@loutrejs/loutre 0.9.2 → 0.10.1

package/dist/core/index.js

@@ -1,3 +1,5 @@
+export { LoggerService, LoggerToken } from './logger.js';
+export { LoggerModule } from './logger-module.js';
 export { defineArgs, isArgsClass, loadArgs } from './args.js';
 export { diagnostic, hasErrorDiagnostics, isErrorDiagnostic, } from './diagnostic.js';
 export { defineEnv, isEnvClass, loadEnv } from './env.js';
@@ -7,9 +9,13 @@ export { composeLayers, defineLayer } from './generic-layer.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';
+export { defineModule, moduleTypeInfo } from './module.js';
 export { argumentsProvider, environmentProvider, normalizeProvider, provide, } from './provider.js';
 export { getSourceLocation, inheritSourceLocation, registerSourceLocation, } from './source-location.js';
 export { SchemaValidationError, supportsJsonSchema, validateSchema, } from './schema.js';
 export { token, tokenName } from './token.js';
 export { type } from './type.js';
+export * from './identity.js';
+export * from './units.js';
+export { parseModelNodeId, parseProviderNodeId } from './model/identity.js';
+export { sourceFileReference, sourceLine, sourceColumn, } from './source-location.js';

package/dist/core/injection.d.ts

@@ -1,6 +1,7 @@
+import type { DependencyConsumerId } from './identity.js';
 import type { TokenLike, TokenValue } from './token.js';
 export interface DependencyConsumerDescriptor {
-    readonly id: string;
+    readonly id: DependencyConsumerId;
     readonly name: string;
     readonly kind?: string;
 }

package/dist/core/instrumentation.d.ts

@@ -1,23 +1,25 @@
+import type { RuntimeExecutionId } from './identity.js';
+import type { ModelNodeId, ProviderNodeId } from './model/identity.js';
 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 executionId: RuntimeExecutionId;
     readonly executionKind: string;
     readonly name?: string;
-    readonly graphNodeId?: string;
+    readonly graphNodeId?: ModelNodeId;
 }
 export interface RuntimeOperationMetadata {
     readonly kind: string;
     readonly name: string;
-    readonly graphNodeId?: string;
+    readonly graphNodeId?: ModelNodeId;
 }
 export interface RuntimeProviderMetadata {
-    readonly providerId: string;
+    readonly providerId: ProviderNodeId;
     readonly name: string;
-    readonly graphNodeId: string;
+    readonly graphNodeId: ProviderNodeId;
     readonly scope: Scope;
     readonly providerKind: 'value' | 'class' | 'factory' | 'conditional' | 'environment' | 'arguments';
 }

package/dist/core/lifecycle.d.ts

@@ -14,6 +14,9 @@ export interface BeforeApplicationShutdown {
 export interface OnApplicationShutdown {
     onApplicationShutdown(signal?: string): void | Promise<void>;
 }
+export interface OnApplicationDispose {
+    onApplicationDispose(): void | Promise<void>;
+}
 export interface LifecycleHook<TInject extends readonly TokenLike[] = readonly TokenLike[]> {
     readonly kind: 'lifecycle-hook';
     readonly inject: TInject;
@@ -31,4 +34,5 @@ export interface ModuleLifecycle {
     readonly onModuleDestroy?: LifecycleHook<any>;
     readonly beforeApplicationShutdown?: LifecycleHook<any>;
     readonly onApplicationShutdown?: LifecycleHook<any>;
+    readonly onApplicationDispose?: LifecycleHook<any>;
 }

package/dist/core/logger-identity.d.ts

@@ -0,0 +1,4 @@
+export declare const loggerTokenBrand: unique symbol;
+export declare const loggerInstanceBrand: unique symbol;
+export declare const loggerSourceRoot: unique symbol;
+export declare function isLoggerTokenIdentity(value: unknown): boolean;

package/dist/core/logger-identity.js

@@ -0,0 +1,9 @@
+export const loggerTokenBrand = Symbol.for('loutre.logger.token');
+export const loggerInstanceBrand = Symbol.for('loutre.logger.instance');
+export const loggerSourceRoot = Symbol.for('loutre.logger.source-root');
+export function isLoggerTokenIdentity(value) {
+    return (typeof value === 'function' &&
+        Object.hasOwn(value, loggerTokenBrand) &&
+        loggerTokenBrand in value &&
+        value[loggerTokenBrand] === true);
+}

package/dist/core/logger-internal.d.ts

@@ -0,0 +1,5 @@
+import { LoggerService } from './logger.js';
+import { type ProviderDescriptor } from './provider.js';
+export declare function isLoggerToken(value: unknown): value is typeof LoggerService;
+export declare function isLogger(value: unknown): value is LoggerService;
+export declare function defaultLoggerProviders(): readonly ProviderDescriptor[];

package/dist/core/logger-internal.js

@@ -0,0 +1,27 @@
+import { ConsoleLoggerBackend, LoggerService, LoggerToken, } from './logger.js';
+import { inject } from './injection.js';
+import { provide } from './provider.js';
+import { token } from './token.js';
+import { loggerInstanceBrand, isLoggerTokenIdentity, } from './logger-identity.js';
+export function isLoggerToken(value) {
+    // Loggerの派生クラスもrootにできるため、継承された印は予約tokenの判定に使わない。
+    return isLoggerTokenIdentity(value);
+}
+export function isLogger(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        loggerInstanceBrand in value &&
+        value[loggerInstanceBrand] === true);
+}
+const defaultBackendToken = token('loutre.logger.backend');
+class DefaultLogger extends LoggerService {
+    constructor(backend = inject(defaultBackendToken)) {
+        super(backend);
+    }
+}
+export function defaultLoggerProviders() {
+    return [
+        provide(defaultBackendToken).useClass(ConsoleLoggerBackend),
+        provide(LoggerToken).useClass(DefaultLogger),
+    ];
+}

package/dist/core/logger-module.d.ts

@@ -0,0 +1,5 @@
+export declare const LoggerModule: import("./module.js").ModuleInstance<{
+    readonly name: "LoggerModule";
+    readonly providers: readonly import("./provider.js").ProviderDescriptor[];
+    readonly exports: readonly [typeof import("./logger.js").LoggerService];
+}>;

package/dist/core/logger-module.js

@@ -0,0 +1,8 @@
+import { LoggerToken } from './logger.js';
+import { defaultLoggerProviders } from './logger-internal.js';
+import { defineModule } from './module.js';
+export const LoggerModule = defineModule({
+    name: 'LoggerModule',
+    providers: defaultLoggerProviders(),
+    exports: [LoggerToken],
+});

package/dist/core/logger.d.ts

@@ -0,0 +1,42 @@
+import { frameworkProvidedTokenBrand } from './token-internal.js';
+import { loggerInstanceBrand, loggerTokenBrand } from './logger-identity.js';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogRecord {
+    readonly timestamp: string;
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly [key: string]: unknown;
+}
+export interface LoggerBackend {
+    write(record: LogRecord): void;
+}
+export interface ConsoleLoggerBackendOptions {
+    readonly colors?: boolean;
+    readonly prefix?: string;
+}
+export declare class ConsoleLoggerBackend implements LoggerBackend {
+    #private;
+    constructor(options?: ConsoleLoggerBackendOptions);
+    write(record: LogRecord): void;
+}
+export declare class JsonConsoleLoggerBackend implements LoggerBackend {
+    write(record: LogRecord): void;
+}
+export declare class LoggerService {
+    #private;
+    readonly backend: LoggerBackend;
+    static readonly [frameworkProvidedTokenBrand] = true;
+    static readonly [loggerTokenBrand] = true;
+    readonly [loggerInstanceBrand] = true;
+    readonly context: Readonly<Record<string, unknown>>;
+    constructor(backend?: LoggerBackend, context?: Readonly<Record<string, unknown>>);
+    debug(message: string, context?: Readonly<Record<string, unknown>>): void;
+    info(message: string, context?: Readonly<Record<string, unknown>>): void;
+    warn(message: string, context?: Readonly<Record<string, unknown>>): void;
+    error(message: string, context?: Readonly<Record<string, unknown>>): void;
+    onApplicationDispose(): void;
+}
+export declare const LoggerToken: typeof LoggerService;
+export declare class SilentLogger extends LoggerService {
+    constructor(context?: Readonly<Record<string, unknown>>);
+}

package/dist/core/logger.js

@@ -0,0 +1,221 @@
+import { frameworkProvidedTokenBrand } from './token-internal.js';
+import { loggerInstanceBrand, loggerTokenBrand } from './logger-identity.js';
+export class ConsoleLoggerBackend {
+    #colors;
+    #prefix;
+    constructor(options = {}) {
+        this.#colors = options.colors ?? detectConsoleColors();
+        this.#prefix = options.prefix ?? 'Loutre';
+    }
+    write(record) {
+        writeToConsole(record.level, formatConsoleLogRecord(record, this.#prefix, this.#colors));
+    }
+}
+export class JsonConsoleLoggerBackend {
+    write(record) {
+        writeToConsole(record.level, serializeLogRecord(record));
+    }
+}
+class SilentLoggerBackend {
+    write(_record) { }
+}
+export class LoggerService {
+    backend;
+    static #disposed = new WeakSet();
+    static [frameworkProvidedTokenBrand] = true;
+    static [loggerTokenBrand] = true;
+    [loggerInstanceBrand] = true;
+    context;
+    constructor(backend = new ConsoleLoggerBackend(), context = {}) {
+        this.backend = backend;
+        this.context = { source: 'Application', ...context };
+    }
+    debug(message, context = {}) {
+        LoggerService.#write(this, 'debug', message, context);
+    }
+    info(message, context = {}) {
+        LoggerService.#write(this, 'info', message, context);
+    }
+    warn(message, context = {}) {
+        LoggerService.#write(this, 'warn', message, context);
+    }
+    error(message, context = {}) {
+        LoggerService.#write(this, 'error', message, context);
+    }
+    onApplicationDispose() {
+        LoggerService.#disposed.add(this);
+    }
+    static #write(logger, level, message, context) {
+        const record = {
+            ...logger.context,
+            ...context,
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+        };
+        if (LoggerService.#disposed.has(logger)) {
+            writeToConsole(level, serializeLogRecord(record));
+            return;
+        }
+        logger.backend.write(record);
+    }
+}
+export const LoggerToken = LoggerService;
+export class SilentLogger extends LoggerService {
+    constructor(context = {}) {
+        super(new SilentLoggerBackend(), context);
+    }
+}
+function serializeLogRecord(record) {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(record, (_key, value) => {
+            if (typeof value === 'bigint')
+                return value.toString();
+            if (value !== null && typeof value === 'object') {
+                if (seen.has(value))
+                    return '[Circular]';
+                seen.add(value);
+            }
+            if (value instanceof Error) {
+                return {
+                    ...value,
+                    name: value.name,
+                    message: value.message,
+                    ...(value.stack === undefined ? {} : { stack: value.stack }),
+                    ...(value.cause === undefined ? {} : { cause: value.cause }),
+                    ...(value instanceof AggregateError ? { errors: value.errors } : {}),
+                };
+            }
+            return value;
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            timestamp: record.timestamp,
+            level: 'error',
+            message: 'Log record serialization failed',
+            serializationError: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function writeToConsole(level, value) {
+    const target = level === 'error'
+        ? console.error
+        : level === 'warn'
+            ? console.warn
+            : console.log;
+    target(value);
+}
+function formatConsoleLogRecord(record, prefix, colors) {
+    const { timestamp, level, message, ...recordContext } = record;
+    const context = { ...recordContext };
+    const source = typeof context.source === 'string'
+        ? context.source
+        : typeof context.protocol === 'string'
+            ? context.protocol
+            : undefined;
+    if (source !== undefined)
+        delete context.source;
+    const runtimeProcess = getRuntimeProcess();
+    const processLabel = runtimeProcess?.pid === undefined
+        ? `[${prefix}]`
+        : `[${prefix}] ${runtimeProcess.pid}`;
+    const levelLabel = level === 'info' ? 'LOG' : level.toUpperCase();
+    const levelColor = level === 'error' ? 31 : level === 'warn' ? 33 : level === 'debug' ? 36 : 32;
+    const sourceLabel = source === undefined ? '' : `${paint(`[${source}]`, 33, colors)} `;
+    const formattedContext = formatLogContext(context);
+    const contextSuffix = formattedContext === '' ? '' : ` ${paint(formattedContext, 90, colors)}`;
+    return `${paint(processLabel, 32, colors)}  - ${formatLocalTimestamp(timestamp)}  ${paint(levelLabel.padStart(7), levelColor, colors)} ${sourceLabel}${paint(message, levelColor, colors)}${contextSuffix}`;
+}
+function formatLogContext(context) {
+    const entries = Object.entries(context);
+    if (entries.length === 0)
+        return '';
+    return `{ ${entries
+        .map(([key, value]) => `${formatLogKey(key)}=${formatLogValue(value)}`)
+        .join(', ')} }`;
+}
+function formatLogKey(key) {
+    return /^[A-Za-z_$][\w$]*$/u.test(key) ? key : JSON.stringify(key);
+}
+function formatLogValue(value, ancestors = new WeakSet()) {
+    try {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string') {
+            return /^[\w./:@+-]+$/u.test(value) ? value : JSON.stringify(value);
+        }
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (typeof value === 'bigint')
+            return `${value}n`;
+        if (typeof value === 'symbol')
+            return String(value);
+        if (typeof value === 'function')
+            return `[Function ${value.name || 'anonymous'}]`;
+        if (ancestors.has(value))
+            return '[Circular]';
+        ancestors.add(value);
+        try {
+            if (value instanceof Date)
+                return value.toISOString();
+            if (value instanceof Error) {
+                return formatLogValue({
+                    name: value.name,
+                    message: value.message,
+                    ...(value.stack === undefined ? {} : { stack: value.stack }),
+                    ...(value.cause === undefined ? {} : { cause: value.cause }),
+                }, ancestors);
+            }
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => formatLogValue(item, ancestors)).join(', ')}]`;
+            }
+            return `{ ${Object.entries(value)
+                .map(([key, item]) => `${formatLogKey(key)}=${formatLogValue(item, ancestors)}`)
+                .join(', ')} }`;
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `[Unformattable: ${message}]`;
+    }
+}
+function formatLocalTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime()))
+        return timestamp;
+    return ([
+        date.getFullYear(),
+        String(date.getMonth() + 1).padStart(2, '0'),
+        String(date.getDate()).padStart(2, '0'),
+    ].join('/') +
+        ` ${[
+            String(date.getHours()).padStart(2, '0'),
+            String(date.getMinutes()).padStart(2, '0'),
+            String(date.getSeconds()).padStart(2, '0'),
+        ].join(':')}.${String(date.getMilliseconds()).padStart(3, '0')}`);
+}
+function paint(value, color, enabled) {
+    return enabled ? `\u001B[${color}m${value}\u001B[39m` : value;
+}
+function getRuntimeProcess() {
+    return globalThis.process;
+}
+function detectConsoleColors() {
+    const runtimeProcess = getRuntimeProcess();
+    const environment = runtimeProcess?.env;
+    if (environment?.NO_COLOR !== undefined ||
+        environment?.NODE_DISABLE_COLORS !== undefined) {
+        return false;
+    }
+    if (environment?.FORCE_COLOR !== undefined) {
+        return environment.FORCE_COLOR !== '0';
+    }
+    return runtimeProcess?.stdout?.isTTY === true;
+}

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

@@ -1,19 +1,22 @@
+import { type ModuleId, type ProviderNodeId } from './identity.js';
 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 roots: readonly ModuleInstance[];
     readonly modules: readonly ModuleInstance[];
     readonly imports: ReadonlyMap<ModuleInstance, readonly ModuleInstance[]>;
-    readonly moduleIds: ReadonlyMap<ModuleInstance, string>;
+    readonly moduleIds: ReadonlyMap<ModuleInstance, ModuleId>;
     readonly nodes: ApplicationModelNode[];
     readonly edges: ApplicationModelEdge[];
     readonly diagnostics: Diagnostic[];
     readonly providers: ProviderDescriptor[];
     readonly executions: ExecutionModelNode[];
     readonly providerNodes: Map<TokenLike, ProviderModelNode>;
-    nextProviderId(): string;
+    nextProviderId(): ProviderNodeId;
 }
 export declare function createModelBuildContext(options: ApplicationModelBuildOptions): ModelBuildContext;
+export declare function findProviderNode(context: Pick<ModelBuildContext, 'providerNodes'>, token: TokenLike): ProviderModelNode | undefined;

package/dist/core/model/context.js

@@ -1,21 +1,14 @@
-import { asModuleInstance, } from '../module.js';
+import { isLoggerToken } from '../logger-internal.js';
+import { moduleId, providerNodeId, } from './identity.js';
 function collectModules(roots) {
     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);
+    const visit = (module) => {
+        if (module?.kind !== 'module-instance')
+            throw new TypeError('Application modules and imports require Module instances.');
         if (imports.has(module))
             return;
-        const imported = (module.definition.imports ?? []).map(normalize);
+        const imported = [...(module.definition.imports ?? [])];
         imports.set(module, imported);
         for (const child of imported)
             visit(child);
@@ -23,14 +16,15 @@ function collectModules(roots) {
     };
     for (const root of roots)
         visit(root);
-    return { modules, imports };
+    return { modules, imports, rootModules: [...roots] };
 }
 export function createModelBuildContext(options) {
-    const { modules, imports } = collectModules(options.modules);
-    const moduleIds = new Map(modules.map((module, index) => [module, `module:${index + 1}`]));
+    const { modules, imports, rootModules } = collectModules(options.modules);
+    const moduleIds = new Map(modules.map((module, index) => [module, moduleId(index + 1)]));
     let providerOrdinal = 0;
     return {
         options,
+        roots: rootModules,
         modules,
         imports,
         moduleIds,
@@ -40,6 +34,12 @@ export function createModelBuildContext(options) {
         providers: [],
         executions: [],
         providerNodes: new Map(),
-        nextProviderId: () => `provider:${++providerOrdinal}`,
+        nextProviderId: () => providerNodeId(++providerOrdinal),
     };
 }
+export function findProviderNode(context, token) {
+    return (context.providerNodes.get(token) ??
+        (isLoggerToken(token)
+            ? [...context.providerNodes.values()].find((node) => isLoggerToken(node.token))
+            : undefined));
+}

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

@@ -0,0 +1,19 @@
+type ModelId<Kind extends string> = string & {
+    readonly '~loutre.model-node-id': Kind;
+};
+export type ModuleId = ModelId<'module'>;
+export type ProviderNodeId = ModelId<'provider'>;
+export type ExecutionNodeId = ModelId<'execution'>;
+export type LifecycleNodeId = ModelId<'lifecycle'>;
+export type CapabilityNodeId = ModelId<'capability'>;
+export type ExtensionNodeId = ModelId<'extension'>;
+export type ModelNodeId = ModuleId | ProviderNodeId | ExecutionNodeId | LifecycleNodeId | CapabilityNodeId | ExtensionNodeId;
+export declare const moduleId: (ordinal: number) => ModuleId;
+export declare const providerNodeId: (ordinal: number) => ProviderNodeId;
+export declare const executionNodeId: (value: string) => ExecutionNodeId;
+export declare const lifecycleNodeId: (owner: ModuleId, phase: string) => LifecycleNodeId;
+export declare const capabilityNodeId: (value: string) => CapabilityNodeId;
+export declare const extensionNodeId: (value: string) => ExtensionNodeId;
+export declare const parseModelNodeId: (value: unknown) => ModelNodeId | undefined;
+export declare const parseProviderNodeId: (value: unknown) => ProviderNodeId | undefined;
+export {};

package/dist/core/model/identity.js

@@ -0,0 +1,8 @@
+export const moduleId = (ordinal) => `module:${ordinal}`;
+export const providerNodeId = (ordinal) => `provider:${ordinal}`;
+export const executionNodeId = (value) => value;
+export const lifecycleNodeId = (owner, phase) => `lifecycle:${owner}:${phase}`;
+export const capabilityNodeId = (value) => `capability:${value}`;
+export const extensionNodeId = (value) => `extension:${value}`;
+export const parseModelNodeId = (value) => typeof value === 'string' ? value : undefined;
+export const parseProviderNodeId = (value) => typeof value === 'string' ? value : undefined;

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

@@ -1,5 +1,6 @@
+import { type ModuleId } from './identity.js';
 import type { ModuleInstance } from '../module.js';
 import type { ApplicationModelEdge, ApplicationModelNode } from './types.js';
-import type { ModelBuildContext } from './context.js';
-export declare function appendLifecycleNodes(module: ModuleInstance, moduleId: string, nodes: ApplicationModelNode[], edges: ApplicationModelEdge[]): void;
+import { type ModelBuildContext } from './context.js';
+export declare function appendLifecycleNodes(module: ModuleInstance, moduleId: ModuleId, nodes: ApplicationModelNode[], edges: ApplicationModelEdge[]): void;
 export declare function resolveLifecycleDependencies(context: ModelBuildContext): void;

package/dist/core/model/lifecycle.js

@@ -1,6 +1,9 @@
+import { isLoggerToken } from '../logger-internal.js';
+import { lifecycleNodeId } from './identity.js';
 import { diagnostic } from '../diagnostic.js';
 import { isFrameworkProvidedToken } from '../token-internal.js';
 import { tokenName } from '../token.js';
+import { findProviderNode } from './context.js';
 import { snapshotLifecycleHook } from './snapshot.js';
 import { isTokenVisible, moduleDeclaresToken } from './visibility.js';
 export function appendLifecycleNodes(module, moduleId, nodes, edges) {
@@ -8,7 +11,7 @@ export function appendLifecycleNodes(module, moduleId, nodes, edges) {
     if (!lifecycle)
         return;
     for (const [phase, hook] of Object.entries(lifecycle)) {
-        const id = `lifecycle:${moduleId}:${phase}`;
+        const id = lifecycleNodeId(moduleId, phase);
         nodes.push({
             kind: 'lifecycle',
             id,
@@ -20,15 +23,16 @@ export function appendLifecycleNodes(module, moduleId, nodes, edges) {
     }
 }
 export function resolveLifecycleDependencies(context) {
-    const { nodes, providerNodes, modules, moduleIds, edges, diagnostics } = context;
+    const { nodes, modules, moduleIds, edges, diagnostics } = context;
     for (const lifecycle of nodes.filter((node) => node.kind === 'lifecycle')) {
         for (const dependency of lifecycle.hook.inject) {
-            const provider = providerNodes.get(dependency);
+            const provider = findProviderNode(context, dependency);
             if (provider) {
                 edges.push({ from: lifecycle.id, to: provider.id, kind: 'injects' });
                 const sourceModule = modules.find((candidate) => moduleIds.get(candidate) === lifecycle.moduleId);
                 const providerModule = modules.find((candidate) => moduleIds.get(candidate) === provider.moduleId);
                 if (sourceModule &&
+                    !isLoggerToken(dependency) &&
                     providerModule &&
                     provider.moduleId !== lifecycle.moduleId &&
                     !moduleDeclaresToken(sourceModule, dependency) &&

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

@@ -0,0 +1,3 @@
+import { type ModelBuildContext } from './context.js';
+export declare function compileApplicationLogger(context: ModelBuildContext): void;
+export declare function validateApplicationLogger(context: ModelBuildContext): void;

package/dist/core/model/logger.js

@@ -0,0 +1,59 @@
+import { diagnostic } from '../diagnostic.js';
+import { LoggerToken } from '../logger.js';
+import { defaultLoggerProviders, isLoggerToken } from '../logger-internal.js';
+import { tokenName } from '../token.js';
+import { findProviderNode } from './context.js';
+import { collectProviderDependencies } from './modules.js';
+import { snapshotProvider } from './snapshot.js';
+export function compileApplicationLogger(context) {
+    const { providers, providerNodes, nodes, diagnostics } = context;
+    let root = findProviderNode(context, LoggerToken);
+    if (!root) {
+        for (const declaration of defaultLoggerProviders()) {
+            const provider = snapshotProvider(declaration);
+            const node = {
+                kind: 'provider',
+                id: context.nextProviderId(),
+                token: provider.provide,
+                provider,
+                moduleId: 'application',
+                dependencies: collectProviderDependencies(provider),
+            };
+            providers.push(provider);
+            providerNodes.set(node.token, node);
+            nodes.push(node);
+        }
+        root = findProviderNode(context, LoggerToken);
+    }
+    if (!root)
+        return;
+    if (root.provider.scope !== 'application') {
+        diagnostics.push(diagnostic('LUTRE_LOGGER_SCOPE', 'LoggerToken must have application scope.', root.id));
+    }
+    if (root.moduleId !== 'application' &&
+        !context.roots.some((module) => module.definition.exports?.some(isLoggerToken))) {
+        diagnostics.push(diagnostic('LUTRE_LOGGER_VISIBILITY', 'LoggerToken must be exported by a root Module to configure the Application logger.', root.id));
+    }
+}
+export function validateApplicationLogger(context) {
+    const root = findProviderNode(context, LoggerToken);
+    if (!root)
+        return;
+    const visited = new Set();
+    const visit = (token, lineage) => {
+        const canonical = isLoggerToken(token) ? root.token : token;
+        const start = lineage.indexOf(canonical);
+        if (start >= 0) {
+            context.diagnostics.push(diagnostic('LUTRE_LOGGER_CYCLE', `Circular Logger dependency: ${[...lineage.slice(start), canonical].map(tokenName).join(' -> ')}`, root.id));
+            return;
+        }
+        if (visited.has(canonical))
+            return;
+        visited.add(canonical);
+        for (const dependency of findProviderNode(context, canonical)
+            ?.dependencies ?? []) {
+            visit(dependency, [...lineage, canonical]);
+        }
+    };
+    visit(root.token, []);
+}

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

@@ -1,2 +1,5 @@
-import type { ModelBuildContext } from './context.js';
+import { type ProviderDescriptor } from '../provider.js';
+import type { TokenLike } from '../token.js';
+import { type ModelBuildContext } from './context.js';
 export declare function collectModuleDeclarations(context: ModelBuildContext): void;
+export declare function collectProviderDependencies(provider: ProviderDescriptor): readonly TokenLike[];