@loutrejs/loutre 0.2.0 → 0.4.0

package/dist/adapters/bun.d.ts

@@ -1,22 +1,25 @@
 import { type ApplicationDefinition, type BootstrapArguments, type HasHttp, type HostBindingApplication } from '../application/index.js';
 type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
 type HttpApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasHttp<TDefinition> extends true ? TDefinition : never;
-export type BunServeOptions<TDefinition extends ApplicationDefinition> = {
+export type BunCreateOptions<TDefinition extends ApplicationDefinition> = {
     readonly application: HttpApplication<TDefinition>;
+    readonly environment?: unknown;
+} & BootstrapArguments<TDefinition>;
+export interface BunServeOptions {
     readonly port?: number;
     readonly hostname?: string;
     readonly shutdownHooks?: boolean;
-    readonly environment?: unknown;
-} & BootstrapArguments<TDefinition>;
-export interface BunServeHandle<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
-    readonly application: HostBindingApplication<TDefinition>;
+}
+export interface BunListenerHandle {
     readonly port: number;
-    close(signal?: string): Promise<void>;
 }
+export type BunRuntimeApplication<TDefinition extends ApplicationDefinition = ApplicationDefinition> = HostBindingApplication<TDefinition> & {
+    serve(options?: BunServeOptions): Promise<BunListenerHandle>;
+};
 export declare const bunRuntime: {
     readonly runtime: 'bun';
     readonly capabilities: Set<string>;
-    readonly serve: typeof serve;
+    readonly create: typeof create;
 };
-declare function serve<const TDefinition extends ApplicationDefinition>(options: BunServeOptions<TDefinition>): Promise<BunServeHandle<TDefinition>>;
+declare function create<const TDefinition extends ApplicationDefinition>(options: BunCreateOptions<TDefinition>): Promise<BunRuntimeApplication<TDefinition>>;
 export {};

package/dist/adapters/bun.js

@@ -15,16 +15,13 @@ export const bunRuntime = {
         'env.runtime',
         'crypto.random',
     ]),
-    serve,
+    create,
 };
-async function serve(options) {
+async function create(options) {
     assertRuntimeEngine('bun');
     const bun = bunGlobal();
-    if (!bun?.serve) {
-        throw new Error('LUTRE_BUN_UNAVAILABLE: Bun.serve() is not available.');
-    }
     const startedAt = performance.now();
-    const environment = bun.env ?? {};
+    const environment = bun?.env ?? {};
     const presentation = startStartupPresentation({ version: LOUTRE_VERSION }, {
         terminal: detectPresentationTerminal(process.stdout, environment),
         write: (value) => console.log(value),
@@ -37,53 +34,32 @@ async function serve(options) {
     const http = 'http' in host ? host.http : undefined;
     if (!http) {
         await host.application.close();
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: bunRuntime.serve() requires an HTTP-capable Application.');
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: bunRuntime.create() requires an HTTP-capable Application.');
     }
     await host.application.init();
-    if ('triggers' in host.application)
-        await host.application.triggers.start();
+    const application = host.application;
+    const closeApplication = host.application.close.bind(host.application);
     let server;
-    const requestedPort = options.port;
-    let port = requestedPort ?? 3000;
-    while (true) {
-        try {
-            server = bun.serve({
-                port,
-                ...(options.hostname === undefined
-                    ? {}
-                    : { hostname: options.hostname }),
-                fetch: createBunFetchDriver(http),
-            });
-            break;
-        }
-        catch (error) {
-            if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
-                await host.application.close().catch(() => undefined);
-                throw error;
-            }
-            port += 1;
-        }
-    }
-    presentation.ready({
-        server: serverUrl(options.hostname, port),
-        runtime: `Bun ${bun.version ?? 'unknown'}`,
-        environment: environment.NODE_ENV ?? 'development',
-        startupDurationMs: performance.now() - startedAt,
-    });
+    let removeShutdownHooks;
+    let serving = false;
     let closed = false;
-    const closeRuntime = async (signal) => {
+    const close = async (signal) => {
         if (closed)
             return;
         closed = true;
+        removeShutdownHooks?.();
+        removeShutdownHooks = undefined;
         const errors = [];
-        try {
-            await server.stop(true);
-        }
-        catch (error) {
-            errors.push(error);
+        if (server) {
+            try {
+                await server.stop(true);
+            }
+            catch (error) {
+                errors.push(error);
+            }
         }
         try {
-            await host.application.close(signal);
+            await closeApplication(signal);
         }
         catch (error) {
             errors.push(error);
@@ -91,14 +67,60 @@ async function serve(options) {
         if (errors.length > 0)
             throw new AggregateError(errors, 'Bun runtime shutdown failed');
     };
-    const removeShutdownHooks = options.shutdownHooks === false
-        ? undefined
-        : registerBunShutdownHooks(closeRuntime);
-    const close = async (signal) => {
-        removeShutdownHooks?.();
-        await closeRuntime(signal);
+    const serve = async (serveOptions = {}) => {
+        if (closed) {
+            throw new Error('LUTRE_APP_STOPPED: Application is stopped.');
+        }
+        if (serving) {
+            throw new Error('LUTRE_RUNTIME_ALREADY_SERVING: Bun runtime Application is already serving.');
+        }
+        if (!bun?.serve) {
+            await close().catch(() => undefined);
+            throw new Error('LUTRE_BUN_UNAVAILABLE: Bun.serve() is not available.');
+        }
+        serving = true;
+        try {
+            if ('triggers' in application)
+                await application.triggers.start();
+            const requestedPort = serveOptions.port;
+            let port = requestedPort ?? 3000;
+            while (true) {
+                try {
+                    server = bun.serve({
+                        port,
+                        ...(serveOptions.hostname === undefined
+                            ? {}
+                            : { hostname: serveOptions.hostname }),
+                        fetch: createBunFetchDriver(http),
+                    });
+                    break;
+                }
+                catch (error) {
+                    if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
+                        throw error;
+                    }
+                    port += 1;
+                }
+            }
+            presentation.ready({
+                server: serverUrl(serveOptions.hostname, port),
+                runtime: `Bun ${bun.version ?? 'unknown'}`,
+                environment: environment.NODE_ENV ?? 'development',
+                startupDurationMs: performance.now() - startedAt,
+            });
+            removeShutdownHooks =
+                serveOptions.shutdownHooks === false
+                    ? undefined
+                    : registerBunShutdownHooks(close);
+            return { port };
+        }
+        catch (error) {
+            await close().catch(() => undefined);
+            throw error;
+        }
     };
-    return { application: host.application, port, close };
+    Object.assign(application, { serve, close });
+    return application;
 }
 function registerBunShutdownHooks(close) {
     const handlers = new Map();

package/dist/adapters/deno.d.ts

@@ -5,26 +5,28 @@ export type DenoRuntimeOptions<TDefinition extends ApplicationDefinition> = {
     readonly application: HttpApplication<TDefinition>;
     readonly environment?: unknown;
 } & BootstrapArguments<TDefinition>;
-export type DenoServeOptions<TDefinition extends ApplicationDefinition> = DenoRuntimeOptions<TDefinition> & {
+export type DenoCreateOptions<TDefinition extends ApplicationDefinition> = DenoRuntimeOptions<TDefinition>;
+export interface DenoServeOptions {
     readonly port?: number;
     readonly hostname?: string;
     readonly shutdownHooks?: boolean;
-};
+}
 export interface DenoBinding {
     fetch(request: Request): Promise<Response>;
     close(signal?: string): Promise<void>;
 }
-export interface DenoServeHandle<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
-    readonly application: HostBindingApplication<TDefinition>;
+export interface DenoListenerHandle {
     readonly port: number;
-    close(signal?: string): Promise<void>;
 }
+export type DenoRuntimeApplication<TDefinition extends ApplicationDefinition = ApplicationDefinition> = HostBindingApplication<TDefinition> & {
+    serve(options?: DenoServeOptions): Promise<DenoListenerHandle>;
+};
 export declare const denoRuntime: {
     readonly runtime: 'deno';
     readonly capabilities: Set<string>;
     readonly bind: typeof bind;
-    readonly serve: typeof serve;
+    readonly create: typeof create;
 };
 declare function bind<const TDefinition extends ApplicationDefinition>(options: DenoRuntimeOptions<TDefinition>): DenoBinding;
-declare function serve<const TDefinition extends ApplicationDefinition>(options: DenoServeOptions<TDefinition>): Promise<DenoServeHandle<TDefinition>>;
+declare function create<const TDefinition extends ApplicationDefinition>(options: DenoCreateOptions<TDefinition>): Promise<DenoRuntimeApplication<TDefinition>>;
 export {};

package/dist/adapters/deno.js

@@ -16,7 +16,7 @@ export const denoRuntime = {
         'crypto.random',
     ]),
     bind,
-    serve,
+    create,
 };
 function bind(options) {
     assertRuntimeEngine('deno');
@@ -34,18 +34,15 @@ function bind(options) {
         close: (signal) => invocation.application.close(signal),
     };
 }
-async function serve(options) {
+async function create(options) {
     assertRuntimeEngine('deno');
     const deno = denoGlobal();
-    if (!deno?.serve) {
-        throw new Error('LUTRE_DENO_UNAVAILABLE: Deno.serve() is not available.');
-    }
     const startedAt = performance.now();
-    const isTTY = deno.stdout?.isTerminal?.() === true;
+    const isTTY = deno?.stdout?.isTerminal?.() === true;
     const presentation = startStartupPresentation({ version: LOUTRE_VERSION }, {
         terminal: {
             isTTY,
-            color: isTTY && deno.env?.get?.('NO_COLOR') === undefined,
+            color: isTTY && deno?.env?.get?.('NO_COLOR') === undefined,
         },
         write: (value) => console.log(value),
     });
@@ -53,55 +50,32 @@ async function serve(options) {
     const http = 'http' in host ? host.http : undefined;
     if (!http) {
         await host.application.close();
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.serve() requires an HTTP-capable Application.');
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.create() requires an HTTP-capable Application.');
     }
     await host.application.init();
-    if ('triggers' in host.application)
-        await host.application.triggers.start();
+    const application = host.application;
+    const closeApplication = host.application.close.bind(host.application);
     let server;
-    const requestedPort = options.port;
-    let port = requestedPort ?? 3000;
-    while (true) {
-        try {
-            server = deno.serve({
-                port,
-                ...(options.hostname === undefined
-                    ? {}
-                    : { hostname: options.hostname }),
-                onListen: () => undefined,
-            }, createDenoFetchDriver(http));
-            break;
-        }
-        catch (error) {
-            if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
-                await host.application.close().catch(() => undefined);
-                throw error;
-            }
-            port += 1;
-        }
-    }
-    presentation.ready({
-        server: serverUrl(options.hostname, port),
-        runtime: `Deno ${deno.version?.deno ?? 'unknown'}`,
-        environment: deno.env?.get?.('DENO_ENV') ??
-            deno.env?.get?.('NODE_ENV') ??
-            'development',
-        startupDurationMs: performance.now() - startedAt,
-    });
+    let removeShutdownHooks;
+    let serving = false;
     let closed = false;
-    const closeRuntime = async (signal) => {
+    const close = async (signal) => {
         if (closed)
             return;
         closed = true;
+        removeShutdownHooks?.();
+        removeShutdownHooks = undefined;
         const errors = [];
-        try {
-            await server.shutdown();
-        }
-        catch (error) {
-            errors.push(error);
+        if (server) {
+            try {
+                await server.shutdown();
+            }
+            catch (error) {
+                errors.push(error);
+            }
         }
         try {
-            await host.application.close(signal);
+            await closeApplication(signal);
         }
         catch (error) {
             errors.push(error);
@@ -109,14 +83,62 @@ async function serve(options) {
         if (errors.length > 0)
             throw new AggregateError(errors, 'Deno runtime shutdown failed');
     };
-    const removeShutdownHooks = options.shutdownHooks === false
-        ? undefined
-        : registerDenoShutdownHooks(deno, closeRuntime);
-    const close = async (signal) => {
-        removeShutdownHooks?.();
-        await closeRuntime(signal);
+    const serve = async (serveOptions = {}) => {
+        if (closed) {
+            throw new Error('LUTRE_APP_STOPPED: Application is stopped.');
+        }
+        if (serving) {
+            throw new Error('LUTRE_RUNTIME_ALREADY_SERVING: Deno runtime Application is already serving.');
+        }
+        if (!deno?.serve) {
+            await close().catch(() => undefined);
+            throw new Error('LUTRE_DENO_UNAVAILABLE: Deno.serve() is not available.');
+        }
+        serving = true;
+        try {
+            if ('triggers' in application)
+                await application.triggers.start();
+            const requestedPort = serveOptions.port;
+            let port = requestedPort ?? 3000;
+            while (true) {
+                try {
+                    server = deno.serve({
+                        port,
+                        ...(serveOptions.hostname === undefined
+                            ? {}
+                            : { hostname: serveOptions.hostname }),
+                        onListen: () => undefined,
+                    }, createDenoFetchDriver(http));
+                    break;
+                }
+                catch (error) {
+                    if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
+                        throw error;
+                    }
+                    port += 1;
+                }
+            }
+            presentation.ready({
+                server: serverUrl(serveOptions.hostname, port),
+                runtime: `Deno ${deno.version?.deno ?? 'unknown'}`,
+                environment: deno.env?.get?.('DENO_ENV') ??
+                    deno.env?.get?.('NODE_ENV') ??
+                    'development',
+                startupDurationMs: performance.now() - startedAt,
+            });
+            removeShutdownHooks =
+                serveOptions.shutdownHooks === false
+                    ? undefined
+                    : registerDenoShutdownHooks(deno, close);
+            return { port };
+        }
+        catch (error) {
+            await close().catch(() => undefined);
+            throw error;
+        }
     };
-    return { application: host.application, port, close };
+    Object.assign(application, { serve, close });
+    return application;
 }
 function registerDenoShutdownHooks(deno, close) {
     if (!deno.addSignalListener || !deno.removeSignalListener) {

package/dist/application/binding.js

@@ -109,6 +109,9 @@ function createRuntimeState(options) {
 function createInvocationApplication(state) {
     const application = {
         graph: state.graph,
+        get(token) {
+            return state.runtime.get(token);
+        },
         async init() {
             await state.runtime.initialize();
             return application;

package/dist/application/index.d.ts

@@ -1,4 +1,4 @@
-import type { ArgsClass, ModuleProtocols, ModuleInstance, SchemaInput, TaskArguments, TaskDescriptor, TaskOutput, TriggerDescriptor } from '../core/index.js';
+import type { ArgsClass, ModuleProtocols, ModuleInstance, SchemaInput, TaskArguments, TaskDescriptor, TaskOutput, TokenLike, TokenValue, TriggerDescriptor } from '../core/index.js';
 import type { ApplicationGraphIR } from '../graph/index.js';
 import type { Logger } from '../runtime/index.js';
 export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInstance[], TArguments extends ArgsClass | undefined, TTasks extends readonly TaskDescriptor<any, any>[], TTriggers extends readonly TriggerDescriptor[]> {
@@ -27,6 +27,7 @@ export type BootstrapArguments<TDefinition extends ApplicationDefinition> = TDef
 };
 export interface BaseApplication {
     readonly graph: ApplicationGraphIR;
+    get<TToken extends TokenLike>(token: TToken): TokenValue<TToken>;
     init(): Promise<this>;
     close(signal?: string): Promise<void>;
 }

package/dist/application/openapi.d.ts

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

package/dist/application/openapi.js

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

package/dist/core/contract.d.ts

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