@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/http/runtime/response.js

@@ -0,0 +1,108 @@
+import { validateSchema } from '../../core/index.js';
+export async function validateResponseHeaders(schema, headers) {
+    if (!schema) {
+        if (headers !== undefined) {
+            throw new Error('Undeclared HTTP response header was returned');
+        }
+        return undefined;
+    }
+    const validated = await validateSchema(schema, headers);
+    if (validated === undefined)
+        return undefined;
+    if (!isHttpHeaders(validated)) {
+        throw new Error('HTTP response header schema produced an invalid value');
+    }
+    return validated;
+}
+export function responseHeadersSchema(headers) {
+    if (isStandardSchema(headers))
+        return headers;
+    if (isResponseHeadersWithDefaults(headers))
+        return headers.schema;
+    return undefined;
+}
+export function responseHeadersDefaults(headers) {
+    if (headers === undefined || isStandardSchema(headers))
+        return undefined;
+    if (isResponseHeadersWithDefaults(headers))
+        return headers.defaults;
+    return headers;
+}
+export function isStandardSchema(value) {
+    return typeof value === 'object' && value !== null && '~standard' in value;
+}
+export function isResponseHeadersWithDefaults(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'schema' in value &&
+        isStandardSchema(value.schema));
+}
+export function mergeResponseHeaders(defaults, dynamic) {
+    const headers = new Headers();
+    applyResponseHeaders(headers, defaults);
+    applyResponseHeaders(headers, dynamic);
+    return headers;
+}
+export function applyResponseHeaders(headers, source) {
+    if (!source)
+        return;
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        headers.delete(name);
+        if (typeof value === 'string') {
+            headers.set(name, value);
+            continue;
+        }
+        for (const item of value)
+            headers.append(name, item);
+    }
+}
+export function applyFrameworkHeadersToResponse(response, source) {
+    if (!source)
+        return response;
+    const headers = new Headers(response.headers);
+    applyFrameworkResponseHeaders(headers, Object.fromEntries(source.entries()));
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+export function applyFrameworkResponseHeaders(headers, source) {
+    if (!source)
+        return;
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        if (name.toLowerCase() === 'vary') {
+            const values = typeof value === 'string' ? [value] : value;
+            for (const item of values.flatMap((header) => header.split(','))) {
+                appendVary(headers, item.trim());
+            }
+            continue;
+        }
+        applyResponseHeaders(headers, { [name]: value });
+    }
+}
+function isHttpHeaders(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((header) => header === undefined ||
+        typeof header === 'string' ||
+        (Array.isArray(header) &&
+            header.every((item) => typeof item === 'string')));
+}
+function appendVary(headers, value) {
+    if (value.length === 0)
+        return;
+    const values = (headers.get('vary') ?? '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+        values.push(value);
+    }
+    headers.set('vary', values.join(', '));
+}

package/dist/index.d.ts

@@ -1,2 +1,6 @@
 export * from './core/index.js';
 export * from './application/index.js';
+export { projectApplicationModel } from './graph/model.js';
+export type { ApplicationModelGraphIR, GraphEdgeIR, GraphNodeIR, JsonValue, } from './graph/model.js';
+export { ApplicationKernelRuntime } from './runtime/kernel.js';
+export type { ApplicationKernelRuntimeOptions } from './runtime/kernel.js';

package/dist/index.js

@@ -1,2 +1,4 @@
 export * from './core/index.js';
 export * from './application/index.js';
+export { projectApplicationModel } from './graph/model.js';
+export { ApplicationKernelRuntime } from './runtime/kernel.js';

package/dist/message-port/extension.d.ts

@@ -0,0 +1,66 @@
+import { type ExecutionDefinition, type ExecutionExtension, type ExecutionExtensionDrainContext, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
+export interface MessagePortServerStreamResponseDefinition {
+    readonly body: StandardSchemaV1;
+    readonly stream: 'server';
+}
+export type MessagePortResponseDefinition = StandardSchemaV1 | MessagePortServerStreamResponseDefinition;
+export interface MessagePortRouteDefinition {
+    readonly input?: StandardSchemaV1;
+    readonly responses: Readonly<Record<string, MessagePortResponseDefinition>>;
+}
+export interface MessagePortContract<TRoutes extends Readonly<Record<string, MessagePortRouteDefinition>> = Readonly<Record<string, MessagePortRouteDefinition>>> {
+    readonly kind: 'message-port-contract';
+    readonly routes: TRoutes;
+}
+export interface MessagePortResult<TVariant extends string = string, TValue = unknown> {
+    readonly kind: 'message-port-result';
+    readonly response: TVariant;
+    readonly value: TValue;
+}
+type MessagePortResponseValue<TResponse extends MessagePortResponseDefinition> = TResponse extends MessagePortServerStreamResponseDefinition ? AsyncIterable<SchemaOutput<TResponse['body']>> : TResponse extends StandardSchemaV1 ? SchemaOutput<TResponse> : never;
+type ResponseHelpers<TRoute extends MessagePortRouteDefinition> = {
+    readonly [TVariant in keyof TRoute['responses'] & string]: (value: MessagePortResponseValue<TRoute['responses'][TVariant]>) => MessagePortResult<TVariant, MessagePortResponseValue<TRoute['responses'][TVariant]>>;
+};
+export interface MessagePortContext<TRoute extends MessagePortRouteDefinition = MessagePortRouteDefinition> {
+    readonly input: TRoute['input'] extends StandardSchemaV1 ? SchemaOutput<TRoute['input']> : unknown;
+    readonly response: ResponseHelpers<TRoute>;
+    readonly signal: AbortSignal;
+}
+export type MessagePortHandlers<TContract extends MessagePortContract> = {
+    readonly [TName in keyof TContract['routes']]: (context: MessagePortContext<TContract['routes'][TName]>) => MessagePortResult | Promise<MessagePortResult>;
+};
+export interface MessagePortImplementationData<TContract extends MessagePortContract = MessagePortContract> {
+    readonly name: string;
+    readonly contract: TContract;
+    readonly factory: () => MessagePortHandlers<TContract>;
+}
+interface CompiledMessagePortExecution {
+    readonly routes: MessagePortContract['routes'];
+    readonly factory: () => Readonly<Record<string, (context: MessagePortContext) => MessagePortResult | Promise<MessagePortResult>>>;
+}
+export interface MessagePortExtensionRuntime {
+    invoke(method: string, input?: unknown): Promise<MessagePortResult>;
+    drain(context: ExecutionExtensionDrainContext): Promise<void>;
+}
+export interface MessagePortHostApi {
+    invoke(method: string, input?: unknown): Promise<MessagePortResult>;
+}
+declare const messagePortExecutionExtensionIdentity: unique symbol;
+export declare const messagePortExtension: ExecutionExtension<MessagePortImplementationData & ExecutionDefinition, CompiledMessagePortExecution, 'messagePort', MessagePortHostApi, MessagePortExtensionRuntime> & {
+    readonly [messagePortExecutionExtensionIdentity]: true;
+};
+export type MessagePortExecutionDefinition<TContract extends MessagePortContract = MessagePortContract> = MessagePortImplementationData<TContract> & ExecutionDefinition<typeof messagePortExtension>;
+export declare function defineMessagePortContract<const TRoutes extends Readonly<Record<string, MessagePortRouteDefinition>>>(routes: TRoutes): MessagePortContract<TRoutes>;
+export declare function defineMessagePortImplementation<const TContract extends MessagePortContract>(definition: {
+    readonly name?: string;
+    readonly contract: TContract;
+    readonly factory: MessagePortImplementationData<TContract>['factory'];
+}): MessagePortExecutionDefinition<TContract>;
+export declare const messagePort: Readonly<{
+    contract: typeof defineMessagePortContract;
+    implementation: typeof defineMessagePortImplementation;
+    extension: ExecutionExtension<MessagePortImplementationData<MessagePortContract<Readonly<Record<string, MessagePortRouteDefinition>>>> & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledMessagePortExecution, "messagePort", MessagePortHostApi, MessagePortExtensionRuntime> & {
+        readonly [messagePortExecutionExtensionIdentity]: true;
+    };
+}>;
+export {};

package/dist/message-port/extension.js

@@ -0,0 +1,411 @@
+import { collectInjectedDependencies, defineExecution, defineExecutionExtension, runInInjectionContext, validateSchema, } from '../core/index.js';
+import { IngressGate } from '../runtime/ingress-gate.js';
+import { AsyncIteratorCleanupDeadlineError, AsyncIteratorLifecycle, } from '../runtime/async-iterator-lifecycle.js';
+export const messagePortExtension = defineExecutionExtension({
+    kind: 'execution-extension',
+    abiVersion: '1',
+    name: 'loutre:message-port',
+    compile(definition, context) {
+        return {
+            kind: 'execution',
+            id: definition.name ||
+                `${context.moduleId}.message-port.${context.definitionIndex}`,
+            executionKind: 'message-port.invocation',
+            dependencies: collectInjectedDependencies({
+                kind: 'execution',
+                id: `message-port:${definition.name || `${context.moduleId}.message-port.${context.definitionIndex}`}`,
+                name: definition.name ||
+                    `${context.moduleId}.message-port.${context.definitionIndex}`,
+            }, () => definition.factory()),
+            capabilities: [],
+            compiled: Object.freeze({
+                routes: snapshotMessagePortRoutes(definition.contract.routes),
+                factory: definition.factory,
+            }),
+        };
+    },
+    validate({ executions }) {
+        const methods = new Set();
+        return executions.flatMap((execution) => Object.keys(execution.compiled.routes).flatMap((method) => {
+            if (!methods.has(method)) {
+                methods.add(method);
+                return [];
+            }
+            return [
+                {
+                    code: 'LUTRE_MESSAGE_PORT_DUPLICATE_METHOD',
+                    message: `MessagePort method ${method} is declared more than once.`,
+                    path: execution.id,
+                },
+            ];
+        }));
+    },
+    createRuntime({ executions, applicationRuntime }) {
+        return createMessagePortRuntime(executions, applicationRuntime);
+    },
+    projectGraph: ({ execution }) => ({
+        methods: Object.keys(execution.compiled.routes),
+    }),
+    host: {
+        namespace: 'messagePort',
+        create: ({ runtime }) => ({
+            invoke: (method, input) => runtime.invoke(method, input),
+        }),
+    },
+});
+export function defineMessagePortContract(routes) {
+    return Object.freeze({ kind: 'message-port-contract', routes });
+}
+export function defineMessagePortImplementation(definition) {
+    return defineExecution(messagePortExtension, {
+        name: definition.name ?? '',
+        contract: definition.contract,
+        factory: definition.factory,
+    });
+}
+export const messagePort = Object.freeze({
+    contract: defineMessagePortContract,
+    implementation: defineMessagePortImplementation,
+    extension: messagePortExtension,
+});
+function snapshotMessagePortRoutes(routes) {
+    return Object.freeze(Object.fromEntries(Object.entries(routes).map(([name, route]) => [
+        name,
+        Object.freeze({
+            ...(route.input === undefined ? {} : { input: route.input }),
+            responses: Object.freeze(Object.fromEntries(Object.entries(route.responses).map(([response, definition]) => [
+                response,
+                isMessagePortServerStreamResponse(definition)
+                    ? Object.freeze({ ...definition })
+                    : definition,
+            ]))),
+        }),
+    ])));
+}
+function createMessagePortRuntime(executions, applicationRuntime) {
+    const routes = new Map();
+    const ingress = new IngressGate();
+    const activeStreams = new Set();
+    for (const execution of executions) {
+        const handlers = runInInjectionContext({
+            consumer: {
+                kind: 'execution',
+                id: `message-port:${execution.id}`,
+                name: execution.id,
+            },
+            resolve: (token) => applicationRuntime.resolve(token, execution.id),
+        }, () => execution.compiled.factory());
+        for (const [method, definition] of Object.entries(execution.compiled.routes)) {
+            const handler = handlers[method];
+            if (handler) {
+                routes.set(method, {
+                    executionId: execution.id,
+                    route: definition,
+                    handler,
+                });
+            }
+        }
+    }
+    return {
+        async invoke(method, input) {
+            const completePendingIngress = ingress.enter();
+            if (!completePendingIngress) {
+                throw new Error('LUTRE_MESSAGE_PORT_DRAINING');
+            }
+            const route = routes.get(method);
+            if (!route) {
+                completePendingIngress();
+                throw new Error(`LUTRE_MESSAGE_PORT_METHOD_NOT_FOUND: ${method}`);
+            }
+            let lease;
+            try {
+                lease = applicationRuntime.beginExecution({
+                    executionId: route.executionId,
+                    executionKind: 'message-port.invocation',
+                    graphNodeId: route.executionId,
+                    name: method,
+                });
+            }
+            catch (error) {
+                completePendingIngress();
+                throw error;
+            }
+            let executionOwnedByStream = false;
+            try {
+                const value = route.route.input
+                    ? await validateSchema(route.route.input, input)
+                    : input;
+                const response = Object.fromEntries(Object.keys(route.route.responses).map((name) => [
+                    name,
+                    (result) => ({
+                        kind: 'message-port-result',
+                        response: name,
+                        value: result,
+                    }),
+                ]));
+                const invoke = () => route.handler({
+                    input: value,
+                    response,
+                    signal: lease.signal,
+                });
+                const result = await (lease.run ? lease.run(invoke) : invoke());
+                const schema = route.route.responses[result.response];
+                if (!schema) {
+                    throw new Error(`LUTRE_MESSAGE_PORT_RESPONSE_UNDECLARED: ${result.response}`);
+                }
+                if (isMessagePortServerStreamResponse(schema)) {
+                    if (!isAsyncIterable(result.value)) {
+                        throw new TypeError('LUTRE_MESSAGE_PORT_STREAM_REQUIRED');
+                    }
+                    const stream = createLeasedMessagePortStream(schema.body, result.value, lease, activeStreams);
+                    executionOwnedByStream = true;
+                    return { ...result, value: stream };
+                }
+                return {
+                    ...result,
+                    value: await validateSchema(schema, result.value),
+                };
+            }
+            catch (error) {
+                lease.fail?.(error);
+                throw error;
+            }
+            finally {
+                if (!executionOwnedByStream)
+                    lease.complete();
+                completePendingIngress();
+            }
+        },
+        async drain({ timeoutMs }) {
+            ingress.stopAccepting();
+            const deadline = Date.now() + timeoutMs;
+            await ingress.waitForIdle();
+            const reason = new Error('LUTRE_MESSAGE_PORT_DRAINING');
+            const results = await Promise.allSettled([...activeStreams].map((stream) => stream.abort(reason, deadline)));
+            const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'MessagePort stream drain failed.');
+            }
+        },
+    };
+}
+function createLeasedMessagePortStream(schema, source, lease, activeStreams) {
+    const iterator = new AsyncIteratorLifecycle(source[Symbol.asyncIterator]());
+    let finished = false;
+    let completed = false;
+    let inFlightOperations = 0;
+    let cancellationSettled = true;
+    let cancellation;
+    let iteratorCleanup;
+    let iteratorCleanupDeadline;
+    let iteratorCleanupComplete = false;
+    let resolveCompleted;
+    const completedPromise = new Promise((resolve) => {
+        resolveCompleted = resolve;
+    });
+    let control;
+    const markFinished = () => {
+        if (finished)
+            return false;
+        finished = true;
+        lease.signal.removeEventListener('abort', onAbort);
+        return true;
+    };
+    const completeIfSafe = () => {
+        if (completed ||
+            !finished ||
+            !cancellationSettled ||
+            inFlightOperations > 0) {
+            return;
+        }
+        completed = true;
+        activeStreams.delete(control);
+        try {
+            lease.complete();
+        }
+        finally {
+            resolveCompleted();
+        }
+    };
+    const startIteratorCleanup = (reason, deadline) => {
+        if (iteratorCleanup) {
+            if (deadline !== undefined) {
+                iteratorCleanupDeadline = Math.min(iteratorCleanupDeadline ?? deadline, deadline);
+            }
+            return iteratorCleanup;
+        }
+        if (deadline !== undefined)
+            iteratorCleanupDeadline = deadline;
+        markFinished();
+        if (iteratorCleanupComplete)
+            return Promise.resolve();
+        cancellationSettled = false;
+        const operation = (async () => {
+            try {
+                await iterator.drain(reason, () => iteratorCleanupDeadline, 'MessagePort iterator cleanup exceeded the drain deadline.');
+            }
+            catch (error) {
+                if (error instanceof AsyncIteratorCleanupDeadlineError)
+                    throw error;
+                iteratorCleanupComplete = true;
+                cancellationSettled = true;
+                throw error;
+            }
+            finally {
+                if (iterator.done)
+                    iteratorCleanupComplete = true;
+                if (iteratorCleanupComplete)
+                    cancellationSettled = true;
+                completeIfSafe();
+            }
+        })();
+        iteratorCleanup = operation;
+        void operation.then(() => {
+            if (iteratorCleanup === operation)
+                iteratorCleanup = undefined;
+        }, () => {
+            if (iteratorCleanup === operation)
+                iteratorCleanup = undefined;
+        });
+        return operation;
+    };
+    const cancel = (reason) => {
+        if (cancellation)
+            return cancellation;
+        cancellation = (async () => {
+            let cleanupError;
+            try {
+                await startIteratorCleanup(reason);
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+            await completedPromise;
+            if (cleanupError !== undefined)
+                throw cleanupError;
+        })();
+        return cancellation;
+    };
+    const onAbort = () => {
+        // AbortSignalはasync cleanup errorを返せないため、error伝播が必要なdrainはcontrol.abort()を直接awaitする。
+        void cancel(lease.signal.reason).catch(() => undefined);
+    };
+    control = {
+        async abort(reason, deadline) {
+            iteratorCleanupDeadline = deadline;
+            lease.abort(reason);
+            const cleanup = startIteratorCleanup(reason, deadline);
+            await cleanup;
+            await completedPromise;
+        },
+    };
+    activeStreams.add(control);
+    if (lease.signal.aborted)
+        onAbort();
+    else
+        lease.signal.addEventListener('abort', onAbort, { once: true });
+    const closeAfterError = async (error) => {
+        lease.fail?.(error);
+        let cleanupError;
+        try {
+            await startIteratorCleanup(error);
+        }
+        catch (caught) {
+            cleanupError = caught;
+        }
+        if (cleanupError !== undefined) {
+            throw new AggregateError([error, cleanupError], 'MessagePort stream validation and cleanup failed.', { cause: error });
+        }
+        throw error;
+    };
+    const validateResult = async (result) => {
+        if (result.done) {
+            markFinished();
+            return result;
+        }
+        try {
+            return {
+                done: false,
+                value: await validateSchema(schema, result.value),
+            };
+        }
+        catch (error) {
+            return closeAfterError(error);
+        }
+    };
+    const wrapped = {
+        async next() {
+            if (finished)
+                return { done: true, value: undefined };
+            inFlightOperations += 1;
+            try {
+                return await validateResult(await iterator.next());
+            }
+            catch (error) {
+                if (finished)
+                    throw error;
+                return await closeAfterError(error);
+            }
+            finally {
+                inFlightOperations -= 1;
+                completeIfSafe();
+            }
+        },
+        async return(reason) {
+            if (finished)
+                return { done: true, value: reason };
+            inFlightOperations += 1;
+            try {
+                const result = await iterator.return(reason);
+                if (result.done) {
+                    markFinished();
+                }
+                return result;
+            }
+            catch (error) {
+                markFinished();
+                throw error;
+            }
+            finally {
+                inFlightOperations -= 1;
+                completeIfSafe();
+            }
+        },
+        async throw(error) {
+            if (finished)
+                throw error;
+            inFlightOperations += 1;
+            try {
+                return await validateResult(await iterator.throw(error));
+            }
+            catch (caught) {
+                if (finished)
+                    throw caught;
+                return await closeAfterError(caught);
+            }
+            finally {
+                inFlightOperations -= 1;
+                completeIfSafe();
+            }
+        },
+    };
+    return {
+        [Symbol.asyncIterator]() {
+            return wrapped;
+        },
+        cancel,
+    };
+}
+function isMessagePortServerStreamResponse(response) {
+    return (typeof response === 'object' &&
+        response !== null &&
+        'stream' in response &&
+        response.stream === 'server' &&
+        'body' in response);
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}

package/dist/message-port/index.d.ts

@@ -1,73 +1,4 @@
-import { type ContextProvidedBeforeTerminal, type IsValidProtocolPipeline, type ContractDefinition, type PipelineItem, type ProtocolDescriptor, type ProtocolFactory, type ProtocolGroup, type SchemaOutput, type StandardSchemaV1, type TerminalLayerDescriptor } from '../core/index.js';
-import type { ApplicationGraphIR } from '../graph/index.js';
-import { ApplicationRuntime, Logger } from '../runtime/index.js';
-export interface MessagePortResponseDefinition {
-    readonly body: StandardSchemaV1;
-    readonly stream?: 'server';
-}
-export interface MessagePortProtocolDefinition {
-    readonly interaction?: 'unary' | 'server-stream';
-    readonly responses: Readonly<Record<string, MessagePortResponseDefinition>>;
-    readonly pipeline: readonly PipelineItem[];
-}
-export interface MessagePortProtocol<TDefinition extends MessagePortProtocolDefinition = MessagePortProtocolDefinition> extends ProtocolDescriptor<'messagePort', MessagePortHandlerContextDefinition<TDefinition>, LogicalMessagePortResult> {
-    readonly definition: TDefinition;
-}
-declare function defineMessagePort<const TDefinition extends MessagePortProtocolDefinition>(definition: TDefinition & MessagePortPipelineConstraint<TDefinition>): MessagePortProtocol<TDefinition>;
-type MessagePortPipelineConstraint<TDefinition extends MessagePortProtocolDefinition> = IsValidProtocolPipeline<TDefinition['pipeline'], 'messagePort'> extends true ? unknown : {
-    readonly pipeline: never;
-};
-type MessagePortProtocolGroup<TDefinitions extends Record<string, MessagePortProtocolDefinition>> = ProtocolGroup<'messagePort', {
-    [K in keyof TDefinitions]: MessagePortProtocol<TDefinitions[K]>;
-}>;
-type MessagePortDefinitionsConstraint<TDefinitions extends Record<string, MessagePortProtocolDefinition>> = {
-    [K in keyof TDefinitions]: TDefinitions[K] & MessagePortPipelineConstraint<TDefinitions[K]>;
-};
-export interface MessagePortProtocolFactory extends ProtocolFactory<'messagePort'> {
-    <const TDefinitions extends Record<string, MessagePortProtocolDefinition>>(definitions: TDefinitions & MessagePortDefinitionsConstraint<TDefinitions>): MessagePortProtocolGroup<TDefinitions>;
-    readonly route: typeof defineMessagePort;
-    readonly handler: TerminalLayerDescriptor<'messagePort'>;
-}
-export declare const messagePort: MessagePortProtocolFactory;
-export interface LogicalMessagePortResult<TVariant extends string = string, TValue = unknown> {
-    readonly kind: 'message-port-result';
-    readonly variant: TVariant;
-    readonly value: TValue;
-}
-type ProceduresForMessagePort<TContract extends ContractDefinition> = {
-    [K in keyof TContract['procedures']]: 'messagePort' extends keyof TContract['procedures'][K]['protocols'] ? K : never;
-}[keyof TContract['procedures']] & string;
-type ProtocolAt<TContract extends ContractDefinition, TProcedure extends keyof TContract['procedures']> = TContract['procedures'][TProcedure]['protocols']['messagePort' & keyof TContract['procedures'][TProcedure]['protocols']] extends infer TProtocol ? TProtocol extends MessagePortProtocol ? TProtocol : never : never;
-type MessageHelpers<TProtocol extends MessagePortProtocol> = {
-    [TVariant in keyof TProtocol['definition']['responses'] & string]: (value: TProtocol['definition']['responses'][TVariant] extends {
-        readonly stream: 'server';
-    } ? AsyncIterable<SchemaOutput<TProtocol['definition']['responses'][TVariant]['body']>> : SchemaOutput<TProtocol['definition']['responses'][TVariant]['body']>) => LogicalMessagePortResult;
-};
-type MessagePortHandlerContextDefinition<TDefinition extends MessagePortProtocolDefinition> = {
-    readonly input: unknown;
-    readonly message: MessageHelpers<MessagePortProtocol<TDefinition>>;
-    readonly logger: Logger;
-} & ContextProvidedBeforeTerminal<TDefinition['pipeline']>;
-export type MessagePortHandlerContext<TProtocol extends MessagePortProtocol> = MessagePortHandlerContextDefinition<TProtocol['definition']>;
-export type HandlerOf<TContract extends ContractDefinition, TProtocol extends 'messagePort', TProcedures extends ProceduresForMessagePort<TContract> = ProceduresForMessagePort<TContract>> = TProtocol extends 'messagePort' ? {
-    [K in TProcedures]: (context: MessagePortHandlerContext<ProtocolAt<TContract, K>>) => LogicalMessagePortResult | Promise<LogicalMessagePortResult>;
-} : never;
-export type MessageContextOf<THandler, TProcedure extends keyof THandler> = THandler[TProcedure] extends (context: infer TContext, ...args: any[]) => any ? TContext : never;
-export interface MessagePortProtocolExecution {
-    readonly graph: ApplicationGraphIR;
-    initialize(): Promise<void>;
-    shutdown(signal?: string): Promise<void>;
-    invoke(procedure: string, input?: unknown): Promise<LogicalMessagePortResult>;
-}
-export declare function createMessagePortExecution(options: {
-    readonly runtime: ApplicationRuntime;
-    readonly graph: ApplicationGraphIR;
-    readonly logger?: Logger;
-}): MessagePortProtocolExecution;
-export interface MessagePortLike {
-    postMessage(value: unknown): void;
-    addEventListener(type: string, listener: (event: any) => void): void;
-    start?(): void;
-}
-export declare function attachMessagePort(application: MessagePortProtocolExecution, port: MessagePortLike): void;
-export {};
+export { defineMessagePortContract, defineMessagePortImplementation, messagePort, messagePortExtension, } from './extension.js';
+export { attachMessagePort } from './transport.js';
+export type { MessagePortContext, MessagePortContract, MessagePortExecutionDefinition, MessagePortExtensionRuntime, MessagePortHandlers, MessagePortHostApi, MessagePortImplementationData, MessagePortResponseDefinition, MessagePortResult, MessagePortRouteDefinition, MessagePortServerStreamResponseDefinition, } from './extension.js';
+export type { MessagePortHost, MessagePortLike } from './transport.js';