@loutrejs/loutre 0.4.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -12,18 +12,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./host": {
-      "types": "./dist/application/host.d.ts",
-      "import": "./dist/application/host.js"
-    },
-    "./binding": {
-      "types": "./dist/application/binding.d.ts",
-      "import": "./dist/application/binding.js"
-    },
-    "./openapi": {
-      "types": "./dist/application/openapi.d.ts",
-      "import": "./dist/application/openapi.js"
-    },
     "./presentation": {
       "types": "./dist/presentation.d.ts",
       "import": "./dist/presentation.js"
@@ -40,13 +28,17 @@
       "types": "./dist/http/index.d.ts",
       "import": "./dist/http/index.js"
     },
+    "./tasks": {
+      "types": "./dist/tasks/index.d.ts",
+      "import": "./dist/tasks/index.js"
+    },
     "./message-port": {
       "types": "./dist/message-port/index.d.ts",
       "import": "./dist/message-port/index.js"
     },
-    "./message-port/environment": {
-      "types": "./dist/message-port/environment.d.ts",
-      "import": "./dist/message-port/environment.js"
+    "./websocket": {
+      "types": "./dist/websocket/index.d.ts",
+      "import": "./dist/websocket/index.js"
     },
     "./runtime/bun": {
       "types": "./dist/adapters/bun.d.ts",
@@ -67,6 +59,10 @@
     "./runtime/electron": {
       "types": "./dist/adapters/electron.d.ts",
       "import": "./dist/adapters/electron.js"
+    },
+    "./http/openapi": {
+      "types": "./dist/http/openapi.d.ts",
+      "import": "./dist/http/openapi.js"
     }
   },
   "sideEffects": false,

package/dist/application/binding.d.ts

@@ -1,33 +0,0 @@
-import { type ProviderDescriptor, type QueueDescriptor } from '../core/index.js';
-import { type HttpProtocolExecution } from '../http/index.js';
-import { type MessagePortProtocolExecution } from '../message-port/index.js';
-import type { ApplicationDefinition, BootstrapArguments, HasHttp, HasMessagePort, HasTriggers, InvocationApplication, QueueConsumerDriver, TriggerApplicationCapability } from './index.js';
-type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
-type ProtocolBinding<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? {
-    readonly http?: HttpProtocolExecution;
-    readonly messagePort?: MessagePortProtocolExecution;
-} : (HasHttp<TDefinition> extends true ? {
-    readonly http: HttpProtocolExecution;
-} : {}) & (HasMessagePort<TDefinition> extends true ? {
-    readonly messagePort: MessagePortProtocolExecution;
-} : {});
-export type InvocationBinding<TDefinition extends ApplicationDefinition> = {
-    readonly application: InvocationApplication<TDefinition>;
-} & ProtocolBinding<TDefinition>;
-export type HostBindingApplication<TDefinition extends ApplicationDefinition> = InvocationApplication<TDefinition> & (HasTriggers<TDefinition> extends true ? TriggerApplicationCapability : {});
-export type HostBinding<TDefinition extends ApplicationDefinition> = {
-    readonly application: HostBindingApplication<TDefinition>;
-} & ProtocolBinding<TDefinition>;
-export interface InvocationBindingBaseOptions<TDefinition extends ApplicationDefinition> {
-    readonly application: TDefinition;
-    readonly environment?: unknown;
-}
-export type InvocationBindingOptions<TDefinition extends ApplicationDefinition> = InvocationBindingBaseOptions<TDefinition> & BootstrapArguments<TDefinition>;
-interface BindingApi {
-    invocation<const TDefinition extends ApplicationDefinition>(options: InvocationBindingOptions<TDefinition>): InvocationBinding<TDefinition>;
-    host<const TDefinition extends ApplicationDefinition>(options: InvocationBindingOptions<TDefinition>): HostBinding<TDefinition>;
-    queue(descriptor: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;
-}
-/** flatなcreateXXX/bindXXX APIを増殖させないため、外部bindingをnamespaceへ集約する。 */
-export declare const binding: Readonly<BindingApi>;
-export {};

package/dist/application/binding.js

@@ -1,295 +0,0 @@
-import { queueRuntimeToken, validateSchema, } from '../core/index.js';
-import { assertValidCompilation, compileApplication } from '../graph/index.js';
-import { createHttpExecution, } from '../http/index.js';
-import { createMessagePortExecution, } from '../message-port/index.js';
-import { ApplicationRuntime, Logger } from '../runtime/index.js';
-import { bindQueueDriver } from './queue.js';
-import { matchesCronTrigger } from './scheduler.js';
-/** flatなcreateXXX/bindXXX APIを増殖させないため、外部bindingをnamespaceへ集約する。 */
-export const binding = Object.freeze({
-    invocation: createInvocationBinding,
-    host: createHostBinding,
-    queue: bindQueueDriver,
-});
-function createInvocationBinding(options) {
-    const state = createRuntimeState(options);
-    const application = createInvocationApplication(state);
-    return createProtocolBinding(state, application);
-}
-function createHostBinding(options) {
-    const state = createRuntimeState(options);
-    const application = createInvocationApplication(state);
-    let triggersStarted = false;
-    let triggerHandles = [];
-    const stopTriggers = async () => {
-        const handles = triggerHandles;
-        triggerHandles = [];
-        triggersStarted = false;
-        const results = await Promise.allSettled(handles.toReversed().map((handle) => handle.stop()));
-        const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
-        if (errors.length > 0)
-            throw new AggregateError(errors, 'Trigger stop failed');
-    };
-    Object.assign(application, {
-        async close(signal) {
-            state.runtime.stopAcceptingExecutions();
-            const errors = [];
-            try {
-                await stopTriggers();
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            try {
-                await state.runtime.shutdown(signal);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            if (errors.length > 0)
-                throw new AggregateError(errors, 'Application shutdown failed');
-        },
-        ...(state.definition.triggers.length > 0
-            ? {
-                triggers: {
-                    async start() {
-                        if (triggersStarted) {
-                            throw new Error('LUTRE_TRIGGERS_ALREADY_STARTED: Trigger Engine is already started.');
-                        }
-                        await state.runtime.initialize();
-                        triggersStarted = true;
-                        const started = [];
-                        try {
-                            for (const trigger of state.definition.triggers) {
-                                started.push(await startTrigger(trigger, state.runtime, state.logger));
-                            }
-                            triggerHandles = started;
-                        }
-                        catch (error) {
-                            await Promise.allSettled(started.toReversed().map((handle) => handle.stop()));
-                            triggersStarted = false;
-                            throw error;
-                        }
-                    },
-                    stop: stopTriggers,
-                },
-            }
-            : {}),
-    });
-    return createProtocolBinding(state, application);
-}
-function createRuntimeState(options) {
-    const definition = options.application;
-    const logger = definition.logger ?? new Logger();
-    const tasks = registeredTasks(definition);
-    const graph = assertValidCompilation(compileApplication({
-        modules: definition.modules,
-        ...(definition.arguments === undefined
-            ? {}
-            : { arguments: definition.arguments }),
-        tasks: definition.tasks,
-        triggers: definition.triggers,
-    }));
-    const runtime = new ApplicationRuntime(definition.modules, {
-        logger,
-        tasks,
-        publicTasks: definition.tasks,
-        ...(definition.arguments === undefined
-            ? {}
-            : {
-                arguments: definition.arguments,
-                argumentsSource: 'arguments' in options ? options.arguments : Object.freeze({}),
-            }),
-        ...('environment' in options
-            ? { environmentSource: options.environment }
-            : {}),
-    });
-    return { definition, logger, runtime, graph };
-}
-function createInvocationApplication(state) {
-    const application = {
-        graph: state.graph,
-        get(token) {
-            return state.runtime.get(token);
-        },
-        async init() {
-            await state.runtime.initialize();
-            return application;
-        },
-        ...(state.definition.tasks.length > 0
-            ? {
-                run(task, ...args) {
-                    return Reflect.apply(state.runtime.run, state.runtime, [
-                        task,
-                        ...args,
-                    ]);
-                },
-            }
-            : {}),
-        close: (signal) => state.runtime.shutdown(signal),
-    };
-    return application;
-}
-function createProtocolBinding(state, application) {
-    const protocols = new Set(state.graph.pipelines.map((pipeline) => pipeline.protocol));
-    return {
-        application,
-        ...(protocols.has('http')
-            ? {
-                http: createHttpExecution({
-                    runtime: state.runtime,
-                    graph: state.graph,
-                    logger: state.logger,
-                }),
-            }
-            : {}),
-        ...(protocols.has('messagePort')
-            ? {
-                messagePort: createMessagePortExecution({
-                    runtime: state.runtime,
-                    graph: state.graph,
-                    logger: state.logger,
-                }),
-            }
-            : {}),
-    };
-}
-async function startTrigger(trigger, runtime, logger) {
-    switch (trigger.trigger) {
-        case 'cron':
-            return startCronTrigger(trigger, runtime, logger);
-        case 'fixed-delay':
-            return startFixedDelayTrigger(trigger, runtime, logger);
-        case 'queue-consumer':
-            return startQueueTrigger(trigger, runtime);
-    }
-    throw new Error('LUTRE_TRIGGER_UNSUPPORTED: Unsupported trigger type.');
-}
-function startCronTrigger(trigger, runtime, logger) {
-    let stopped = false;
-    let lastMinute;
-    const active = new Set();
-    const tick = () => {
-        if (stopped)
-            return;
-        const now = new Date();
-        if (!matchesCronTrigger(trigger, now))
-            return;
-        const minute = cronMinuteIdentity(trigger.timezone, now);
-        if (lastMinute === minute)
-            return;
-        lastMinute = minute;
-        if (trigger.overlap === 'skip' && active.size > 0) {
-            logger.info('Cron trigger skipped overlapping execution', {
-                event: 'trigger.cron.skipped',
-                trigger: trigger.name,
-            });
-            return;
-        }
-        const execution = runtime.runTask(trigger.task).catch((error) => {
-            logger.error('Cron trigger execution failed', {
-                event: 'trigger.cron.execution.failed',
-                trigger: trigger.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-        active.add(execution);
-        void execution.finally(() => active.delete(execution));
-    };
-    tick();
-    const timer = setInterval(tick, 1_000);
-    return {
-        async stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            clearInterval(timer);
-            await Promise.allSettled(active);
-        },
-    };
-}
-function startFixedDelayTrigger(trigger, runtime, logger) {
-    let stopped = false;
-    let timer;
-    let releaseSleep;
-    const sleep = () => new Promise((resolve) => {
-        releaseSleep = resolve;
-        timer = setTimeout(() => {
-            timer = undefined;
-            releaseSleep = undefined;
-            resolve();
-        }, trigger.delay);
-    });
-    const execute = async () => {
-        try {
-            await runtime.runTask(trigger.task);
-        }
-        catch (error) {
-            logger.error('Fixed-delay trigger execution failed', {
-                event: 'trigger.fixed_delay.execution.failed',
-                trigger: trigger.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    };
-    const loop = (async () => {
-        if (!trigger.immediate)
-            await sleep();
-        while (true) {
-            if (stopped)
-                break;
-            await execute();
-            if (stopped)
-                break;
-            await sleep();
-        }
-    })();
-    return {
-        async stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            if (timer)
-                clearTimeout(timer);
-            timer = undefined;
-            releaseSleep?.();
-            releaseSleep = undefined;
-            await loop;
-        },
-    };
-}
-async function startQueueTrigger(trigger, runtime) {
-    const driver = runtime.container.resolve(queueRuntimeToken(trigger.queue));
-    if (!driver || typeof driver.start !== 'function') {
-        throw new Error(`LUTRE_QUEUE_DRIVER_INVALID: Queue ${trigger.queue.name} driver is invalid.`);
-    }
-    const handle = await driver.start({
-        consume: async (payload) => {
-            const validated = await validateSchema(trigger.queue.payload, payload);
-            await runtime.runTask(trigger.task, validated);
-        },
-    });
-    if (!handle || typeof handle.stop !== 'function') {
-        throw new Error(`LUTRE_QUEUE_DRIVER_INVALID: Queue ${trigger.queue.name} driver returned an invalid handle.`);
-    }
-    return handle;
-}
-function registeredTasks(definition) {
-    return [
-        ...new Set([
-            ...definition.tasks,
-            ...definition.triggers.map((trigger) => trigger.task),
-        ]),
-    ];
-}
-function cronMinuteIdentity(timezone, instant) {
-    return new Intl.DateTimeFormat('en-CA', {
-        timeZone: timezone,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        hourCycle: 'h23',
-    }).format(instant);
-}

package/dist/application/host.d.ts

@@ -1,8 +0,0 @@
-import type { ApplicationDefinition, BootstrapArguments, HostedApplication } from './index.js';
-export interface BootstrapBaseOptions<TDefinition extends ApplicationDefinition> {
-    readonly application: TDefinition;
-    readonly environment?: unknown;
-}
-export type BootstrapOptions<TDefinition extends ApplicationDefinition> = BootstrapBaseOptions<TDefinition> & BootstrapArguments<TDefinition>;
-/** generic hostへruntime固有listenerを持ち込まないため、listener ownershipはruntime adapterへ委ねる。 */
-export declare function bootstrap<const TDefinition extends ApplicationDefinition>(options: BootstrapOptions<TDefinition>): HostedApplication<TDefinition>;

package/dist/application/host.js

@@ -1,14 +0,0 @@
-import { binding } from './binding.js';
-/** generic hostへruntime固有listenerを持ち込まないため、listener ownershipはruntime adapterへ委ねる。 */
-export function bootstrap(options) {
-    const host = binding.host(options);
-    const http = 'http' in host ? host.http : undefined;
-    if (http) {
-        Object.assign(host.application, {
-            fetch(request) {
-                return http.handle(request);
-            },
-        });
-    }
-    return host.application;
-}

package/dist/application/queue.d.ts

@@ -1,3 +0,0 @@
-import { type ProviderDescriptor, type QueueDescriptor } from '../core/index.js';
-import type { QueueConsumerDriver } from './index.js';
-export declare function bindQueueDriver(queue: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;

package/dist/application/queue.js

@@ -1,4 +0,0 @@
-import { provide, queueRuntimeToken, } from '../core/index.js';
-export function bindQueueDriver(queue, driver) {
-    return provide(queueRuntimeToken(queue)).useValue(driver);
-}

package/dist/application/scheduler.d.ts

@@ -1,2 +0,0 @@
-import type { CronTriggerDescriptor } from '../core/index.js';
-export declare function matchesCronTrigger(trigger: CronTriggerDescriptor<any>, instant: Date): boolean;

package/dist/application/scheduler.js

@@ -1,45 +0,0 @@
-export function matchesCronTrigger(trigger, instant) {
-    const [minute, hour, dayOfMonth, month, dayOfWeek] = trigger.expression
-        .trim()
-        .split(/\s+/);
-    const fields = { minute, hour, dayOfMonth, month, dayOfWeek };
-    const parts = new Intl.DateTimeFormat('en-US', {
-        timeZone: trigger.timezone,
-        minute: 'numeric',
-        hour: 'numeric',
-        day: 'numeric',
-        month: 'numeric',
-        weekday: 'short',
-        hourCycle: 'h23',
-    }).formatToParts(instant);
-    const value = (type) => parts.find((part) => part.type === type)?.value ?? '';
-    const weekday = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(value('weekday'));
-    return (matchesCronField(fields.minute, Number(value('minute')), 0, 59) &&
-        matchesCronField(fields.hour, Number(value('hour')), 0, 23) &&
-        matchesCronField(fields.dayOfMonth, Number(value('day')), 1, 31) &&
-        matchesCronField(fields.month, Number(value('month')), 1, 12) &&
-        matchesCronField(fields.dayOfWeek, weekday, 0, 7, true));
-}
-function matchesCronField(expression, value, minimum, maximum, sundayAlias = false) {
-    return expression.split(',').some((segment) => {
-        const [rangeExpression, stepExpression] = segment.split('/');
-        const step = stepExpression === undefined ? 1 : Number(stepExpression);
-        if (!Number.isInteger(step) || step <= 0 || !rangeExpression)
-            return false;
-        let start = minimum;
-        let end = maximum;
-        if (rangeExpression !== '*') {
-            const [startExpression, endExpression] = rangeExpression.split('-');
-            start = Number(startExpression);
-            end = endExpression === undefined ? start : Number(endExpression);
-        }
-        const normalized = sundayAlias && value === 0 && start === 7 ? 7 : value;
-        return (Number.isInteger(start) &&
-            Number.isInteger(end) &&
-            start >= minimum &&
-            end <= maximum &&
-            normalized >= start &&
-            normalized <= end &&
-            (normalized - start) % step === 0);
-    });
-}

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

@@ -1,14 +0,0 @@
-export interface ContextKey<TName extends string = string, TValue = unknown> {
-    readonly kind: 'context-key';
-    readonly name: TName;
-    readonly key: symbol;
-    readonly '~value'?: TValue;
-}
-export type ContextKeyValue<TKey> = TKey extends ContextKey<string, infer TValue> ? TValue : never;
-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): {
-    of<TValue>(): ContextKey<TName, TValue>;
-};
-export declare function contextKeyName(key: ContextKey): string;

package/dist/core/context-key.js

@@ -1,14 +0,0 @@
-export function contextKey(name) {
-    return {
-        of() {
-            return Object.freeze({
-                kind: 'context-key',
-                name,
-                key: Symbol(name),
-            });
-        },
-    };
-}
-export function contextKeyName(key) {
-    return key.name;
-}

package/dist/core/contract.d.ts

@@ -1,94 +0,0 @@
-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;
-}
-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 {
-            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;
-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;
-    readonly capabilities?: TCapabilities;
-}
-export {};