@loutrejs/loutre 0.8.2 → 0.9.1

package/README.md

@@ -43,11 +43,11 @@ const HealthHttp = http.implementation({
   }),
 })
 
-const AppModule = defineModule(() => ({
+const AppModule = defineModule({
   executions: [HealthHttp],
-}))
+})
 
-export default defineApplication({ modules: [AppModule()] })
+export default defineApplication({ modules: [AppModule] })
 ```
 
 ## Kernel bootstrap

package/dist/adapters/bun.d.ts

@@ -4,6 +4,7 @@ export type BunCreateOptions<TDefinition extends ApplicationDefinition> = {
     readonly application: TDefinition;
     readonly environment?: unknown;
     readonly capabilities?: readonly RuntimeCapabilityBinding[];
+    readonly shutdownHooks?: boolean;
     readonly forceShutdownTimeoutMs?: number;
 } & BootstrapArguments<TDefinition>;
 export interface BunServeOptions {

package/dist/adapters/bun.js

@@ -1,3 +1,6 @@
+import { RuntimeShutdown } from '../runtime/shutdown.js';
+import { ProcessShutdownHooks } from '../runtime/shutdown-hooks.js';
+import { Logger } from '../runtime/logger.js';
 import { createBunWebSocketDriver, } from './websocket-native.js';
 import { serverTransportBindings, dispatchServerRequest, } from './server-transports.js';
 import { createKernelApplication, } from '../application/index.js';
@@ -44,67 +47,41 @@ async function create(options) {
     const application = hosted;
     const closeApplication = application.close.bind(application);
     let server;
-    let removeShutdownHooks;
+    const logger = options.application.logger ?? new Logger();
     let serving = false;
-    let closed = false;
-    let closingPromise;
-    const close = (signal) => {
-        if (closed)
+    let serverClosingPromise;
+    const beginServerClose = () => {
+        if (serverClosingPromise)
+            return serverClosingPromise;
+        if (!server)
             return Promise.resolve();
-        if (closingPromise)
-            return closingPromise;
-        closingPromise = (async () => {
-            removeShutdownHooks?.();
-            removeShutdownHooks = undefined;
-            const errors = [];
-            try {
-                await closeApplication(signal);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            if (server && errors.length === 0) {
-                let timer;
-                try {
-                    // 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);
-                }
-                finally {
-                    clearTimeout(timer);
-                }
-            }
-            if (errors.length > 0) {
-                throw new AggregateError(errors, 'Bun runtime shutdown failed');
-            }
-            closed = true;
+        const closingServer = server;
+        serverClosingPromise = (async () => {
+            await closingServer.stop(false);
+            if (server === closingServer)
+                server = undefined;
         })().catch((error) => {
-            closingPromise = undefined;
+            serverClosingPromise = undefined;
             throw error;
         });
-        return closingPromise;
+        void serverClosingPromise.catch(() => undefined);
+        return serverClosingPromise;
     };
+    const shutdown = new RuntimeShutdown({
+        message: 'Bun runtime shutdown failed',
+        beginClose: () => {
+            shutdownHooks.dispose();
+            return beginServerClose();
+        },
+        closeApplication,
+        closeResources: async (safeCleanupBoundaryReached, serverClosing) => {
+            if (safeCleanupBoundaryReached)
+                await serverClosing;
+        },
+    });
+    const close = shutdown.close.bind(shutdown);
     const serve = async (serveOptions = {}) => {
-        if (closed) {
+        if (shutdown.started) {
             throw new Error('LUTRE_APP_STOPPED: Application is stopped.');
         }
         if (serving) {
@@ -115,6 +92,9 @@ async function create(options) {
             throw new Error('LUTRE_BUN_UNAVAILABLE: Bun.serve() is not available.');
         }
         serving = true;
+        if (serveOptions.shutdownHooks !== undefined) {
+            shutdownHooks.setEnabled(serveOptions.shutdownHooks);
+        }
         try {
             const requestedPort = serveOptions.port;
             let port = initialServerPort(requestedPort);
@@ -144,10 +124,6 @@ async function create(options) {
                 environment: environment.NODE_ENV ?? 'development',
                 startupDurationMs: performance.now() - startedAt,
             });
-            removeShutdownHooks =
-                serveOptions.shutdownHooks === false
-                    ? undefined
-                    : registerBunShutdownHooks(close);
             return { port };
         }
         catch (error) {
@@ -155,26 +131,15 @@ async function create(options) {
             throw error;
         }
     };
+    const shutdownHooks = new ProcessShutdownHooks({
+        source: process,
+        close,
+        onError: (error, signal) => logger.error('Bun runtime shutdown failed', { error, signal }),
+    });
     Object.assign(application, { serve, close });
+    shutdownHooks.setEnabled(options.shutdownHooks !== false);
     return application;
 }
-function registerBunShutdownHooks(close) {
-    const handlers = new Map();
-    const remove = () => {
-        for (const [signal, handler] of handlers)
-            process.off(signal, handler);
-        handlers.clear();
-    };
-    for (const signal of ['SIGINT', 'SIGTERM']) {
-        const handler = () => {
-            remove();
-            void close(signal);
-        };
-        handlers.set(signal, handler);
-        process.once(signal, handler);
-    }
-    return remove;
-}
 function bunGlobal() {
     return globalThis.Bun;
 }

package/dist/application/definition.d.ts

@@ -1,19 +1,19 @@
 /// <reference lib="esnext.disposable" preserve="true" />
-import type { ArgsClass, ApplicationModel, ExecutionExtension, HostApiOfExtension, ModuleExtensions, ModuleInstance, SchemaInput } from '../core/index.js';
+import type { ArgsClass, ApplicationModel, ExecutionExtension, HostApiOfExtension, ModuleExtensions, ModuleInput, SchemaInput } from '../core/index.js';
 import type { Logger } from '../runtime/index.js';
-export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInstance[], TArguments extends ArgsClass | undefined> {
+export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInput[], TArguments extends ArgsClass | undefined> {
     readonly modules: TModules;
     readonly arguments?: TArguments;
     readonly logger?: Logger;
 }
-export interface ApplicationDefinition<TModules extends readonly ModuleInstance[] = readonly ModuleInstance[], TArguments extends ArgsClass | undefined = ArgsClass | undefined> {
+export interface ApplicationDefinition<TModules extends readonly ModuleInput[] = readonly ModuleInput[], TArguments extends ArgsClass | undefined = ArgsClass | undefined> {
     readonly kind: 'application-definition';
     readonly model: ApplicationModel;
     readonly modules: TModules;
     readonly arguments: TArguments;
     readonly logger?: Logger;
 }
-export declare function defineApplication<const TModules extends readonly ModuleInstance[], const TArguments extends ArgsClass | undefined = undefined>(options: ApplicationDefinitionOptions<TModules, TArguments>): ApplicationDefinition<TModules, TArguments>;
+export declare function defineApplication<const TModules extends readonly ModuleInput[], const TArguments extends ArgsClass | undefined = undefined>(options: ApplicationDefinitionOptions<TModules, TArguments>): ApplicationDefinition<TModules, TArguments>;
 export type ApplicationArgumentsInput<TDefinition extends ApplicationDefinition> = TDefinition['arguments'] extends ArgsClass<infer TSchema> ? SchemaInput<TSchema> : never;
 export type BootstrapArguments<TDefinition extends ApplicationDefinition> = TDefinition['arguments'] extends ArgsClass<infer TSchema> ? {} extends SchemaInput<TSchema> ? {
     readonly arguments?: SchemaInput<TSchema>;

package/dist/application/kernel.js

@@ -25,7 +25,7 @@ export function createKernelApplication(options) {
                     if (!host)
                         continue;
                     application[host.namespace] = host.create({
-                        executions: modelExtension.executions,
+                        executions: runtime.executionBindings(modelExtension.extension),
                         runtime: runtime.extensionRuntime(modelExtension.extension),
                         applicationRuntime: runtime,
                     });

package/dist/core/extension.d.ts

@@ -1,3 +1,4 @@
+import type { DependencyResolver } from './injection.js';
 import type { Diagnostic } from './diagnostic.js';
 import type { RuntimeExecutionMetadata, RuntimeInvocationRegistration, RuntimeOperationMetadata } from './instrumentation.js';
 import type { TokenLike } from './token.js';
@@ -43,7 +44,6 @@ export interface ExecutionOperationLease {
 export interface ExecutionKernelRuntime {
     beginExecution(metadata?: RuntimeExecutionMetadata, invocation?: RuntimeInvocationRegistration): ExecutionLease;
     beginOperation?(metadata: RuntimeOperationMetadata, invocation?: RuntimeInvocationRegistration): ExecutionOperationLease;
-    resolve<TValue>(token: TokenLike<TValue>, source?: string): TValue;
 }
 export interface ExecutionExtensionDrainContext {
     readonly timeoutMs: number;
@@ -64,6 +64,10 @@ export interface ExecutionContribution<TCompiled = unknown> {
     readonly capabilities: readonly RuntimeCapability[];
     readonly compiled: TCompiled;
 }
+export interface ExecutionRuntimeBinding<TCompiled = unknown> {
+    readonly execution: ExecutionContribution<TCompiled>;
+    readonly resolve: DependencyResolver;
+}
 export interface ExecutionExtensionValidationContext<TCompiled = unknown> {
     readonly executions: readonly ExecutionContribution<TCompiled>[];
 }
@@ -71,12 +75,12 @@ export interface ExecutionProjectionContext<TCompiled = unknown> {
     readonly execution: ExecutionContribution<TCompiled>;
 }
 export interface ExecutionExtensionRuntimeContext<TCompiled = unknown> {
-    readonly executions: readonly ExecutionContribution<TCompiled>[];
+    readonly executions: readonly ExecutionRuntimeBinding<TCompiled>[];
     readonly capabilities: RuntimeCapabilityBindings;
     readonly applicationRuntime: ExecutionKernelRuntime;
 }
 export interface HostExtensionContext<TCompiled = unknown, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime> {
-    readonly executions: readonly ExecutionContribution<TCompiled>[];
+    readonly executions: readonly ExecutionRuntimeBinding<TCompiled>[];
     readonly runtime: TRuntime;
     readonly applicationRuntime: ExecutionKernelRuntime;
 }

package/dist/core/generic-layer.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeCapability } from './extension.js';
-import type { TokenLike } from './token.js';
+import { type DependencyResolver } from './injection.js';
 import type { Type } from './type.js';
 export interface GenericLayerContext<TState extends object = {}> {
     readonly state: Readonly<TState>;
@@ -21,6 +21,6 @@ export declare function defineLayer<TContribution extends object = {}, TContext
 export declare function composeLayers<TContext extends object, TOutcome>(options: {
     readonly context: TContext;
     readonly layers: readonly GenericLayer<any, any, TOutcome>[];
-    readonly resolve: <TValue>(token: TokenLike<TValue>, source?: string) => TValue;
+    readonly resolve: DependencyResolver;
     readonly terminal: (context: TContext & GenericLayerContext<Record<string, unknown>>) => Promise<TOutcome>;
 }): Promise<TOutcome>;

package/dist/core/generic-layer.js

@@ -15,7 +15,7 @@ export function composeLayers(options) {
             id: `layer:${index}:${layer.name}`,
             name: layer.name,
         },
-        resolve: (token) => options.resolve(token, layer.name),
+        resolve: (token, consumer) => options.resolve(token, { source: layer.name, consumer }),
     }, () => layer.factory()));
     const dispatch = async (index, state) => {
         const context = Object.assign(Object.create(options.context), {

package/dist/core/index.d.ts

@@ -7,18 +7,18 @@ 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, 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 { AnyExecutionExtension, ExecutionCompileContext, ExecutionContribution, ExecutionRuntimeBinding, 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';
-export type { DependencyConsumer, DependencyConsumerDescriptor, InjectionContext, } from './injection.js';
+export { collectInjectedDependencies, inject, injectInquirer, InjectionContextError, runInInjectionContext, } from './injection.js';
+export type { DependencyConsumer, DependencyConsumerDescriptor, DependencyResolutionContext, DependencyResolver, InjectionContext, } from './injection.js';
 export { hook } from './lifecycle.js';
 export type { BeforeApplicationShutdown, LifecycleHook, ModuleLifecycle, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, OnModuleInit, } from './lifecycle.js';
 export { ApplicationModelError, assertValidApplicationModel, buildApplicationModel, } from './model.js';
 export type { ApplicationModel, ApplicationModelBuildOptions, ApplicationModelEdge, ApplicationModelExtension, ApplicationModelExtensions, ApplicationModelNode, CompiledOf, ExecutionModelNode, FrameworkModelNode, LifecycleModelNode, ModuleModelNode, ProviderModelNode, } from './model.js';
 export { asModuleInstance, defineModule, moduleTypeInfo } from './module.js';
-export type { AnyModuleTemplate, ExtensionsOfModuleDefinition, ModuleDefinition, ModuleExtensions, ModuleHostApis, ModuleInstance, ModuleTemplate, ModuleTypeInfo, } from './module.js';
+export type { AnyModuleTemplate, ExtensionsOfModuleDefinition, ModuleDefinition, ModuleExtensions, ModuleHostApis, ModuleInstance, ModuleInput, ModuleTemplate, ModuleTypeInfo, } from './module.js';
 export { argumentsProvider, environmentProvider, normalizeProvider, provide, } from './provider.js';
 export type { ArgumentsProvider, ClassProvider, ConditionalProvider, EnvironmentProvider, FactoryDefinition, FactoryProvider, ProviderDeclaration, ProviderDescriptor, ProviderScopeOptions, Scope, ValueProvider, } from './provider.js';
 export type { RuntimeInputContract, RuntimeInputKey } from './runtime-input.js';

package/dist/core/index.js

@@ -4,7 +4,7 @@ export { defineEnv, isEnvClass, loadEnv } from './env.js';
 export { defineError, DomainError } from './error.js';
 export { bindRuntimeCapability, defineExecution, defineExecutionExtension, executionDefinitionBrand, isExecutionDefinition, runtimeCapability, RuntimeCapabilityRegistry, } from './extension.js';
 export { composeLayers, defineLayer } from './generic-layer.js';
-export { collectInjectedDependencies, inject, InjectionContextError, runInInjectionContext, } from './injection.js';
+export { collectInjectedDependencies, inject, injectInquirer, InjectionContextError, runInInjectionContext, } from './injection.js';
 export { hook } from './lifecycle.js';
 export { ApplicationModelError, assertValidApplicationModel, buildApplicationModel, } from './model.js';
 export { asModuleInstance, defineModule, moduleTypeInfo } from './module.js';

package/dist/core/injection.d.ts

@@ -5,9 +5,17 @@ export interface DependencyConsumerDescriptor {
     readonly kind?: string;
 }
 export type DependencyConsumer = TokenLike | DependencyConsumerDescriptor;
+export interface DependencyResolutionContext {
+    readonly source?: string;
+    readonly consumer?: DependencyConsumer;
+}
+export interface DependencyResolver {
+    <TValue>(token: TokenLike<TValue>, context?: string | DependencyResolutionContext): TValue;
+}
 export interface InjectionContext {
     readonly consumer: DependencyConsumer;
-    readonly resolve: <T>(token: TokenLike<T>) => T;
+    readonly inquirer?: DependencyConsumer;
+    readonly resolve?: <T>(token: TokenLike<T>, consumer: DependencyConsumer) => T;
     readonly record?: (consumer: DependencyConsumer, dependency: TokenLike) => void;
 }
 export declare function runInInjectionContext<T>(context: InjectionContext, run: () => T): T;
@@ -16,4 +24,6 @@ export declare class InjectionContextError extends Error {
     constructor(token: TokenLike);
 }
 export declare function inject<TToken extends TokenLike>(token: TToken): TokenValue<TToken>;
+/** Modelに現れない依存は解決できないため、依存宣言の分岐ではなく構築metadataの取得に使う。 */
+export declare function injectInquirer(): DependencyConsumer | undefined;
 export declare function collectInjectedDependencies(consumer: DependencyConsumer, construct: () => unknown): readonly TokenLike[];

package/dist/core/injection.js

@@ -22,16 +22,20 @@ export function runInInjectionContext(context, run) {
 export class InjectionContextError extends Error {
     code = 'LUTRE_DI_CONTEXT';
     constructor(token) {
-        super(`inject(${typeof token === 'function' ? token.name : token.id}) was called outside a Loutre injection context.`);
+        super(`inject(${typeof token === 'function' ? token.name : token.id}) requires a Loutre injection context with a dependency resolver.`);
         this.name = 'InjectionContextError';
     }
 }
 export function inject(token) {
     const context = currentInjectionContext();
-    if (!context)
+    if (!context?.resolve)
         throw new InjectionContextError(token);
     context.record?.(context.consumer, token);
-    return context.resolve(token);
+    return context.resolve(token, context.consumer);
+}
+/** Modelに現れない依存は解決できないため、依存宣言の分岐ではなく構築metadataの取得に使う。 */
+export function injectInquirer() {
+    return currentInjectionContext()?.inquirer;
 }
 function dependencyProbeTarget() { }
 class DependencyProbeBoundary extends Error {

package/dist/core/model/context.d.ts

@@ -1,11 +1,12 @@
 import type { Diagnostic } from '../diagnostic.js';
-import type { ModuleInstance } from '../module.js';
+import { type ModuleInstance } from '../module.js';
 import type { ProviderDescriptor } from '../provider.js';
 import type { TokenLike } from '../token.js';
 import type { ApplicationModelBuildOptions, ApplicationModelEdge, ApplicationModelNode, ExecutionModelNode, ProviderModelNode } from './types.js';
 export interface ModelBuildContext {
     readonly options: ApplicationModelBuildOptions;
     readonly modules: readonly ModuleInstance[];
+    readonly imports: ReadonlyMap<ModuleInstance, readonly ModuleInstance[]>;
     readonly moduleIds: ReadonlyMap<ModuleInstance, string>;
     readonly nodes: ApplicationModelNode[];
     readonly edges: ApplicationModelEdge[];

package/dist/core/model/context.js

@@ -1,27 +1,38 @@
-import { asModuleInstance } from '../module.js';
+import { asModuleInstance, } from '../module.js';
 function collectModules(roots) {
-    const result = [];
-    const seen = new Set();
-    const visit = (candidate) => {
-        const module = asModuleInstance(candidate);
-        if (seen.has(module))
+    const modules = [];
+    const imports = new Map();
+    const instances = new Map();
+    const normalize = (input) => {
+        const existing = instances.get(input);
+        if (existing)
+            return existing;
+        const instance = asModuleInstance(input);
+        instances.set(input, instance);
+        return instance;
+    };
+    const visit = (input) => {
+        const module = normalize(input);
+        if (imports.has(module))
             return;
-        seen.add(module);
-        for (const imported of module.definition.imports ?? [])
-            visit(imported);
-        result.push(module);
+        const imported = (module.definition.imports ?? []).map(normalize);
+        imports.set(module, imported);
+        for (const child of imported)
+            visit(child);
+        modules.push(module);
     };
     for (const root of roots)
         visit(root);
-    return result;
+    return { modules, imports };
 }
 export function createModelBuildContext(options) {
-    const modules = collectModules(options.modules);
+    const { modules, imports } = collectModules(options.modules);
     const moduleIds = new Map(modules.map((module, index) => [module, `module:${index + 1}`]));
     let providerOrdinal = 0;
     return {
         options,
         modules,
+        imports,
         moduleIds,
         nodes: [],
         edges: [],

package/dist/core/model/lifecycle.js

@@ -32,7 +32,7 @@ export function resolveLifecycleDependencies(context) {
                     providerModule &&
                     provider.moduleId !== lifecycle.moduleId &&
                     !moduleDeclaresToken(sourceModule, dependency) &&
-                    !isTokenVisible(sourceModule, providerModule, dependency)) {
+                    !isTokenVisible(context, sourceModule, providerModule, dependency)) {
                     diagnostics.push(diagnostic('LUTRE_MODULE_VISIBILITY', `Lifecycle ${lifecycle.phase} depends on private ${tokenName(dependency)} from another Module.`, lifecycle.id));
                 }
             }

package/dist/core/model/modules.js

@@ -1,6 +1,5 @@
 import { collectInjectedDependencies } from '../injection.js';
 import { diagnostic } from '../diagnostic.js';
-import { asModuleInstance } from '../module.js';
 import { normalizeProvider } from '../provider.js';
 import { tokenName } from '../token.js';
 import { appendLifecycleNodes } from './lifecycle.js';
@@ -18,7 +17,7 @@ export function collectModuleDeclarations(context) {
             }
             moduleNames.add(module.definition.name);
         }
-        const moduleSource = getSourceLocation(module.template);
+        const moduleSource = getSourceLocation(module) ?? getSourceLocation(module.template);
         nodes.push({
             kind: 'module',
             id: moduleId,
@@ -30,8 +29,8 @@ export function collectModuleDeclarations(context) {
                 ? {}
                 : { description: module.definition.description }),
         });
-        for (const imported of module.definition.imports ?? []) {
-            const target = moduleIds.get(asModuleInstance(imported));
+        for (const imported of context.imports.get(module) ?? []) {
+            const target = moduleIds.get(imported);
             if (target)
                 edges.push({ from: moduleId, to: target, kind: 'imports' });
         }
@@ -84,8 +83,9 @@ function collectProviderDependencies(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)) {
+        const dependencies = new Set([candidate.select.contract]);
+        for (const key of Reflect.ownKeys(candidate.mapping)) {
+            const implementation = candidate.mapping[key];
             for (const dependency of collectInjectedDependencies(candidate.provide, () => Reflect.construct(implementation, []))) {
                 dependencies.add(dependency);
             }

package/dist/core/model/providers.js

@@ -17,7 +17,7 @@ export function resolveModuleExports(context) {
                 : undefined;
             if (provider &&
                 providerModule &&
-                isTokenVisible(module, providerModule, exported)) {
+                isTokenVisible(context, module, providerModule, exported)) {
                 edges.push({ from: moduleId, to: provider.id, kind: 'exports' });
                 continue;
             }
@@ -62,7 +62,7 @@ export function resolveProviderDependencies(context) {
                 if (targetModule &&
                     target.moduleId !== provider.moduleId &&
                     !moduleDeclaresToken(sourceModule, dependency) &&
-                    !isTokenVisible(sourceModule, targetModule, dependency)) {
+                    !isTokenVisible(context, sourceModule, targetModule, dependency)) {
                     diagnostics.push(diagnostic('LUTRE_MODULE_VISIBILITY', `Provider ${tokenName(provider.token)} depends on private ${tokenName(dependency)} from another Module.`, provider.id));
                 }
             }

package/dist/core/model/visibility.d.ts

@@ -1,4 +1,5 @@
-import { type ModuleInstance } from '../module.js';
+import type { ModuleInstance } from '../module.js';
+import type { ModelBuildContext } from './context.js';
 import type { TokenLike } from '../token.js';
 export declare function moduleDeclaresToken(module: ModuleInstance, token: TokenLike): boolean;
-export declare function isTokenVisible(source: ModuleInstance, target: ModuleInstance, token: TokenLike, visited?: Set<ModuleInstance<import("../module.js").ModuleDefinition>>): boolean;
+export declare function isTokenVisible(context: ModelBuildContext, source: ModuleInstance, target: ModuleInstance, token: TokenLike, visited?: Set<ModuleInstance<import("../module.js").ModuleDefinition>>): boolean;

package/dist/core/model/visibility.js

@@ -1,19 +1,17 @@
-import { asModuleInstance } from '../module.js';
 import { normalizeProvider } from '../provider.js';
 export function moduleDeclaresToken(module, token) {
     return (module.definition.providers ?? []).some((declaration) => normalizeProvider(declaration).provide === token);
 }
-export function isTokenVisible(source, target, token, visited = new Set()) {
+export function isTokenVisible(context, source, target, token, visited = new Set()) {
     if (visited.has(source))
         return false;
     visited.add(source);
-    for (const importedValue of source.definition.imports ?? []) {
-        const imported = asModuleInstance(importedValue);
+    for (const imported of context.imports.get(source) ?? []) {
         if (!imported.definition.exports?.includes(token))
             continue;
         if (imported === target)
             return true;
-        if (isTokenVisible(imported, target, token, new Set(visited)))
+        if (isTokenVisible(context, imported, target, token, new Set(visited)))
             return true;
     }
     return false;

package/dist/core/model.js

@@ -247,7 +247,7 @@ export function buildApplicationModel(options) {
                     if (providerModule &&
                         provider.moduleId !== moduleId &&
                         !moduleDeclaresToken(module, dependency) &&
-                        !isTokenVisible(module, providerModule, dependency)) {
+                        !isTokenVisible(context, module, providerModule, dependency)) {
                         diagnostics.push(diagnostic('LUTRE_MODULE_VISIBILITY', `Execution ${execution.id} depends on private ${tokenName(dependency)} from another Module.`, execution.id));
                     }
                 }

package/dist/core/module.d.ts

@@ -5,7 +5,7 @@ import { type ProviderDeclaration } from './provider.js';
 export interface ModuleDefinition {
     readonly name?: string;
     readonly description?: string;
-    readonly imports?: readonly ModuleInstance[];
+    readonly imports?: readonly ModuleInput[];
     readonly environment?: readonly EnvClass[];
     readonly providers?: readonly ProviderDeclaration[];
     readonly executions?: readonly ExecutionDeclaration[];
@@ -17,9 +17,9 @@ export interface ModuleTypeInfo<TDefinition extends ModuleDefinition = ModuleDef
     readonly extensions: ExtensionsOfModuleDefinition<TDefinition>;
 }
 type DirectExtensions<TDefinition extends ModuleDefinition> = TDefinition['executions'] extends readonly ExecutionDeclaration[] ? ExtensionOfDefinition<TDefinition['executions'][number]> : never;
-type ImportedExtensions<TDefinition extends ModuleDefinition> = TDefinition['imports'] extends readonly ModuleInstance[] ? ModuleExtensions<TDefinition['imports'][number]> : never;
+type ImportedExtensions<TDefinition extends ModuleDefinition> = TDefinition['imports'] extends readonly ModuleInput[] ? ModuleExtensions<TDefinition['imports'][number]> : never;
 export type ExtensionsOfModuleDefinition<TDefinition extends ModuleDefinition> = DirectExtensions<TDefinition> | ImportedExtensions<TDefinition>;
-export type ModuleExtensions<TModule> = TModule extends ModuleInstance<infer TDefinition> ? ExtensionsOfModuleDefinition<TDefinition> : never;
+export type ModuleExtensions<TModule> = TModule extends ModuleInstance<infer TDefinition> ? ExtensionsOfModuleDefinition<TDefinition> : TModule extends ModuleTemplate<void, infer TDefinition> ? ExtensionsOfModuleDefinition<TDefinition> : never;
 export type ModuleHostApis<TModule> = HostApiOfExtension<ModuleExtensions<TModule>>;
 export interface ModuleInstance<TDefinition extends ModuleDefinition = ModuleDefinition> {
     readonly kind: 'module-instance';
@@ -43,6 +43,8 @@ export type ModuleTemplate<Args, TDefinition extends ModuleDefinition = ModuleDe
     readonly instantiate: (args: Args) => ModuleInstance<TDefinition>;
     readonly [moduleTypeInfo]?: ModuleTypeInfo<TDefinition>;
 };
+export type ModuleInput = ModuleInstance | ModuleTemplate<void>;
+export declare function defineModule<const TDefinition extends ModuleDefinition>(definition: TDefinition): ModuleInstance<TDefinition>;
 export declare function defineModule<Args = void, const TDefinition extends ModuleDefinition = ModuleDefinition>(factory: (args: Args) => TDefinition): ModuleTemplate<Args, TDefinition>;
-export declare function asModuleInstance(module: ModuleInstance | ModuleTemplate<void>): ModuleInstance;
+export declare function asModuleInstance(module: ModuleInput): ModuleInstance;
 export {};

package/dist/core/module.js

@@ -1,6 +1,11 @@
 import { environmentProvider } from './provider.js';
 export const moduleTypeInfo = Symbol('loutre.module-type-info');
-export function defineModule(factory) {
+export function defineModule(definition) {
+    const factory = typeof definition === 'function' ? definition : () => definition;
+    const template = createModuleTemplate(factory);
+    return typeof definition === 'function' ? template : template();
+}
+function createModuleTemplate(factory) {
     const instantiate = (args) => {
         const declared = factory(args);
         const environment = [...new Set(declared.environment ?? [])];

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.8.2";
+export declare const LOUTRE_VERSION = "0.9.1";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.8.2';
+export const LOUTRE_VERSION = '0.9.1';