@loutrejs/loutre 0.9.2 → 0.10.0

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

@@ -2,3 +2,5 @@ export { defineMessagePortContract, defineMessagePortImplementation, messagePort
 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';
+export { decodeMessagePortRequest, messagePortProcedureName, } from './identity.js';
+export type { MessagePortRequestId, MessagePortProcedureName, } from './identity.js';

package/dist/message-port/index.js

@@ -1,2 +1,3 @@
 export { defineMessagePortContract, defineMessagePortImplementation, messagePort, messagePortExtension, } from './extension.js';
 export { attachMessagePort } from './transport.js';
+export { decodeMessagePortRequest, messagePortProcedureName, } from './identity.js';

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

@@ -1,5 +1,6 @@
+import { type MessagePortProcedureName } from './identity.js';
 export interface MessagePortHost {
-    invoke(method: string, input?: unknown): Promise<{
+    invoke(method: MessagePortProcedureName, input?: unknown): Promise<{
         readonly response: string;
         readonly value: unknown;
     }>;
@@ -7,5 +8,6 @@ export interface MessagePortHost {
 export type MessagePortLike = {
     postMessage(value: unknown): void;
     start?(): void;
-} & Pick<EventTarget, 'addEventListener'>;
+    addEventListener(type: 'message', listener: (event: unknown) => void): void;
+};
 export declare function attachMessagePort(host: MessagePortHost, port: MessagePortLike): void;

package/dist/message-port/transport.js

@@ -1,6 +1,11 @@
+import { decodeMessagePortRequest, } from './identity.js';
 export function attachMessagePort(host, port) {
     port.addEventListener('message', async (event) => {
-        const request = event.data;
+        if (typeof event !== 'object' || event === null || !('data' in event))
+            return;
+        const request = decodeMessagePortRequest(event.data);
+        if (!request)
+            return;
         try {
             const result = await host.invoke(request.procedure, request.input);
             if (isAsyncIterable(result.value)) {

package/dist/runtime/async-iterator-lifecycle.d.ts

@@ -1,3 +1,4 @@
+import { type EpochMs } from '../core/units.js';
 export declare class AsyncIteratorCleanupDeadlineError extends Error {
     constructor(message: string);
 }
@@ -8,5 +9,5 @@ export declare class AsyncIteratorLifecycle<T> {
     next(): Promise<IteratorResult<T>>;
     return(reason?: unknown): Promise<IteratorResult<T>>;
     throw(error?: unknown): Promise<IteratorResult<T>>;
-    drain(reason: unknown, deadline: () => number | undefined, timeoutMessage: string): Promise<void>;
+    drain(reason: unknown, deadline: () => EpochMs | undefined, timeoutMessage: string): Promise<void>;
 }

package/dist/runtime/async-iterator-lifecycle.js

@@ -1,3 +1,4 @@
+import { epochNow } from '../core/units.js';
 const cleanupYieldInterval = 32;
 export class AsyncIteratorCleanupDeadlineError extends Error {
     constructor(message) {
@@ -56,7 +57,7 @@ export class AsyncIteratorLifecycle {
         let continuationSteps = 0;
         while (!this.#done) {
             const currentDeadline = deadline();
-            if (currentDeadline !== undefined && Date.now() >= currentDeadline) {
+            if (currentDeadline !== undefined && epochNow() >= currentDeadline) {
                 throw new AsyncIteratorCleanupDeadlineError(timeoutMessage);
             }
             await this.next();

package/dist/runtime/capability.d.ts

@@ -1,4 +1,8 @@
-export type RuntimeCapabilityId = string;
+import type { Brand } from '../internal/brand.js';
+export type RuntimeSupportFeature = Brand<string, 'runtime.support-feature'>;
+export declare const runtimeSupportFeature: (value: string) => RuntimeSupportFeature;
+export declare const runtimeSupportFeatures: (values: Iterable<string>) => ReadonlySet<RuntimeSupportFeature>;
+export type RuntimeCapabilityId = RuntimeSupportFeature;
 export interface RuntimeSupportProfile {
     readonly runtime: string;
     readonly capabilities: ReadonlySet<RuntimeCapabilityId>;
@@ -9,7 +13,7 @@ export interface RuntimeSupportCheck {
     readonly supported: readonly RuntimeCapabilityId[];
     readonly missing: readonly RuntimeCapabilityId[];
 }
-export declare function checkRuntimeSupport(required: Iterable<RuntimeCapabilityId>, runtime: RuntimeSupportProfile): RuntimeSupportCheck;
+export declare function checkRuntimeSupport(required: Iterable<string>, runtime: RuntimeSupportProfile): RuntimeSupportCheck;
 export declare class MissingRuntimeSupportError extends Error {
     readonly check: RuntimeSupportCheck;
     constructor(check: RuntimeSupportCheck);

package/dist/runtime/capability.js

@@ -1,5 +1,7 @@
+export const runtimeSupportFeature = (value) => value;
+export const runtimeSupportFeatures = (values) => new Set([...values].map(runtimeSupportFeature));
 export function checkRuntimeSupport(required, runtime) {
-    const requirements = [...new Set(required)];
+    const requirements = [...runtimeSupportFeatures(required)];
     const missing = requirements.filter((capability) => !runtime.capabilities.has(capability));
     return {
         ok: missing.length === 0,

package/dist/runtime/di.d.ts

@@ -1,5 +1,4 @@
 import { type ArgsClass, type EnvClass, type DependencyResolutionContext, type ProviderDescriptor, type TokenLike } from '../core/index.js';
-import { Logger } from './logger.js';
 export declare class DependencyResolutionError extends Error {
     constructor(message: string);
 }
@@ -7,7 +6,6 @@ export interface ContainerHooks {
     created?(provider: ProviderDescriptor, value: unknown): void;
 }
 export interface ContainerOptions {
-    readonly logger?: Logger;
     readonly dependencies?: ReadonlyMap<TokenLike, readonly TokenLike[]>;
     readonly hooks?: ContainerHooks;
     readonly environment?: ReadonlyMap<EnvClass, object>;
@@ -15,7 +13,7 @@ export interface ContainerOptions {
 }
 export declare class Container {
     #private;
-    constructor(providers: readonly ProviderDescriptor[], options?: Logger | ContainerOptions);
+    constructor(providers: readonly ProviderDescriptor[], options?: ContainerOptions);
     bindEnvironment(environment: EnvClass, value: object): void;
     bindArguments(argumentsContract: ArgsClass, value: object): void;
     resolve<T>(token: TokenLike<T>, context?: string | DependencyResolutionContext): T;

package/dist/runtime/di.js

@@ -1,5 +1,7 @@
 import { isArgsClass, isEnvClass, runInInjectionContext, tokenName, } from '../core/index.js';
-import { Logger } from './logger.js';
+import { LoggerToken } from './logger.js';
+import { defaultLoggerProviders, isLogger, isLoggerToken, } from '../core/logger-internal.js';
+import { bindLoggerSource } from './logger-source.js';
 import { match } from 'ts-pattern';
 export class DependencyResolutionError extends Error {
     constructor(message) {
@@ -10,27 +12,39 @@ export class DependencyResolutionError extends Error {
 export class Container {
     #providers = new Map();
     #applicationCache = new Map();
-    #logger;
+    #loggerToken;
     #dependencies;
     #hooks;
     #environment = new Map();
     #arguments = new Map();
     constructor(providers, options = {}) {
-        this.#logger =
-            options instanceof Logger ? options : (options.logger ?? new Logger());
-        this.#dependencies =
-            options instanceof Logger ? undefined : options.dependencies;
-        this.#hooks = options instanceof Logger ? {} : (options.hooks ?? {});
-        if (!(options instanceof Logger)) {
-            for (const [environment, value] of options.environment ?? []) {
-                this.#environment.set(environment, value);
+        if (isLogger(options) || 'logger' in options) {
+            throw new DependencyResolutionError('LUTRE_LOGGER_CONFIGURATION: Register provide(LoggerToken).useClass(LoggerService) in providers.');
+        }
+        const configured = providers.find((provider) => isLoggerToken(provider.provide));
+        this.#loggerToken =
+            configured && isLoggerToken(configured.provide)
+                ? configured.provide
+                : LoggerToken;
+        this.#dependencies = options.dependencies;
+        this.#hooks = options.hooks ?? {};
+        for (const [environment, value] of options.environment ?? []) {
+            this.#environment.set(environment, value);
+        }
+        for (const [argumentsContract, value] of options.arguments ?? []) {
+            this.#arguments.set(argumentsContract, value);
+        }
+        const declarations = configured
+            ? providers
+            : [...providers, ...defaultLoggerProviders()];
+        for (const provider of declarations) {
+            if (isLoggerToken(provider.provide) && provider.scope !== 'application') {
+                throw new DependencyResolutionError('LUTRE_LOGGER_SCOPE: LoggerToken must have application scope.');
             }
-            for (const [argumentsContract, value] of options.arguments ?? []) {
-                this.#arguments.set(argumentsContract, value);
-            }
-        }
-        for (const provider of providers) {
-            const existing = this.#providers.get(provider.provide);
+            const key = isLoggerToken(provider.provide)
+                ? this.#loggerToken
+                : provider.provide;
+            const existing = this.#providers.get(key);
             if (existing) {
                 if (existing.kind === provider.kind &&
                     isRuntimeInputProvider(provider)) {
@@ -46,7 +60,7 @@ export class Container {
                 }
                 throw new DependencyResolutionError(`LUTRE_DI_DUPLICATE: Duplicate provider for ${tokenName(provider.provide)}`);
             }
-            this.#providers.set(provider.provide, provider);
+            this.#providers.set(key, provider);
         }
     }
     bindEnvironment(environment, value) {
@@ -74,7 +88,8 @@ export class Container {
         return this.#resolve(token, resolution?.source, [], resolution?.consumer);
     }
     get(token) {
-        const provider = this.#providers.get(token);
+        const requested = isLoggerToken(token) ? this.#loggerToken : token;
+        const provider = this.#providers.get(requested);
         if (!provider) {
             if (isEnvClass(token)) {
                 throw new DependencyResolutionError(`LUTRE_ENV_002: ${token.name} is not declared by any Module.environment.`);
@@ -99,24 +114,23 @@ export class Container {
             }
             throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
         }
-        if (this.#applicationCache.has(token)) {
-            return this.#applicationCache.get(token);
+        if (this.#applicationCache.has(requested)) {
+            const value = this.#applicationCache.get(requested);
+            return (isLoggerToken(requested) ? requireLogger(value) : value);
         }
         throw new DependencyResolutionError(`LUTRE_DI_NOT_INITIALIZED: ${tokenName(token)} has not been constructed by Application initialization.`);
     }
     #resolve(token, source, lineage = [], inquirer) {
-        const cycleStart = lineage.indexOf(token);
+        const requested = isLoggerToken(token) ? this.#loggerToken : token;
+        const cycleStart = lineage.indexOf(requested);
         if (cycleStart >= 0) {
-            const cycle = [...lineage.slice(cycleStart), token]
+            const cycle = [...lineage.slice(cycleStart), requested]
                 .map(tokenName)
                 .join(' -> ');
             throw new DependencyResolutionError(`LUTRE_DI_CYCLE: Circular dependency detected: ${cycle}`);
         }
-        const provider = this.#providers.get(token);
+        const provider = this.#providers.get(requested);
         if (!provider) {
-            if (token === Logger) {
-                return this.#logger.child(source === undefined ? {} : { source });
-            }
             if (isEnvClass(token)) {
                 throw new DependencyResolutionError(`LUTRE_ENV_002: ${token.name} is injected by ${source ?? 'Application'} but is not declared by any Module.environment.`);
             }
@@ -125,16 +139,22 @@ export class Container {
             }
             throw new DependencyResolutionError(`LUTRE_DI_UNRESOLVED: ${source ?? 'Application'} requires ${tokenName(token)}, but no provider is declared for ${tokenName(token)}.`);
         }
-        const nextLineage = [...lineage, token];
-        if (provider.scope !== 'application') {
-            return this.#create(provider, nextLineage, inquirer);
+        const nextLineage = [...lineage, requested];
+        let value;
+        if (provider.scope === 'application' &&
+            this.#applicationCache.has(requested)) {
+            value = this.#applicationCache.get(requested);
         }
-        if (this.#applicationCache.has(token)) {
-            return this.#applicationCache.get(token);
+        else {
+            value = this.#create(provider, nextLineage, inquirer);
+            if (provider.scope === 'application')
+                this.#applicationCache.set(requested, value);
         }
-        const instance = this.#create(provider, nextLineage, inquirer);
-        this.#applicationCache.set(token, instance);
-        return instance;
+        if (isLoggerToken(requested)) {
+            const root = requireLogger(value);
+            return (source === undefined ? root : bindLoggerSource(root, source));
+        }
+        return value;
     }
     #create(provider, lineage, inquirer) {
         try {
@@ -212,6 +232,12 @@ export class Container {
 function isRuntimeInputProvider(provider) {
     return provider.kind === 'environment' || provider.kind === 'arguments';
 }
+function requireLogger(value) {
+    if (!isLogger(value)) {
+        throw new DependencyResolutionError('LUTRE_LOGGER_VALUE: The root Logger Provider must return a LoggerService instance.');
+    }
+    return value;
+}
 function isThenable(value) {
     return (((typeof value === 'object' && value !== null) ||
         typeof value === 'function') &&
@@ -219,7 +245,8 @@ function isThenable(value) {
         typeof value.then === 'function');
 }
 export function assertDeclaredDependency(consumer, token, dependencies) {
-    if (!dependencies.includes(token)) {
+    if (!dependencies.includes(token) &&
+        !(isLoggerToken(token) && dependencies.some(isLoggerToken))) {
         throw new DependencyResolutionError(`LUTRE_DI_UNDECLARED_DEPENDENCY: ${consumer} requested ${tokenName(token)}, but it is not declared in the canonical Application Model. Declare dependencies unconditionally; construction metadata and runtime values must not add dependencies.`);
     }
 }

package/dist/runtime/error.d.ts

@@ -1,6 +1,8 @@
+import type { Brand } from '../internal/brand.js';
+export type ApplicationErrorId = Brand<string, 'runtime.application-error-id'>;
 export interface NormalizedApplicationError {
     readonly code: 'INTERNAL_ERROR';
-    readonly errorId: string;
+    readonly errorId: ApplicationErrorId;
     readonly message: string;
     readonly stack?: string;
     readonly cause?: unknown;

package/dist/runtime/index.d.ts

@@ -3,10 +3,10 @@ export type { RuntimeCapabilityId, RuntimeSupportCheck, RuntimeSupportProfile, }
 export { Container, DependencyResolutionError } from './di.js';
 export type { ContainerOptions } from './di.js';
 export { normalizeUnknownError } from './error.js';
-export type { NormalizedApplicationError } from './error.js';
+export type { NormalizedApplicationError, ApplicationErrorId } from './error.js';
 export { assertRuntimeEngine, assertSupportedBunVersion, detectRuntimeEngine, } from './engine.js';
 export type { RuntimeEngine } from './engine.js';
-export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, Logger, SilentLogger, } from './logger.js';
+export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, LoggerService, LoggerToken, SilentLogger, } from './logger.js';
 export type { ConsoleLoggerBackendOptions, LoggerBackend, LogLevel, LogRecord, } from './logger.js';
 export { ApplicationKernelRuntime } from './kernel.js';
 export type { ApplicationKernelRuntimeOptions } from './kernel.js';
@@ -17,3 +17,7 @@ export { ProcessShutdownHooks } from './shutdown-hooks.js';
 export type { ProcessShutdownHooksOptions, ProcessSignalSource, ShutdownSignal, } from './shutdown-hooks.js';
 export { ApplicationShutdownError, RuntimeShutdown } from './shutdown.js';
 export type { RuntimeShutdownOptions } from './shutdown.js';
+export { runtimeSupportFeature, runtimeSupportFeatures } from './capability.js';
+export type { RuntimeSupportFeature } from './capability.js';
+export { boundPort } from './server-port.js';
+export type { RequestedPort, BoundPort } from './server-port.js';

package/dist/runtime/index.js

@@ -2,10 +2,12 @@ export { checkRuntimeSupport, MissingRuntimeSupportError, } from './capability.j
 export { Container, DependencyResolutionError } from './di.js';
 export { normalizeUnknownError } from './error.js';
 export { assertRuntimeEngine, assertSupportedBunVersion, detectRuntimeEngine, } from './engine.js';
-export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, Logger, SilentLogger, } from './logger.js';
+export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, LoggerService, LoggerToken, SilentLogger, } from './logger.js';
 export { ApplicationKernelRuntime } from './kernel.js';
 export { nodeRuntimeSupport } from './node-capabilities.js';
 export { canRetryOnNextPort, initialServerPort } from './server-port.js';
 export { serverUrl } from './server-url.js';
 export { ProcessShutdownHooks } from './shutdown-hooks.js';
 export { ApplicationShutdownError, RuntimeShutdown } from './shutdown.js';
+export { runtimeSupportFeature, runtimeSupportFeatures } from './capability.js';
+export { boundPort } from './server-port.js';

package/dist/runtime/kernel.d.ts

@@ -1,9 +1,7 @@
 import { RuntimeCapabilityRegistry, type ApplicationModel, type ExecutionExtension, type ExecutionExtensionRuntime, type ExecutionKernelRuntime, type ExecutionRuntimeBinding, type ExecutionLease, type ExecutionOperationLease, type RuntimeCapabilityBinding, type RuntimeExecutionMetadata, type RuntimeInstrumentation, type RuntimeInvocationRegistration, type RuntimeOperationMetadata, type TokenLike } from '../core/index.js';
 import { Container } from './di.js';
-import { Logger } from './logger.js';
 export interface ApplicationKernelRuntimeOptions {
     readonly capabilities?: readonly RuntimeCapabilityBinding[];
-    readonly logger?: Logger;
     readonly environmentSource?: unknown;
     readonly argumentsSource?: unknown;
     readonly forceShutdownTimeoutMs?: number;

package/dist/runtime/kernel.js

@@ -1,8 +1,10 @@
+import { milliseconds } from '../core/units.js';
 import { ApplicationShutdownError } from './shutdown.js';
 import { assertValidApplicationModel, loadArgs, loadEnv, RuntimeCapabilityRegistry, tokenName, } from '../core/index.js';
 import { Container, assertDeclaredDependency } from './di.js';
 import { ExecutionTracker } from './execution-tracker.js';
-import { Logger } from './logger.js';
+import { LoggerToken } from './logger.js';
+import { loggerLifecycleOwner } from './logger-source.js';
 const defaultForceShutdownTimeoutMs = 5_000;
 export class ApplicationKernelRuntime {
     model;
@@ -10,6 +12,9 @@ export class ApplicationKernelRuntime {
     capabilities;
     #extensionRuntimes = new Map();
     #providerInstances = new Map();
+    #createdInstances = [];
+    #trackedInstances = new Set();
+    #initializedInstanceCount = 0;
     #providerNodes = new Map();
     #executionBindings = new Map();
     #initializedModuleIds = new Set();
@@ -23,6 +28,9 @@ export class ApplicationKernelRuntime {
     #initialization;
     #shutdown;
     constructor(model, options = {}) {
+        if ('logger' in options) {
+            throw new TypeError('LUTRE_LOGGER_CONFIGURATION: Register provide(LoggerToken).useClass(LoggerService) in Module.providers; runtime Logger overrides are not supported.');
+        }
         this.model = assertValidApplicationModel(model);
         for (const node of this.model.nodes) {
             if (node.kind === 'provider')
@@ -32,21 +40,19 @@ export class ApplicationKernelRuntime {
         this.#environmentSource = options.environmentSource;
         this.#argumentsSource =
             'argumentsSource' in options ? options.argumentsSource : Object.freeze({});
-        this.#forceShutdownTimeoutMs =
-            options.forceShutdownTimeoutMs ?? defaultForceShutdownTimeoutMs;
+        this.#forceShutdownTimeoutMs = milliseconds(options.forceShutdownTimeoutMs ?? defaultForceShutdownTimeoutMs);
         this.#instrumentation = options.instrumentation;
         if (!Number.isFinite(this.#forceShutdownTimeoutMs) ||
             this.#forceShutdownTimeoutMs < 0) {
             throw new TypeError('LUTRE_FORCE_SHUTDOWN_TIMEOUT: forceShutdownTimeoutMs must be a non-negative finite number.');
         }
         this.container = new Container(model.providers, {
-            logger: options.logger ?? new Logger(),
             dependencies: new Map([...this.#providerNodes.values()].map((node) => [
                 node.token,
                 node.dependencies,
             ])),
             hooks: {
-                created: (provider, value) => this.#notifyProviderCreated(provider, value),
+                created: (provider, value) => this.#onProviderCreated(provider, value),
             },
         });
         for (const { extension, executions } of this.model.extensions) {
@@ -88,6 +94,8 @@ export class ApplicationKernelRuntime {
         try {
             this.#validateCapabilities();
             await this.#bindRuntimeInputs();
+            this.container.resolve(LoggerToken);
+            await this.#initializeConstructedProviders();
             await this.#initializeProviders();
             for (const modelExtension of this.model.extensions) {
                 const runtime = await modelExtension.extension.createRuntime({
@@ -141,8 +149,6 @@ export class ApplicationKernelRuntime {
     }
     async #initializeProviders() {
         for (const module of moduleNodes(this.model)) {
-            const instances = [];
-            this.#providerInstances.set(module.id, instances);
             for (const providerNode of providerNodesOfModule(this.model, module.id)) {
                 const provider = providerNode.provider;
                 if (provider.scope !== 'application' ||
@@ -150,13 +156,15 @@ export class ApplicationKernelRuntime {
                     provider.kind === 'arguments') {
                     continue;
                 }
-                const instance = this.container.resolve(provider.provide);
-                instances.push(instance);
-                await callLifecycle(instance, 'onModuleInit');
+                this.container.resolve(provider.provide);
+                await this.#initializeConstructedProviders();
             }
             this.#initializedModuleIds.add(module.id);
             await this.#runHook(lifecycleHookOf(this.model, module.id, 'onModuleInit'));
         }
+        for (const instance of this.#providerInstances.get('application') ?? []) {
+            await callLifecycle(instance, 'onApplicationBootstrap');
+        }
         for (const module of moduleNodes(this.model)) {
             for (const instance of this.#providerInstances.get(module.id) ?? []) {
                 await callLifecycle(instance, 'onApplicationBootstrap');
@@ -164,6 +172,12 @@ export class ApplicationKernelRuntime {
             await this.#runHook(lifecycleHookOf(this.model, module.id, 'onApplicationBootstrap'));
         }
     }
+    async #initializeConstructedProviders() {
+        while (this.#initializedInstanceCount < this.#createdInstances.length) {
+            const instance = this.#createdInstances[this.#initializedInstanceCount++];
+            await callLifecycle(instance, 'onModuleInit');
+        }
+    }
     executionBindings(extension) {
         const bindings = this.#executionBindings.get(extension.identity);
         if (!bindings) {
@@ -211,7 +225,18 @@ export class ApplicationKernelRuntime {
     beginOperation(metadata, invocation) {
         return instrumentationLease(safely(() => this.#instrumentation?.beginOperation?.(metadata, invocation)));
     }
-    #notifyProviderCreated(provider, value) {
+    #onProviderCreated(provider, value) {
+        const node = this.#providerNodes.get(provider);
+        const owner = loggerLifecycleOwner(value);
+        if (node &&
+            provider.scope === 'application' &&
+            !this.#trackedInstances.has(owner)) {
+            this.#trackedInstances.add(owner);
+            this.#createdInstances.push(owner);
+            const instances = this.#providerInstances.get(node.moduleId) ?? [];
+            instances.push(owner);
+            this.#providerInstances.set(node.moduleId, instances);
+        }
         const instrumentation = this.#instrumentation;
         if (!instrumentation?.providerCreated)
             return;
@@ -305,6 +330,7 @@ export class ApplicationKernelRuntime {
         }
         this.#extensionDrainOperations.clear();
         await this.#cleanupProviders(signal, errors);
+        await this.#disposeProviders(errors);
         this.#state = 'stopped';
         await closeInstrumentation(this.#instrumentation);
         if (errors.length > 0) {
@@ -338,23 +364,28 @@ export class ApplicationKernelRuntime {
     }
     async #cleanupProviders(signal, errors) {
         const modules = moduleNodes(this.model).toReversed();
-        for (const module of modules) {
-            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
-                await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
+        for (const phase of [
+            'onModuleDestroy',
+            'beforeApplicationShutdown',
+            'onApplicationShutdown',
+        ]) {
+            for (const module of modules) {
+                for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
+                    await collectError(() => callLifecycle(instance, phase, phase === 'onModuleDestroy' ? undefined : signal), errors);
+                }
+                await collectError(() => this.#runCleanupHook(module.id, phase), errors);
             }
-            await collectError(() => this.#runCleanupHook(module.id, 'onModuleDestroy'), errors);
-        }
-        for (const module of modules) {
-            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
-                await collectError(() => callLifecycle(instance, 'beforeApplicationShutdown', signal), errors);
+            for (const instance of (this.#providerInstances.get('application') ?? []).toReversed()) {
+                await collectError(() => callLifecycle(instance, phase, phase === 'onModuleDestroy' ? undefined : signal), errors);
             }
-            await collectError(() => this.#runCleanupHook(module.id, 'beforeApplicationShutdown'), errors);
         }
-        for (const module of modules) {
-            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
-                await collectError(() => callLifecycle(instance, 'onApplicationShutdown', signal), errors);
-            }
-            await collectError(() => this.#runCleanupHook(module.id, 'onApplicationShutdown'), errors);
+    }
+    async #disposeProviders(errors) {
+        for (const module of moduleNodes(this.model).toReversed()) {
+            await collectError(() => this.#runCleanupHook(module.id, 'onApplicationDispose'), errors);
+        }
+        for (const instance of this.#createdInstances.toReversed()) {
+            await collectError(() => callLifecycle(instance, 'onApplicationDispose'), errors);
         }
     }
     async #rollbackInitialization() {
@@ -369,14 +400,21 @@ export class ApplicationKernelRuntime {
                 await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
             }
         }
+        for (const instance of (this.#providerInstances.get('application') ?? []).toReversed()) {
+            await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
+        }
+        await this.#disposeProviders(errors);
         await closeInstrumentation(this.#instrumentation);
         return errors;
     }
-    async #runHook(hook) {
-        if (!hook)
+    async #runHook(node) {
+        if (!node)
             return;
-        const dependencies = hook.inject.map((token) => this.container.resolve(token));
-        await hook.run(...dependencies);
+        const dependencies = node.hook.inject.map((token) => this.container.resolve(token, {
+            source: node.id,
+            consumer: { id: node.id, name: node.phase, kind: 'lifecycle' },
+        }));
+        await node.hook.run(...dependencies);
     }
     async #runCleanupHook(moduleId, phase) {
         if (!this.#initializedModuleIds.has(moduleId))
@@ -393,7 +431,7 @@ function providerNodesOfModule(model, moduleId) {
 function lifecycleHookOf(model, moduleId, phase) {
     return model.nodes.find((node) => node.kind === 'lifecycle' &&
         node.moduleId === moduleId &&
-        node.phase === phase)?.hook;
+        node.phase === phase);
 }
 function instrumentationLease(scope) {
     return {

package/dist/runtime/logger-source.d.ts

@@ -0,0 +1,4 @@
+import type { LoggerService } from './logger.js';
+export declare function loggerLifecycleOwner(value: LoggerService): LoggerService;
+export declare function loggerLifecycleOwner(value: unknown): unknown;
+export declare function bindLoggerSource(logger: LoggerService, source: string): LoggerService;

package/dist/runtime/logger-source.js

@@ -0,0 +1,47 @@
+import { isLogger } from '../core/logger-internal.js';
+import { loggerInstanceBrand, loggerSourceRoot, } from '../core/logger-identity.js';
+export function loggerLifecycleOwner(value) {
+    if (!isLogger(value) || !(loggerSourceRoot in value))
+        return value;
+    let owner = value;
+    const visited = new Set();
+    while (loggerSourceRoot in owner && !visited.has(owner)) {
+        visited.add(owner);
+        const root = owner[loggerSourceRoot];
+        if (!isLogger(root))
+            break;
+        owner = root;
+    }
+    return owner;
+}
+export function bindLoggerSource(logger, source) {
+    const context = { ...logger.context, source };
+    const bind = (level) => (message, fields = {}) => logger[level](message, { source, ...fields });
+    const methods = {
+        debug: bind('debug'),
+        info: bind('info'),
+        warn: bind('warn'),
+        error: bind('error'),
+    };
+    const reference = {
+        [loggerInstanceBrand]: true,
+        [loggerSourceRoot]: loggerLifecycleOwner(logger),
+        backend: logger.backend,
+        context,
+        ...methods,
+        onApplicationDispose: () => logger.onApplicationDispose(),
+    };
+    Object.setPrototypeOf(reference, Reflect.getPrototypeOf(logger));
+    // 凍結した元の実体を対象にすると、出力メソッドとcontextを委譲用に置き換えられない。
+    return new Proxy(reference, {
+        get(target, property) {
+            if (Object.hasOwn(target, property))
+                return Reflect.get(target, property);
+            // private fieldを持つ実装のreceiverをproxyへ置き換えない。
+            const value = Reflect.get(logger, property, logger);
+            return typeof value === 'function' && property !== 'constructor'
+                ? value.bind(logger)
+                : value;
+        },
+    });
+}