@stitchem/core 0.0.3

package/dist/injector/injector.js

@@ -0,0 +1,295 @@
+import { Scope } from '../context/scope.js';
+import { hasOnInit } from '../core/core.lifecycle.js';
+import { CoreError } from '../errors/core.error.js';
+import { formatToken } from '../token/token.utils.js';
+import { getConstructorTokens, getInjectTokens, } from '../decorator/inject.decorator.js';
+import { isLazyToken } from '../token/lazy.token.js';
+import { isValueProvider, isFactoryProvider, isExistingProvider, isClassProvider, } from '../provider/provider.guards.js';
+/**
+ * Handles dependency resolution and instance creation.
+ * Supports constructor injection (via `static inject`), accessor injection
+ * (via `@inject()` accessor decorator), and lazy proxies for circular deps.
+ */
+export class Injector {
+    container;
+    /** Tracks tokens currently being resolved (circular dependency detection). */
+    resolutionStack = new Set();
+    constructor(container) {
+        this.container = container;
+    }
+    /**
+     * Resolves an instance from a wrapper (async).
+     * Handles caching, circular dependency detection, and lifecycle hooks.
+     *
+     * @throws CoreError (SCOPED_RESOLUTION) if resolving scoped without a scope
+     * @throws CoreError (CIRCULAR_DEPENDENCY) if a circular dependency is detected
+     */
+    async loadInstance(wrapper, module, scope = Scope.STATIC) {
+        const cached = this.guardResolution(wrapper, scope);
+        if (cached !== null)
+            return cached;
+        this.resolutionStack.add(wrapper.token);
+        try {
+            const resolver = this.moduleResolver(module);
+            const instance = await this.createInstance(wrapper, resolver, scope);
+            if (hasOnInit(instance)) {
+                await instance.onInit();
+            }
+            wrapper.setInstance(instance, scope);
+            return instance;
+        }
+        finally {
+            this.resolutionStack.delete(wrapper.token);
+        }
+    }
+    /**
+     * Resolves an instance from a wrapper (sync).
+     *
+     * @throws CoreError (SCOPED_RESOLUTION) if resolving scoped without a scope
+     * @throws CoreError (CIRCULAR_DEPENDENCY) if a circular dependency is detected
+     * @throws Error if async factory or async onInit is encountered
+     */
+    loadInstanceSync(wrapper, module, scope = Scope.STATIC) {
+        const cached = this.guardResolution(wrapper, scope);
+        if (cached !== null)
+            return cached;
+        this.resolutionStack.add(wrapper.token);
+        try {
+            const resolver = this.moduleResolver(module);
+            const instance = this.createInstanceSync(wrapper, resolver, scope);
+            if (hasOnInit(instance)) {
+                const result = instance.onInit();
+                if (result instanceof Promise) {
+                    throw new Error(`Cannot call async onInit synchronously for ${formatToken(wrapper.token)}`);
+                }
+            }
+            wrapper.setInstance(instance, scope);
+            return instance;
+        }
+        finally {
+            this.resolutionStack.delete(wrapper.token);
+        }
+    }
+    /**
+     * Creates a new instance without caching.
+     * Useful for transient-like creation on demand.
+     *
+     * @throws CoreError (CIRCULAR_DEPENDENCY) if a circular dependency is detected
+     */
+    async createUncached(wrapper, module, scope = Scope.STATIC) {
+        if (this.resolutionStack.has(wrapper.token)) {
+            throw CoreError.circularDependency([
+                ...this.resolutionStack,
+                wrapper.token,
+            ]);
+        }
+        this.resolutionStack.add(wrapper.token);
+        try {
+            const resolver = this.moduleResolver(module);
+            const instance = await this.createInstance(wrapper, resolver, scope);
+            if (hasOnInit(instance)) {
+                await instance.onInit();
+            }
+            return instance;
+        }
+        finally {
+            this.resolutionStack.delete(wrapper.token);
+        }
+    }
+    /**
+     * Instantiates any class by resolving its constructor and accessor dependencies.
+     * The class does not need to be registered as a provider or marked with @injectable().
+     */
+    async instantiateClass(ctor, module, scope = Scope.STATIC) {
+        const resolver = this.moduleResolver(module);
+        const tokens = getConstructorTokens(ctor);
+        const deps = await this.resolveDependencies(tokens, resolver, scope);
+        const instance = new ctor(...deps);
+        await this.injectAccessorProperties(instance, ctor, resolver, scope);
+        if (hasOnInit(instance)) {
+            await instance.onInit();
+        }
+        return instance;
+    }
+    /**
+     * Instantiates any class using global resolution (bypasses module visibility).
+     */
+    async instantiateClassGlobal(ctor, scope = Scope.STATIC) {
+        const resolver = this.globalResolver();
+        const tokens = getConstructorTokens(ctor);
+        const deps = await this.resolveDependencies(tokens, resolver, scope);
+        const instance = new ctor(...deps);
+        await this.injectAccessorProperties(instance, ctor, resolver, scope);
+        if (hasOnInit(instance)) {
+            await instance.onInit();
+        }
+        return instance;
+    }
+    // ---------------------------------------------------------------------------
+    // Private — Resolution guards
+    // ---------------------------------------------------------------------------
+    /**
+     * Validates resolution preconditions and returns the cached instance if available.
+     * Returns null if the instance needs to be created.
+     *
+     * @throws CoreError (SCOPED_RESOLUTION) if resolving scoped without a scope
+     * @throws CoreError (CIRCULAR_DEPENDENCY) if a circular dependency is detected
+     */
+    guardResolution(wrapper, scope) {
+        if (wrapper.isScoped && scope === Scope.STATIC) {
+            throw CoreError.scopedResolution(wrapper.token);
+        }
+        if (wrapper.isResolved(scope)) {
+            return wrapper.getInstance(scope);
+        }
+        if (this.resolutionStack.has(wrapper.token)) {
+            throw CoreError.circularDependency([
+                ...this.resolutionStack,
+                wrapper.token,
+            ]);
+        }
+        return null;
+    }
+    // ---------------------------------------------------------------------------
+    // Private — Token resolvers
+    // ---------------------------------------------------------------------------
+    /** Creates a resolver scoped to a specific module. */
+    moduleResolver(module) {
+        return (token) => this.container.getProviderByToken(token, module);
+    }
+    /** Creates a resolver that searches all modules (bypasses visibility). */
+    globalResolver() {
+        return (token) => this.container.getProviderByTokenGlobal(token);
+    }
+    // ---------------------------------------------------------------------------
+    // Private — Instance creation
+    // ---------------------------------------------------------------------------
+    /** Creates an instance from a wrapper's provider (async). */
+    async createInstance(wrapper, resolver, scope) {
+        const provider = wrapper.provider;
+        if (isValueProvider(provider)) {
+            return provider.useValue;
+        }
+        if (isFactoryProvider(provider)) {
+            const deps = await this.resolveDependencies(provider.inject ?? [], resolver, scope);
+            const result = provider.useFactory(...deps);
+            return result instanceof Promise ? await result : result;
+        }
+        if (isExistingProvider(provider)) {
+            const { wrapper: aliased, module: aliasedModule } = resolver(provider.useExisting);
+            return this.loadInstance(aliased, aliasedModule, scope);
+        }
+        // Class or constructor provider.
+        const ctor = isClassProvider(provider) ? provider.useClass : provider;
+        const tokens = getConstructorTokens(ctor);
+        const deps = await this.resolveDependencies(tokens, resolver, scope);
+        const instance = new ctor(...deps);
+        await this.injectAccessorProperties(instance, ctor, resolver, scope);
+        return instance;
+    }
+    /** Creates an instance from a wrapper's provider (sync). */
+    createInstanceSync(wrapper, resolver, scope) {
+        const provider = wrapper.provider;
+        if (isValueProvider(provider)) {
+            return provider.useValue;
+        }
+        if (isFactoryProvider(provider)) {
+            const deps = this.resolveDependenciesSync(provider.inject ?? [], resolver, scope);
+            const result = provider.useFactory(...deps);
+            if (result instanceof Promise) {
+                throw new Error(`Cannot resolve async factory synchronously for ${formatToken(wrapper.token)}`);
+            }
+            return result;
+        }
+        if (isExistingProvider(provider)) {
+            const { wrapper: aliased, module: aliasedModule } = resolver(provider.useExisting);
+            return this.loadInstanceSync(aliased, aliasedModule, scope);
+        }
+        // Class or constructor provider.
+        const ctor = isClassProvider(provider) ? provider.useClass : provider;
+        const tokens = getConstructorTokens(ctor);
+        const deps = this.resolveDependenciesSync(tokens, resolver, scope);
+        const instance = new ctor(...deps);
+        this.injectAccessorPropertiesSync(instance, ctor, resolver, scope);
+        return instance;
+    }
+    // ---------------------------------------------------------------------------
+    // Private — Dependency resolution
+    // ---------------------------------------------------------------------------
+    /** Resolves an array of dependency tokens (async). */
+    async resolveDependencies(tokens, resolver, scope) {
+        return Promise.all(tokens.map((token) => {
+            if (isLazyToken(token)) {
+                return this.createLazyProxy(token, resolver, scope);
+            }
+            const { wrapper, module } = resolver(token);
+            return this.loadInstance(wrapper, module, scope);
+        }));
+    }
+    /** Resolves an array of dependency tokens (sync). */
+    resolveDependenciesSync(tokens, resolver, scope) {
+        return tokens.map((token) => {
+            if (isLazyToken(token)) {
+                return this.createLazyProxy(token, resolver, scope);
+            }
+            const { wrapper, module } = resolver(token);
+            return this.loadInstanceSync(wrapper, module, scope);
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Private — Accessor injection
+    // ---------------------------------------------------------------------------
+    /** Injects accessor-decorated properties on an instance (async). */
+    async injectAccessorProperties(instance, ctor, resolver, scope) {
+        const injectTokens = getInjectTokens(ctor);
+        if (!injectTokens)
+            return;
+        for (const [propName, token] of injectTokens) {
+            const { wrapper, module } = resolver(token);
+            instance[propName] =
+                await this.loadInstance(wrapper, module, scope);
+        }
+    }
+    /** Injects accessor-decorated properties on an instance (sync). */
+    injectAccessorPropertiesSync(instance, ctor, resolver, scope) {
+        const injectTokens = getInjectTokens(ctor);
+        if (!injectTokens)
+            return;
+        for (const [propName, token] of injectTokens) {
+            const { wrapper, module } = resolver(token);
+            instance[propName] =
+                this.loadInstanceSync(wrapper, module, scope);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private — Lazy proxies
+    // ---------------------------------------------------------------------------
+    /**
+     * Creates a lazy proxy that defers resolution until first property access.
+     * Used to break circular dependencies.
+     */
+    createLazyProxy(lazyToken, resolver, scope) {
+        let instance;
+        const resolve = () => {
+            if (instance === undefined) {
+                const realToken = lazyToken.factory();
+                const { wrapper, module } = resolver(realToken);
+                instance = this.loadInstanceSync(wrapper, module, scope);
+            }
+        };
+        return new Proxy(Object.create(null), {
+            get: (_, prop, receiver) => {
+                // Prevent Promise.all from triggering resolution via thenable check.
+                if (prop === 'then')
+                    return undefined;
+                resolve();
+                return Reflect.get(instance, prop, receiver);
+            },
+            set: (_, prop, value) => {
+                resolve();
+                return Reflect.set(instance, prop, value);
+            },
+        });
+    }
+}
+//# sourceMappingURL=injector.js.map

package/dist/instance-wrapper/instance-wrapper.d.ts

@@ -0,0 +1,61 @@
+import type { Token } from '../token/token.types.js';
+import type { constructor } from '../core/core.types.js';
+import type { Provider } from '../provider/provider.interface.js';
+import { Lifetime } from '../core/core.lifetime.js';
+import { Scope } from '../context/scope.js';
+/**
+ * Wraps a provider with instance caching and metadata.
+ * Handles context-aware instance storage for different lifetimes.
+ *
+ * - SINGLETON: Single instance stored directly
+ * - SCOPED: Instances stored per Scope in WeakMap (allows GC)
+ * - TRANSIENT: Never cached, always creates new instance
+ */
+export declare class InstanceWrapper<T = unknown> {
+    /** The injection token for this provider. */
+    readonly token: Token<T>;
+    /** The class constructor (if class-based provider). */
+    readonly classRef: constructor<T> | undefined;
+    /** The original provider configuration. */
+    readonly provider: Provider<T>;
+    /** The lifetime of this provider. */
+    readonly lifetime: Lifetime;
+    /** Singleton instance storage. */
+    private singletonInstance?;
+    private singletonResolved;
+    /** WeakMap for scoped instances (allows GC when Scope is no longer referenced). */
+    private readonly scopedInstances;
+    private readonly scopedResolved;
+    private constructor();
+    /**
+     * Creates an InstanceWrapper from a Provider.
+     * Extracts token, classRef, and lifetime from the provider configuration.
+     */
+    static fromProvider<T>(provider: Provider<T>): InstanceWrapper<T>;
+    /** Whether this is a singleton provider. */
+    get isSingleton(): boolean;
+    /** Whether this is a transient provider (never cached). */
+    get isTransient(): boolean;
+    /** Whether this is a scoped provider. */
+    get isScoped(): boolean;
+    /**
+     * Gets the cached instance for a scope.
+     * Returns undefined if not yet resolved or if transient.
+     */
+    getInstance(scope?: Scope): T | undefined;
+    /**
+     * Stores an instance for a scope. No-op for transient providers.
+     */
+    setInstance(instance: T, scope?: Scope): void;
+    /**
+     * Checks if an instance is already resolved for a scope.
+     * Unlike getInstance, this correctly handles cases where the resolved value is undefined.
+     */
+    isResolved(scope?: Scope): boolean;
+    /**
+     * Clears the cached instance for a scope.
+     * For singletons, scope is ignored. For transient, this is a no-op.
+     */
+    clear(scope?: Scope): void;
+}
+//# sourceMappingURL=instance-wrapper.d.ts.map

package/dist/instance-wrapper/instance-wrapper.js

@@ -0,0 +1,142 @@
+import { Lifetime } from '../core/core.lifetime.js';
+import { Scope } from '../context/scope.js';
+import { isConstructorProvider, isClassProvider, isValueProvider, isFactoryProvider, getProviderToken, } from '../provider/provider.guards.js';
+import { getInjectableMetadata } from '../decorator/injectable.decorator.js';
+/**
+ * Extracts the class constructor from a provider, if applicable.
+ */
+function extractClassRef(provider) {
+    if (isConstructorProvider(provider))
+        return provider;
+    if (isClassProvider(provider))
+        return provider.useClass;
+    return undefined;
+}
+/**
+ * Extracts the lifetime from a provider configuration.
+ */
+function extractLifetime(provider) {
+    // Value providers are always singletons.
+    if (isValueProvider(provider))
+        return Lifetime.SINGLETON;
+    // Class and factory providers can specify lifetime.
+    if (isClassProvider(provider) || isFactoryProvider(provider)) {
+        return provider.lifetime ?? Lifetime.SINGLETON;
+    }
+    // Constructor providers get lifetime from @injectable() metadata.
+    if (isConstructorProvider(provider)) {
+        return getInjectableMetadata(provider)?.lifetime ?? Lifetime.SINGLETON;
+    }
+    // Existing providers (aliases) are effectively singletons.
+    return Lifetime.SINGLETON;
+}
+/**
+ * Wraps a provider with instance caching and metadata.
+ * Handles context-aware instance storage for different lifetimes.
+ *
+ * - SINGLETON: Single instance stored directly
+ * - SCOPED: Instances stored per Scope in WeakMap (allows GC)
+ * - TRANSIENT: Never cached, always creates new instance
+ */
+export class InstanceWrapper {
+    /** The injection token for this provider. */
+    token;
+    /** The class constructor (if class-based provider). */
+    classRef;
+    /** The original provider configuration. */
+    provider;
+    /** The lifetime of this provider. */
+    lifetime;
+    /** Singleton instance storage. */
+    singletonInstance;
+    singletonResolved = false;
+    /** WeakMap for scoped instances (allows GC when Scope is no longer referenced). */
+    scopedInstances = new WeakMap();
+    scopedResolved = new WeakSet();
+    constructor(options) {
+        this.token = options.token;
+        this.provider = options.provider;
+        this.classRef = options.classRef;
+        this.lifetime = options.lifetime;
+    }
+    /**
+     * Creates an InstanceWrapper from a Provider.
+     * Extracts token, classRef, and lifetime from the provider configuration.
+     */
+    static fromProvider(provider) {
+        return new InstanceWrapper({
+            token: getProviderToken(provider),
+            provider,
+            classRef: extractClassRef(provider),
+            lifetime: extractLifetime(provider),
+        });
+    }
+    /** Whether this is a singleton provider. */
+    get isSingleton() {
+        return this.lifetime === Lifetime.SINGLETON;
+    }
+    /** Whether this is a transient provider (never cached). */
+    get isTransient() {
+        return this.lifetime === Lifetime.TRANSIENT;
+    }
+    /** Whether this is a scoped provider. */
+    get isScoped() {
+        return this.lifetime === Lifetime.SCOPED;
+    }
+    /**
+     * Gets the cached instance for a scope.
+     * Returns undefined if not yet resolved or if transient.
+     */
+    getInstance(scope = Scope.STATIC) {
+        if (this.lifetime === Lifetime.SINGLETON)
+            return this.singletonInstance;
+        if (this.lifetime === Lifetime.TRANSIENT)
+            return undefined;
+        return this.scopedInstances.get(scope);
+    }
+    /**
+     * Stores an instance for a scope. No-op for transient providers.
+     */
+    setInstance(instance, scope = Scope.STATIC) {
+        if (this.lifetime === Lifetime.SINGLETON) {
+            this.singletonInstance = instance;
+            this.singletonResolved = true;
+            return;
+        }
+        if (this.lifetime === Lifetime.SCOPED) {
+            this.scopedInstances.set(scope, instance);
+            this.scopedResolved.add(scope);
+            return;
+        }
+        // TRANSIENT: don't cache.
+    }
+    /**
+     * Checks if an instance is already resolved for a scope.
+     * Unlike getInstance, this correctly handles cases where the resolved value is undefined.
+     */
+    isResolved(scope = Scope.STATIC) {
+        if (this.lifetime === Lifetime.SINGLETON)
+            return this.singletonResolved;
+        if (this.lifetime === Lifetime.TRANSIENT)
+            return false;
+        return this.scopedResolved.has(scope);
+    }
+    /**
+     * Clears the cached instance for a scope.
+     * For singletons, scope is ignored. For transient, this is a no-op.
+     */
+    clear(scope = Scope.STATIC) {
+        if (this.lifetime === Lifetime.SINGLETON) {
+            this.singletonInstance = undefined;
+            this.singletonResolved = false;
+            return;
+        }
+        if (this.lifetime === Lifetime.SCOPED) {
+            this.scopedInstances.delete(scope);
+            this.scopedResolved.delete(scope);
+            return;
+        }
+        // TRANSIENT: nothing to clear.
+    }
+}
+//# sourceMappingURL=instance-wrapper.js.map

package/dist/instance-wrapper/instance-wrapper.types.d.ts

@@ -0,0 +1,18 @@
+import type { Token } from '../token/token.types.js';
+import type { constructor } from '../core/core.types.js';
+import type { Provider } from '../provider/provider.interface.js';
+import type { Lifetime } from '../core/core.lifetime.js';
+/**
+ * Options for creating an InstanceWrapper.
+ */
+export interface InstanceWrapperOptions<T = unknown> {
+    /** The injection token. */
+    token: Token<T>;
+    /** The provider configuration. */
+    provider: Provider<T>;
+    /** The class constructor (if class-based provider). */
+    classRef?: constructor<T>;
+    /** The lifetime of this provider. */
+    lifetime: Lifetime;
+}
+//# sourceMappingURL=instance-wrapper.types.d.ts.map

package/dist/instance-wrapper/instance-wrapper.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=instance-wrapper.types.js.map

package/dist/logger/console.logger.d.ts

@@ -0,0 +1,52 @@
+import { LogLevel } from './logger.types.js';
+import type { Logger } from './logger.types.js';
+/**
+ * Default logger implementation with colored symbols and optional context prefix.
+ *
+ * Output format:
+ * ```
+ * 12:30:15 [http:server] ℹ Starting server...
+ * 12:30:15 [http:server] ⚠ Deprecation warning
+ * 12:30:17 [http:server] ✗ Connection failed
+ * 12:30:18 [http:server] ◆ Query executed
+ * ```
+ *
+ * @example Standalone
+ * ```ts
+ * const logger = new ConsoleLogger('http:server');
+ * logger.info('Starting server...');
+ * ```
+ *
+ * @example Set global level
+ * ```ts
+ * ConsoleLogger.setLevel(LogLevel.WARN);
+ * ```
+ */
+export declare class ConsoleLogger implements Logger {
+    private static level;
+    private readonly context?;
+    constructor(context?: string);
+    /**
+     * Sets the global log level for all ConsoleLogger instances.
+     */
+    static setLevel(level: LogLevel): void;
+    /**
+     * Gets the current global log level.
+     */
+    static getLevel(): LogLevel;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    private prefix;
+}
+/**
+ * Silent logger that discards all messages.
+ */
+export declare class NoopLogger implements Logger {
+    info(_message: string, ..._args: unknown[]): void;
+    warn(_message: string, ..._args: unknown[]): void;
+    error(_message: string, ..._args: unknown[]): void;
+    debug(_message: string, ..._args: unknown[]): void;
+}
+//# sourceMappingURL=console.logger.d.ts.map

package/dist/logger/console.logger.js

@@ -0,0 +1,90 @@
+import pc from 'picocolors';
+import logSymbols from 'log-symbols';
+import { LogLevel } from './logger.types.js';
+/**
+ * Default logger implementation with colored symbols and optional context prefix.
+ *
+ * Output format:
+ * ```
+ * 12:30:15 [http:server] ℹ Starting server...
+ * 12:30:15 [http:server] ⚠ Deprecation warning
+ * 12:30:17 [http:server] ✗ Connection failed
+ * 12:30:18 [http:server] ◆ Query executed
+ * ```
+ *
+ * @example Standalone
+ * ```ts
+ * const logger = new ConsoleLogger('http:server');
+ * logger.info('Starting server...');
+ * ```
+ *
+ * @example Set global level
+ * ```ts
+ * ConsoleLogger.setLevel(LogLevel.WARN);
+ * ```
+ */
+export class ConsoleLogger {
+    static level = LogLevel.DEBUG;
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Sets the global log level for all ConsoleLogger instances.
+     */
+    static setLevel(level) {
+        ConsoleLogger.level = level;
+    }
+    /**
+     * Gets the current global log level.
+     */
+    static getLevel() {
+        return ConsoleLogger.level;
+    }
+    info(message, ...args) {
+        if (ConsoleLogger.level > LogLevel.INFO)
+            return;
+        const prefix = this.prefix(logSymbols.info, pc.blue);
+        console.log(prefix, message, ...args);
+    }
+    warn(message, ...args) {
+        if (ConsoleLogger.level > LogLevel.WARN)
+            return;
+        const prefix = this.prefix(logSymbols.warning, pc.yellow);
+        console.warn(prefix, message, ...args);
+    }
+    error(message, ...args) {
+        if (ConsoleLogger.level > LogLevel.ERROR)
+            return;
+        const prefix = this.prefix(logSymbols.error, pc.red);
+        console.error(prefix, message, ...args);
+    }
+    debug(message, ...args) {
+        if (ConsoleLogger.level > LogLevel.DEBUG)
+            return;
+        const prefix = this.prefix('\u25c6', pc.magenta);
+        console.debug(prefix, message, ...args);
+    }
+    prefix(symbol, colorFn) {
+        const timestamp = pc.dim(compactTimestamp());
+        const ctx = this.context ? ` ${pc.dim(`[${this.context}]`)}` : '';
+        return `${timestamp}${ctx} ${colorFn(symbol)}`;
+    }
+}
+/**
+ * Silent logger that discards all messages.
+ */
+export class NoopLogger {
+    info(_message, ..._args) { }
+    warn(_message, ..._args) { }
+    error(_message, ..._args) { }
+    debug(_message, ..._args) { }
+}
+function compactTimestamp() {
+    const now = new Date();
+    const h = now.getHours().toString().padStart(2, '0');
+    const m = now.getMinutes().toString().padStart(2, '0');
+    const s = now.getSeconds().toString().padStart(2, '0');
+    return `${h}:${m}:${s}`;
+}
+//# sourceMappingURL=console.logger.js.map

package/dist/logger/logger.token.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Injection token for the logger.
+ *
+ * Use this token to inject or replace the logger via DI.
+ *
+ * @example Inject
+ * ```ts
+ * @injectable()
+ * class UserService {
+ *   static inject = [LOGGER] as const;
+ *   constructor(readonly logger: Logger) {}
+ * }
+ * ```
+ *
+ * @example Replace globally
+ * ```ts
+ * await using ctx = await Context.create(AppModule, {
+ *   logging: { logger: pino() },
+ * });
+ * ```
+ */
+export declare const LOGGER: unique symbol;
+//# sourceMappingURL=logger.token.d.ts.map