@loutrejs/loutre 0.6.0 → 0.8.0

package/dist/adapters/bun.d.ts

@@ -1,9 +1,7 @@
-import { type ApplicationDefinition, type BootstrapArguments, type KernelHostedApplication, type RequireApplicationExtension } from '../application/index.js';
+import { type ApplicationDefinition, type BootstrapArguments, type KernelHostedApplication } from '../application/index.js';
 import type { RuntimeCapabilityBinding } from '../core/index.js';
-import { httpExecutionExtension } from '../http/index.js';
-type HttpApplication<TDefinition extends ApplicationDefinition> = RequireApplicationExtension<TDefinition, typeof httpExecutionExtension>;
 export type BunCreateOptions<TDefinition extends ApplicationDefinition> = {
-    readonly application: HttpApplication<TDefinition>;
+    readonly application: TDefinition;
     readonly environment?: unknown;
     readonly capabilities?: readonly RuntimeCapabilityBinding[];
     readonly forceShutdownTimeoutMs?: number;

package/dist/adapters/bun.js

@@ -1,6 +1,6 @@
+import { createBunWebSocketDriver, } from './websocket-native.js';
+import { serverTransportBindings, dispatchServerRequest, } from './server-transports.js';
 import { createKernelApplication, } from '../application/index.js';
-import { bindApplicationCapability } from '../application/kernel-internal.js';
-import { httpExecutionExtension } from '../http/index.js';
 import { LOUTRE_VERSION, detectPresentationTerminal, startStartupPresentation, } from '../presentation.js';
 import { assertRuntimeEngine } from '../runtime/engine.js';
 import { serverUrl } from '../runtime/server-url.js';
@@ -9,6 +9,7 @@ export const bunRuntime = {
     runtime: 'bun',
     capabilities: new Set([
         'http.server',
+        'websocket.server',
         'http.request.streaming',
         'http.response.streaming',
         'stream.readable',
@@ -29,25 +30,18 @@ async function create(options) {
         terminal: detectPresentationTerminal(process.stdout, environment),
         write: (value) => console.log(value),
     });
-    if (options.application.model.extensions.get(httpExecutionExtension) ===
-        undefined) {
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: bunRuntime.create() requires the HTTP Execution Extension.');
-    }
+    const websocketDriver = createBunWebSocketDriver();
     const hosted = createKernelApplication({
         ...options,
         application: options.application,
         capabilities: [
-            bindApplicationCapability(options.application.model, 'http.server', {
-                runtime: 'bun',
-            }),
+            ...serverTransportBindings(options.application.model, 'bun', websocketDriver.driver),
             ...(options.capabilities ?? []),
         ],
         environment: 'environment' in options ? options.environment : environment,
     });
     await hosted.init();
     const application = hosted;
-    const http = hosted
-        .http;
     const closeApplication = application.close.bind(application);
     let server;
     let removeShutdownHooks;
@@ -63,20 +57,41 @@ async function create(options) {
             removeShutdownHooks?.();
             removeShutdownHooks = undefined;
             const errors = [];
-            if (server) {
+            try {
+                await closeApplication(signal);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (server && errors.length === 0) {
+                let timer;
                 try {
-                    await server.stop(true);
+                    // Bun 1.3のserver側WebSocket close後はstopが未完了になるため、Kernel drain後も無期限には待たない。
+                    // https://github.com/oven-sh/bun/issues/36223
+                    await Promise.race([
+                        Promise.resolve(server.stop(false)),
+                        new Promise((resolve, reject) => {
+                            timer = setTimeout(() => {
+                                try {
+                                    const forced = server.stop(true);
+                                    server.unref?.();
+                                    void Promise.resolve(forced).then(resolve, reject);
+                                    resolve();
+                                }
+                                catch (error) {
+                                    reject(error);
+                                }
+                            }, options.forceShutdownTimeoutMs ?? 5_000);
+                        }),
+                    ]);
                     server = undefined;
                 }
                 catch (error) {
                     errors.push(error);
                 }
-            }
-            try {
-                await closeApplication(signal);
-            }
-            catch (error) {
-                errors.push(error);
+                finally {
+                    clearTimeout(timer);
+                }
             }
             if (errors.length > 0) {
                 throw new AggregateError(errors, 'Bun runtime shutdown failed');
@@ -110,7 +125,8 @@ async function create(options) {
                         ...(serveOptions.hostname === undefined
                             ? {}
                             : { hostname: serveOptions.hostname }),
-                        fetch: createBunFetchDriver(http),
+                        fetch: (request, upgradeServer) => websocketDriver.fetch(hosted, request, upgradeServer, dispatchServerRequest),
+                        websocket: websocketDriver.websocket,
                     });
                     break;
                 }
@@ -158,14 +174,6 @@ function registerBunShutdownHooks(close) {
     }
     return remove;
 }
-function createBunFetchDriver(application) {
-    let initialization;
-    return async (request) => {
-        initialization ??= application.initialize?.() ?? Promise.resolve();
-        await initialization;
-        return application.fetch(request);
-    };
-}
 function bunGlobal() {
     return globalThis.Bun;
 }

package/dist/adapters/cloudflare-workers.d.ts

@@ -1,9 +1,7 @@
-import { type ApplicationDefinition, type BootstrapArguments, type RequireApplicationExtension } from '../application/index.js';
+import { type ApplicationDefinition, type BootstrapArguments } from '../application/index.js';
 import type { RuntimeCapabilityBinding } from '../core/index.js';
-import { httpExecutionExtension } from '../http/index.js';
-type HttpApplication<TDefinition extends ApplicationDefinition> = RequireApplicationExtension<TDefinition, typeof httpExecutionExtension>;
 export type CloudflareWorkersBindOptions<TDefinition extends ApplicationDefinition> = {
-    readonly application: HttpApplication<TDefinition>;
+    readonly application: TDefinition;
     readonly capabilities?: readonly RuntimeCapabilityBinding[];
 } & BootstrapArguments<TDefinition>;
 export interface CloudflareWorkersBinding {

package/dist/adapters/cloudflare-workers.js

@@ -1,12 +1,13 @@
+import { createCloudflareWebSocketDriver } from './websocket-native.js';
+import { serverTransportBindings, dispatchServerRequest, } from './server-transports.js';
 import { createKernelApplication, } from '../application/index.js';
-import { bindApplicationCapability } from '../application/kernel-internal.js';
-import { httpExecutionExtension } from '../http/index.js';
 import { assertRuntimeEngine } from '../runtime/engine.js';
 export const cloudflareWorkersRuntime = {
     runtime: 'cloudflare-workers',
     compatibilityDateMinimum: '2026-08-04',
     capabilities: new Set([
         'http.server',
+        'websocket.server',
         'http.request.streaming',
         'http.response.streaming',
         'stream.readable',
@@ -19,10 +20,6 @@ export const cloudflareWorkersRuntime = {
 };
 function bind(options) {
     assertRuntimeEngine('cloudflare-workers');
-    if (options.application.model.extensions.get(httpExecutionExtension) ===
-        undefined) {
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: cloudflareWorkersRuntime.bind() requires the HTTP Execution Extension.');
-    }
     let application;
     let initialization;
     const resolve = async (environment) => {
@@ -30,20 +27,18 @@ function bind(options) {
             ...options,
             application: options.application,
             capabilities: [
-                bindApplicationCapability(options.application.model, 'http.server', {
-                    runtime: 'cloudflare-workers',
-                }),
+                ...serverTransportBindings(options.application.model, 'cloudflare-workers', createCloudflareWebSocketDriver()),
                 ...(options.capabilities ?? []),
             ],
             environment,
         });
         initialization ??= application.init();
         await initialization;
-        return application.http;
+        return application;
     };
     return {
         async fetch(request, environment) {
-            return (await resolve(environment)).fetch(request);
+            return dispatchServerRequest(await resolve(environment), request);
         },
         async close(signal) {
             await application?.close(signal);

package/dist/adapters/server-transports.d.ts

@@ -0,0 +1,4 @@
+import type { ApplicationModel, RuntimeCapabilityBinding } from '../core/index.js';
+import { type WebSocketServerDriver } from '../websocket/index.js';
+export declare function serverTransportBindings(model: ApplicationModel, runtime: string, websocket: WebSocketServerDriver): RuntimeCapabilityBinding[];
+export declare function dispatchServerRequest(application: object, request: Request): Promise<Response>;

package/dist/adapters/server-transports.js

@@ -0,0 +1,18 @@
+import { bindHttpServer } from '../http/index.js';
+import { bindWebSocketServer, } from '../websocket/index.js';
+export function serverTransportBindings(model, runtime, websocket) {
+    const requires = (id) => model.executions.some((execution) => execution.capabilities.some((capability) => capability.id === id));
+    return [
+        ...(requires('http.server') ? [bindHttpServer({ runtime })] : []),
+        ...(requires('websocket.server') ? [bindWebSocketServer(websocket)] : []),
+    ];
+}
+export function dispatchServerRequest(application, request) {
+    const transports = application;
+    if (request.headers.get('upgrade')?.toLowerCase() === 'websocket') {
+        return (transports.websocket?.upgrade(request) ??
+            Promise.resolve(new Response('Not Found', { status: 404 })));
+    }
+    return (transports.http?.fetch(request) ??
+        Promise.resolve(new Response('Not Found', { status: 404 })));
+}

package/dist/adapters/websocket-native.d.ts

@@ -0,0 +1,24 @@
+import { type WebSocketServerDriver, type WebSocketDriverChannel } from '../websocket/index.js';
+export declare function createCloudflareWebSocketDriver(): WebSocketServerDriver;
+interface BunSocket {
+    readonly data: WebSocketDriverChannel;
+    send(message: string | Uint8Array): number;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+export interface BunUpgradeServer {
+    upgrade(request: Request, options: {
+        headers: Record<string, string>;
+        data: WebSocketDriverChannel;
+    }): boolean;
+}
+export declare function createBunWebSocketDriver(): {
+    driver: WebSocketServerDriver;
+    fetch(application: object, request: Request, server: BunUpgradeServer, dispatch: (application: object, request: Request) => Promise<Response>): Promise<Response | undefined>;
+    websocket: {
+        open(socket: BunSocket): void;
+        message(socket: BunSocket, message: string | Uint8Array): void;
+        close(socket: BunSocket, code: number, reason: string): void;
+    };
+};
+export {};

package/dist/adapters/websocket-native.js

@@ -0,0 +1,150 @@
+import { createEventWebSocketConnection, createWebSocketDriverChannel, } from '../websocket/index.js';
+export function createCloudflareWebSocketDriver() {
+    return {
+        runtime: 'cloudflare-workers',
+        async upgrade(_request, { protocol }) {
+            const Pair = globalThis.WebSocketPair;
+            const pair = new Pair();
+            pair[1].accept();
+            // WorkersのI/Oはopening requestへ所属するため、別requestからのdrainをそのcontextへ戻す。
+            const io = createOwnedWebSocketIo();
+            const connection = createEventWebSocketConnection(pair[1], protocol ?? '', { run: io.run });
+            void connection.closed.then(io.stop);
+            const response = new Response(null, {
+                status: 101,
+                webSocket: pair[0],
+                headers: protocol ? { 'sec-websocket-protocol': protocol } : {},
+            });
+            return { response, connection };
+        },
+    };
+}
+export function createBunWebSocketDriver() {
+    const requests = new WeakMap();
+    const upgraded = new WeakSet();
+    const driver = {
+        runtime: 'bun',
+        async upgrade(request, { protocol }) {
+            const native = requests.get(request);
+            const server = native?.server;
+            if (!server)
+                throw new Error('Bunのupgrade serverが見つかりません。');
+            let socket;
+            let open;
+            const opened = new Promise((resolve) => {
+                open = resolve;
+            });
+            const channel = createWebSocketDriverChannel({
+                protocol: protocol ?? '',
+                async send(message) {
+                    await opened;
+                    socket.send(message.data);
+                },
+                async close(code = 1000, reason = '') {
+                    await opened;
+                    socket.close(code, reason);
+                },
+                terminate() {
+                    socket?.terminate();
+                    channel.finish({ code: 1006, reason: '', wasClean: false });
+                },
+            });
+            pending.set(channel, (value) => {
+                socket = value;
+                open();
+            });
+            if (!server.upgrade(request, {
+                headers: protocol ? { 'sec-websocket-protocol': protocol } : {},
+                data: channel,
+            })) {
+                pending.delete(channel);
+                throw new Error('Bun WebSocket upgradeに失敗しました。');
+            }
+            upgraded.add(request);
+            native.accepted();
+            return { response: new Response(), connection: channel.connection };
+        },
+    };
+    const pending = new WeakMap();
+    return {
+        driver,
+        async fetch(application, request, server, dispatch) {
+            let accept;
+            const accepted = new Promise((resolve) => {
+                accept = () => resolve(undefined);
+            });
+            requests.set(request, { server, accepted: accept });
+            try {
+                const dispatched = dispatch(application, request).then((response) => upgraded.has(request) ? undefined : response);
+                return await Promise.race([dispatched, accepted]);
+            }
+            finally {
+                requests.delete(request);
+            }
+        },
+        websocket: {
+            open(socket) {
+                pending.get(socket.data)?.(socket);
+                pending.delete(socket.data);
+            },
+            message(socket, message) {
+                socket.data.receive(typeof message === 'string'
+                    ? { type: 'text', data: message }
+                    : { type: 'binary', data: new Uint8Array(message) });
+            },
+            close(socket, code, reason) {
+                socket.data.finish({ code, reason, wasClean: code !== 1006 });
+            },
+        },
+    };
+}
+function createOwnedWebSocketIo() {
+    const queue = [];
+    let active = true;
+    let wake;
+    const stopped = new Error('WebSocketは終了しました。');
+    const pump = async () => {
+        while (true) {
+            if (!active)
+                return;
+            const task = queue.shift();
+            if (task)
+                task.run();
+            else
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+        }
+    };
+    void pump();
+    return {
+        run(operation) {
+            if (!active)
+                return Promise.reject(stopped);
+            return new Promise((resolve, reject) => {
+                queue.push({
+                    run() {
+                        try {
+                            resolve(operation());
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    },
+                    cancel() {
+                        reject(stopped);
+                    },
+                });
+                wake?.();
+                wake = undefined;
+            });
+        },
+        stop() {
+            active = false;
+            for (const task of queue.splice(0))
+                task.cancel();
+            wake?.();
+            wake = undefined;
+        },
+    };
+}

package/dist/application/kernel.d.ts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.disposable" preserve="true" />
-import type { RuntimeCapabilityBinding, TokenLike, TokenValue } from '../core/index.js';
+import type { RuntimeCapabilityBinding, RuntimeInstrumentation, TokenLike, TokenValue } from '../core/index.js';
 import { type ApplicationModelGraphIR } from '../graph/index.js';
 import { type Logger } from '../runtime/index.js';
 import type { ApplicationDefinition, ApplicationExtensionHostApis, BootstrapArguments } from './definition.js';
@@ -16,6 +16,7 @@ export type KernelApplicationOptions<TDefinition extends ApplicationDefinition>
     readonly environment?: unknown;
     readonly logger?: Logger;
     readonly forceShutdownTimeoutMs?: number;
+    readonly instrumentation?: RuntimeInstrumentation;
 } & BootstrapArguments<TDefinition>;
 export declare function createKernelApplication<const TDefinition extends ApplicationDefinition>(options: KernelApplicationOptions<TDefinition>): KernelHostedApplication<TDefinition>;
 export declare function bootstrapApplication<const TDefinition extends ApplicationDefinition>(options: KernelApplicationOptions<TDefinition>): Promise<KernelHostedApplication<TDefinition>>;

package/dist/core/extension.d.ts

@@ -1,4 +1,5 @@
 import type { Diagnostic } from './diagnostic.js';
+import type { RuntimeExecutionMetadata, RuntimeInvocationRegistration, RuntimeOperationMetadata } from './instrumentation.js';
 import type { TokenLike } from './token.js';
 declare const runtimeCapabilityValue: unique symbol;
 declare const executionExtensionTypeInfo: unique symbol;
@@ -27,11 +28,21 @@ export declare class RuntimeCapabilityRegistry implements RuntimeCapabilityBindi
 }
 export interface ExecutionLease {
     readonly signal: AbortSignal;
+    run?<T>(operation: () => T): T;
     abort(reason?: unknown): void;
-    complete(): void;
+    fail?(reason: unknown): void;
+    annotate?(attributes: Readonly<Record<string, unknown>>): void;
+    complete(...result: [] | [unknown]): void;
+}
+export interface ExecutionOperationLease {
+    run?<T>(operation: () => T): T;
+    fail?(reason: unknown): void;
+    annotate?(attributes: Readonly<Record<string, unknown>>): void;
+    complete(...result: [] | [unknown]): void;
 }
 export interface ExecutionKernelRuntime {
-    beginExecution(): ExecutionLease;
+    beginExecution(metadata?: RuntimeExecutionMetadata, invocation?: RuntimeInvocationRegistration): ExecutionLease;
+    beginOperation?(metadata: RuntimeOperationMetadata, invocation?: RuntimeInvocationRegistration): ExecutionOperationLease;
     resolve<TValue>(token: TokenLike<TValue>, source?: string): TValue;
 }
 export interface ExecutionExtensionDrainContext {
@@ -93,11 +104,23 @@ export interface ExecutionDefinition<TExtension extends AnyExecutionExtension =
     readonly extension: TExtension;
     readonly [executionDefinitionBrand]: true;
 }
+export interface ExecutionGroup<TExecutions extends readonly ExecutionDeclaration[] = readonly ExecutionDeclaration[]> {
+    readonly kind: 'execution-group';
+    readonly name?: string;
+    readonly executions: TExecutions;
+}
+export type ExecutionDeclaration = ExecutionDefinition | ExecutionGroup;
+export declare function flattenExecutions(declarations: readonly unknown[]): unknown[];
+export interface ExecutionContextView {
+    readonly signal: AbortSignal;
+    annotate(attributes: Readonly<Record<string, unknown>>): void;
+    beginOperation(metadata: RuntimeOperationMetadata): ExecutionOperationLease;
+}
 export declare function defineExecution<const TExtension extends ExecutionExtension, const TDefinition extends object>(extension: TExtension, definition: TDefinition): Readonly<TDefinition & ExecutionDefinition<TExtension>>;
 export declare function isExecutionDefinition(value: unknown): value is ExecutionDefinition;
 export type ExtensionOfDefinition<TDefinition> = TDefinition extends {
     readonly extension: infer TExtension extends AnyExecutionExtension;
-} ? TExtension : never;
+} ? TExtension : TDefinition extends ExecutionGroup<infer TExecutions> ? ExecutionGroup extends TDefinition ? AnyExecutionExtension : ExtensionOfDefinition<TExecutions[number]> : never;
 export type AnyExecutionExtension = ExecutionExtension<any, any, any, any, any>;
 export type HostApiOfExtension<TExtension> = TExtension extends {
     readonly host?: infer THost;

package/dist/core/extension.js

@@ -56,6 +56,25 @@ export function defineExecutionExtension(extension) {
     });
 }
 export const executionDefinitionBrand = Symbol.for('loutre.execution-definition');
+export function flattenExecutions(declarations) {
+    const active = new Set();
+    const visit = (values) => values.flatMap((value) => {
+        if (typeof value !== 'object' ||
+            value === null ||
+            !('kind' in value) ||
+            value.kind !== 'execution-group')
+            return [value];
+        if (active.has(value))
+            throw new TypeError('ExecutionGroupに循環参照があります。');
+        if (!('executions' in value) || !Array.isArray(value.executions))
+            throw new TypeError('ExecutionGroup.executionsは配列である必要があります。');
+        active.add(value);
+        const executions = visit(value.executions);
+        active.delete(value);
+        return executions;
+    });
+    return visit(declarations);
+}
 export function defineExecution(extension, definition) {
     return Object.freeze({
         ...definition,

package/dist/core/index.d.ts

@@ -7,7 +7,8 @@ export type { EnvClass, EnvKey, EnvSchema } from './env.js';
 export { defineError, DomainError } from './error.js';
 export type { ErrorDefinition } from './error.js';
 export { bindRuntimeCapability, defineExecution, defineExecutionExtension, executionDefinitionBrand, isExecutionDefinition, runtimeCapability, RuntimeCapabilityRegistry, } from './extension.js';
-export type { AnyExecutionExtension, ExecutionCompileContext, ExecutionContribution, ExecutionDefinition, ExecutionExtension, ExecutionExtensionDrainContext, ExecutionExtensionRuntime, ExecutionExtensionRuntimeContext, ExecutionExtensionValidationContext, ExecutionKernelRuntime, ExecutionLease, ExecutionProjectionContext, ExtensionOfDefinition, HostApiOfExtension, HostExtension, HostExtensionContext, RuntimeCapability, RuntimeCapabilityBinding, RuntimeCapabilityBindings, RuntimeCapabilityValue, } from './extension.js';
+export type { AnyExecutionExtension, ExecutionCompileContext, ExecutionContribution, ExecutionDefinition, ExecutionDeclaration, ExecutionGroup, ExecutionContextView, ExecutionExtension, ExecutionExtensionDrainContext, ExecutionExtensionRuntime, ExecutionExtensionRuntimeContext, ExecutionExtensionValidationContext, ExecutionKernelRuntime, ExecutionLease, ExecutionProjectionContext, ExecutionOperationLease, ExtensionOfDefinition, HostApiOfExtension, HostExtension, HostExtensionContext, RuntimeCapability, RuntimeCapabilityBinding, RuntimeCapabilityBindings, RuntimeCapabilityValue, } from './extension.js';
+export type { RuntimeExecutionMetadata, RuntimeInstrumentation, RuntimeInstrumentationScope, RuntimeInvocationRegistration, RuntimeProviderMetadata, RuntimeOperationMetadata, } from './instrumentation.js';
 export { composeLayers, defineLayer } from './generic-layer.js';
 export type { GenericLayer, GenericLayerContext, GenericLayerNext, } from './generic-layer.js';
 export { collectInjectedDependencies, inject, InjectionContextError, runInInjectionContext, } from './injection.js';

package/dist/core/instrumentation.d.ts

@@ -0,0 +1,36 @@
+import type { Scope } from './provider.js';
+export interface RuntimeInvocationRegistration {
+    readonly input: unknown;
+    invoke(input: unknown): unknown | Promise<unknown>;
+}
+export interface RuntimeExecutionMetadata {
+    readonly executionId: string;
+    readonly executionKind: string;
+    readonly name?: string;
+    readonly graphNodeId?: string;
+}
+export interface RuntimeOperationMetadata {
+    readonly kind: string;
+    readonly name: string;
+    readonly graphNodeId?: string;
+}
+export interface RuntimeProviderMetadata {
+    readonly providerId: string;
+    readonly name: string;
+    readonly graphNodeId: string;
+    readonly scope: Scope;
+    readonly providerKind: 'value' | 'class' | 'factory' | 'conditional' | 'environment' | 'arguments';
+}
+export interface RuntimeInstrumentationScope {
+    run?<T>(operation: () => T): T;
+    abort?(reason?: unknown): void;
+    fail?(reason: unknown): void;
+    annotate?(attributes: Readonly<Record<string, unknown>>): void;
+    complete(...result: [] | [unknown]): void;
+}
+export interface RuntimeInstrumentation {
+    beginExecution?(metadata: RuntimeExecutionMetadata, invocation?: RuntimeInvocationRegistration): RuntimeInstrumentationScope | undefined;
+    beginOperation?(metadata: RuntimeOperationMetadata, invocation?: RuntimeInvocationRegistration): RuntimeInstrumentationScope | undefined;
+    providerCreated?(metadata: RuntimeProviderMetadata, value: unknown): void;
+    close?(): void | Promise<void>;
+}

package/dist/core/instrumentation.js

@@ -0,0 +1 @@
+export {};

package/dist/core/model/modules.js

@@ -6,6 +6,7 @@ import { tokenName } from '../token.js';
 import { appendLifecycleNodes } from './lifecycle.js';
 import { snapshotProvider } from './snapshot.js';
 import { getSourceLocation } from '../source-location.js';
+import { match } from 'ts-pattern';
 export function collectModuleDeclarations(context) {
     const { modules, moduleIds, nodes, edges, diagnostics, providers, providerNodes, } = context;
     const moduleNames = new Set();
@@ -79,23 +80,18 @@ export function collectModuleDeclarations(context) {
     }
 }
 function collectProviderDependencies(provider) {
-    switch (provider.kind) {
-        case 'class':
-            return Object.freeze(collectInjectedDependencies(provider.provide, () => Reflect.construct(provider.useClass, [])));
-        case 'factory':
-            return Object.freeze([...provider.inject]);
-        case 'conditional': {
-            const dependencies = new Set();
-            for (const implementation of Object.values(provider.mapping)) {
-                for (const dependency of collectInjectedDependencies(provider.provide, () => Reflect.construct(implementation, []))) {
-                    dependencies.add(dependency);
-                }
+    return match(provider)
+        .with({ kind: 'class' }, (candidate) => Object.freeze(collectInjectedDependencies(candidate.provide, () => Reflect.construct(candidate.useClass, []))))
+        .with({ kind: 'factory' }, (candidate) => Object.freeze([...candidate.inject]))
+        .with({ kind: 'conditional' }, (candidate) => {
+        const dependencies = new Set();
+        for (const implementation of Object.values(candidate.mapping)) {
+            for (const dependency of collectInjectedDependencies(candidate.provide, () => Reflect.construct(implementation, []))) {
+                dependencies.add(dependency);
             }
-            return Object.freeze([...dependencies]);
         }
-        case 'value':
-        case 'environment':
-        case 'arguments':
-            return Object.freeze([]);
-    }
+        return Object.freeze([...dependencies]);
+    })
+        .with({ kind: 'value' }, { kind: 'environment' }, { kind: 'arguments' }, () => Object.freeze([]))
+        .exhaustive();
 }

package/dist/core/model.js

@@ -1,5 +1,5 @@
 import { diagnostic, isErrorDiagnostic } from './diagnostic.js';
-import { isExecutionDefinition, } from './extension.js';
+import { isExecutionDefinition, flattenExecutions, } from './extension.js';
 import { isFrameworkProvidedToken } from './token-internal.js';
 import { tokenName } from './token.js';
 import { createModelBuildContext } from './model/context.js';
@@ -84,9 +84,19 @@ export function buildApplicationModel(options) {
             return result;
         }
     };
+    const moduleExecutions = new Map();
+    for (const module of modules) {
+        try {
+            moduleExecutions.set(module, flattenExecutions(module.definition.executions ?? []));
+        }
+        catch (error) {
+            diagnostics.push(diagnostic('LUTRE_EXECUTION_GROUP_INVALID', String(error), moduleIds.get(module)));
+            moduleExecutions.set(module, []);
+        }
+    }
     const rootDefinitionOwners = new Map();
     for (const module of modules) {
-        for (const value of module.definition.executions ?? []) {
+        for (const value of moduleExecutions.get(module) ?? []) {
             if (!isExecutionDefinition(value))
                 continue;
             const owners = rootDefinitionOwners.get(value) ?? new Set();
@@ -96,7 +106,7 @@ export function buildApplicationModel(options) {
     }
     const reachableDefinitionModules = new Map();
     for (const module of modules) {
-        const queue = (module.definition.executions ?? []).filter(isExecutionDefinition);
+        const queue = (moduleExecutions.get(module) ?? []).filter(isExecutionDefinition);
         const seen = new Set();
         let queueIndex = 0;
         while (queueIndex < queue.length) {
@@ -147,7 +157,7 @@ export function buildApplicationModel(options) {
     }
     for (const module of modules) {
         const moduleId = moduleIds.get(module);
-        const rootDefinitions = module.definition.executions ?? [];
+        const rootDefinitions = moduleExecutions.get(module) ?? [];
         const rootDefinitionIndexes = new Map();
         for (const [definitionIndex, value] of rootDefinitions.entries()) {
             if (isExecutionDefinition(value) && !rootDefinitionIndexes.has(value)) {