stratal 0.0.20 → 0.0.22

package/dist/index-DBd_2wv8.d.mts

@@ -1,263 +0,0 @@
-//#region src/logger/logger.tokens.d.ts
-/**
- * Dependency Injection Tokens for Logger Module
- *
- * Symbol-based tokens ensure type-safe dependency injection
- * and prevent naming collisions.
- */
-declare const LOGGER_TOKENS: {
-  /**
-   * Main logger service facade
-   */
-  readonly LoggerService: symbol;
-  /**
-   * Log formatter (JSON or Pretty)
-   */
-  readonly Formatter: symbol;
-  /**
-   * Array of active transports
-   */
-  readonly Transports: symbol;
-  /**
-   * Individual transport tokens (for factory registration)
-   */
-  readonly ConsoleTransport: symbol;
-  /**
-   * Configured log level for filtering
-   */
-  readonly LogLevelOptions: symbol;
-};
-//#endregion
-//#region src/logger/contracts/log-level.d.ts
-/**
- * Log severity levels
- * Ordered from least to most severe
- */
-declare enum LogLevel {
-  DEBUG = "debug",
-  INFO = "info",
-  WARN = "warn",
-  ERROR = "error"
-}
-/**
- * Map log levels to numeric priorities (for filtering)
- * Higher numbers = more severe = higher priority
- */
-declare const LOG_LEVEL_PRIORITY: Record<LogLevel, number>;
-//#endregion
-//#region src/logger/contracts/log-context.d.ts
-/**
- * Structured metadata attached to log entries
- * Supports arbitrary key-value pairs for context enrichment
- */
-type LogContext = Record<string, unknown>;
-/**
- * Internal context automatically added by LoggerService
- * Contains request metadata, etc.
- */
-interface InternalLogContext extends LogContext {
-  userId?: string;
-  timestamp: number;
-}
-//#endregion
-//#region src/logger/contracts/log-entry.d.ts
-/**
- * Complete log entry structure passed to transports
- * Combines message, level, and enriched context
- */
-interface LogEntry {
-  level: LogLevel;
-  message: string;
-  context: InternalLogContext;
-  error?: {
-    message: string;
-    stack?: string;
-    name?: string;
-  };
-}
-//#endregion
-//#region src/logger/formatters/formatter.interface.d.ts
-/**
- * Formatter contract
- * Transforms LogEntry into string representation for transport output
- */
-interface ILogFormatter {
-  /**
-   * Format log entry into string
-   * @param entry - Complete log entry with context
-   * @returns Formatted string ready for transport
-   */
-  format(entry: LogEntry): string;
-}
-//#endregion
-//#region src/logger/transports/transport.interface.d.ts
-/**
- * Transport contract
- * Handles delivery of formatted log entries to destinations
- */
-interface ILogTransport {
-  /**
-   * Transport name for identification
-   */
-  readonly name: string;
-  /**
-   * Write log entry to destination
-   * Must be async to support waitUntil pattern
-   *
-   * @param entry - Complete log entry
-   * @param formatted - Pre-formatted string from formatter
-   * @returns Promise that resolves when log is written
-   */
-  write(entry: LogEntry, formatted: string): Promise<void>;
-}
-//#endregion
-//#region src/logger/services/logger.service.d.ts
-/**
- * Logger Service
- *
- * Main logging facade.
- *
- * **Features:**
- * - Async logging via ctx.waitUntil() for non-blocking performance
- * - Multi-transport support (console, future Sentry/Cloudflare Analytics)
- * - Configurable formatters (JSON production, Pretty development)
- * - Log level filtering based on environment
- *
- * **Architecture:**
- * - Transports and formatters injected via DI
- *
- * @example Basic usage
- * ```typescript
- * @Transient()
- * export class UserService {
- *   constructor(
- *     @inject(LOGGER_TOKENS.LoggerService)
- *     private readonly logger: LoggerService
- *   ) {}
- *
- *   async createUser(input: CreateUserInput) {
- *     this.logger.info('Creating user', { email: input.email })
- *   }
- * }
- * ```
- */
-declare class LoggerService {
-  private readonly logLevel;
-  private readonly executionContext;
-  private readonly formatter;
-  private readonly transports;
-  constructor(logLevel: LogLevel, executionContext: globalThis.ExecutionContext, formatter: ILogFormatter, transports: ILogTransport[]);
-  /**
-   * Log debug message (development only)
-   */
-  debug(message: string, context?: LogContext): void;
-  /**
-   * Log info message
-   */
-  info(message: string, context?: LogContext): void;
-  /**
-   * Log warning message
-   */
-  warn(message: string, context?: LogContext): void;
-  /**
-   * Log error message
-   * Accepts Error object or custom context
-   */
-  error(message: string, contextOrError?: LogContext | Error): void;
-  /**
-   * Core logging implementation
-   * Enriches context, formats message, dispatches to transports
-   * Uses ctx.waitUntil() for async non-blocking processing
-   */
-  private log;
-  /**
-   * Enrich log context with request info and timestamp
-   * Context enrichment can be extended by application modules
-   */
-  private enrichContext;
-  /**
-   * Serialize Error object for transport
-   */
-  private serializeError;
-}
-//#endregion
-//#region src/logger/formatters/json-formatter.d.ts
-/**
- * JSON Formatter
- *
- * Produces structured JSON logs for production environments.
- * Optimized for log aggregation systems (Cloudflare Analytics, Datadog, etc.)
- *
- * Output format:
- * {
- *   "level": "info",
- *   "message": "User logged in",
- *   "timestamp": 1234567890,
- *   "userId": "user_456",
- *   "error": { "message": "...", "stack": "..." }
- * }
- */
-declare class JsonFormatter implements ILogFormatter {
-  format(entry: LogEntry): string;
-}
-//#endregion
-//#region src/logger/formatters/pretty-formatter.d.ts
-/**
- * Pretty Formatter
- *
- * Human-readable colored output for development environments.
- * Uses ANSI color codes for terminal output.
- *
- * Output format:
- * [2024-01-15 10:30:45] INFO: User logged in
- *   userId: user_456
- */
-declare class PrettyFormatter implements ILogFormatter {
-  private readonly colors;
-  private readonly reset;
-  format(entry: LogEntry): string;
-}
-//#endregion
-//#region src/logger/transports/base-transport.d.ts
-/**
- * Base Transport
- *
- * Abstract base class providing shared transport logic.
- * Reduces code duplication across transport implementations.
- */
-declare abstract class BaseTransport implements ILogTransport {
-  abstract readonly name: string;
-  /**
-   * Write log entry - must be implemented by concrete transports
-   */
-  abstract write(entry: LogEntry, formatted: string): Promise<void>;
-  /**
-   * Handle transport errors gracefully
-   * Logs to console.error as fallback to prevent log loss
-   *
-   * @param error - Error that occurred during write
-   * @param entry - Log entry that failed
-   */
-  protected handleError(error: unknown, entry: LogEntry): void;
-}
-//#endregion
-//#region src/logger/transports/console-transport.d.ts
-/**
- * Console Transport
- *
- * Writes logs to console using appropriate console methods.
- * Maps log levels to console.debug, console.info, console.warn, console.error.
- *
- * Thread-safe for Cloudflare Workers environment.
- */
-declare class ConsoleTransport extends BaseTransport {
-  readonly name = "console";
-  write(entry: LogEntry, formatted: string): Promise<void>;
-  /**
-   * Map log level to console method
-   */
-  private getConsoleMethod;
-}
-//#endregion
-export { LogEntry as a, LOG_LEVEL_PRIORITY as c, LoggerService as i, LogLevel as l, PrettyFormatter as n, InternalLogContext as o, JsonFormatter as r, LogContext as s, ConsoleTransport as t, LOGGER_TOKENS as u };
-//# sourceMappingURL=index-DBd_2wv8.d.mts.map

package/dist/index-DBd_2wv8.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DBd_2wv8.d.mts","names":[],"sources":["../src/logger/logger.tokens.ts","../src/logger/contracts/log-level.ts","../src/logger/contracts/log-context.ts","../src/logger/contracts/log-entry.ts","../src/logger/formatters/formatter.interface.ts","../src/logger/transports/transport.interface.ts","../src/logger/services/logger.service.ts","../src/logger/formatters/json-formatter.ts","../src/logger/formatters/pretty-formatter.ts","../src/logger/transports/base-transport.ts","../src/logger/transports/console-transport.ts"],"mappings":";;AAMA;;;;;cAAa,aAAA;;;;;;;;;ECFD;;;EAAA;EACV;;;EAAA;EAGK;;AAOP;EAPO;;;;;ADFP;;;aCFY,QAAA;EACV,KAAA;EACA,IAAA;EACA,IAAA;EACA,KAAA;AAAA;;;;;cAOW,kBAAA,EAAoB,MAAA,CAAO,QAAA;;;;ADTxC;;;KEFY,UAAA,GAAa,MAAA;;;;;UAMR,kBAAA,SAA2B,UAAA;EAC1C,MAAA;EACA,SAAA;AAAA;;;;;;;UCLe,QAAA;EACf,KAAA,EAAO,QAAA;EACP,OAAA;EACA,OAAA,EAAS,kBAAA;EACT,KAAA;IACE,OAAA;IACA,KAAA;IACA,IAAA;EAAA;AAAA;;;AHRJ;;;;AAAA,UIAiB,aAAA;;;;;;EAMf,MAAA,CAAO,KAAA,EAAO,QAAA;AAAA;;;AJNhB;;;;AAAA,UKAiB,aAAA;;;;WAIN,IAAA;;;;;;AJNX;;;EIgBE,KAAA,CAAM,KAAA,EAAO,QAAA,EAAU,SAAA,WAAoB,OAAA;AAAA;;;;;;;;;;;;;;AJhB7C;;;;;;;;;;AAWA;;;;;;;;cKwBa,aAAA;EAAA,iBAGQ,QAAA;EAAA,iBAGA,gBAAA;EAAA,iBAGA,SAAA;EAAA,iBAGA,UAAA;cATA,QAAA,EAAU,QAAA,EAGV,gBAAA,EAAkB,UAAA,CAAW,gBAAA,EAG7B,SAAA,EAAW,aAAA,EAGX,UAAA,EAAY,aAAA;EJzCG;;;EI+ClC,KAAA,CAAM,OAAA,UAAiB,OAAA,GAAU,UAAA;EJ9CjC;;;EIqDA,IAAA,CAAK,OAAA,UAAiB,OAAA,GAAU,UAAA;;;;EAOhC,IAAA,CAAK,OAAA,UAAiB,OAAA,GAAU,UAAA;EHhET;;;;EGwEvB,KAAA,CAAM,OAAA,UAAiB,cAAA,GAAiB,UAAA,GAAa,KAAA;EHtErD;;;;;EAAA,QGwFQ,GAAA;EHnFN;;;;EAAA,QGgIM,aAAA;;AFxIV;;UEkJU,cAAA;AAAA;;;;;;;;;;;;;;;;ALpJV;;cMca,aAAA,YAAyB,aAAA;EACpC,MAAA,CAAO,KAAA,EAAO,QAAA;AAAA;;;;;;;;;;;;;cCLH,eAAA,YAA2B,aAAA;EAAA,iBACrB,MAAA;EAAA,iBAOA,KAAA;EAEjB,MAAA,CAAO,KAAA,EAAO,QAAA;AAAA;;;;;;;;;uBCfM,aAAA,YAAyB,aAAA;EAAA,kBAC3B,IAAA;;;;WAKT,KAAA,CAAM,KAAA,EAAO,QAAA,EAAU,SAAA,WAAoB,OAAA;;ARXtD;;;;;;YQoBY,WAAA,CAAY,KAAA,WAAgB,KAAA,EAAO,QAAA;AAAA;;;;;;;;;;;cCTlC,gBAAA,SAAyB,aAAA;EAAA,SAC3B,IAAA;EAET,KAAA,CAAM,KAAA,EAAO,QAAA,EAAU,SAAA,WAAoB,OAAA;;;ATd7C;US4BU,gBAAA;AAAA"}

package/dist/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/stratal.ts"],"mappings":";;;;;;AAqBA;;;;;;;;;;;;cAAa,OAAA,aAAoB,UAAA,GAAa,UAAA;EAAA,QACpC,GAAA;EAAA,QACA,WAAA;EAAA,eAEO,YAAA;EAAA,eACA,WAAA;EAAA,eACA,iBAAA;cAEH,MAAA,EAAQ,iBAAA;EAiBd,KAAA,CAAM,OAAA,EAAS,OAAA,EAAS,GAAA,EAAK,GAAA,EAAK,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAMlE,KAAA,CAAM,KAAA,EAAO,YAAA,GAAe,OAAA;EAK5B,SAAA,CAAU,UAAA,EAAY,mBAAA,GAAsB,OAAA;EAAA,IAK9C,IAAA,CAAA,GAAQ,OAAA,CAAQ,OAAA;EAId,QAAA,CAAA,GAAY,OAAA;EA7C0B;;;;;;EAAA,OA2DrC,kBAAA,CAAA,GAAsB,OAAA,CAAQ,WAAA;EAAA,QAOvB,WAAA;EAAA,QAKA,UAAA;AAAA"}

package/dist/logger-V6Ms3QnQ.mjs

@@ -1,436 +0,0 @@
-import { inject, injectable } from "tsyringe";
-//#region src/di/decorators/inject-param.decorator.ts
-/**
-* Metadata key for storing parameter injection information
-*/
-const INJECT_PARAM_METADATA_KEY = Symbol.for("stratal:inject:param");
-/**
-* Mark a method parameter for DI injection
-*
-* The parameter will be resolved from the request-scoped container
-* when the controller method is invoked.
-*
-* @param token - DI token to resolve (class or symbol)
-*
-* @example With class token
-* ```typescript
-* async show(
-*   ctx: RouterContext,
-*   @InjectParam(UserService) userService: UserService
-* ) { }
-* ```
-*
-* @example With symbol token
-* ```typescript
-* async show(
-*   ctx: RouterContext,
-*   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
-* ) { }
-* ```
-*/
-function InjectParam(token) {
-	return (target, propertyKey, parameterIndex) => {
-		if (propertyKey === void 0) throw new Error("@InjectParam can only be used on method parameters, not constructor parameters");
-		const existingInjections = Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? [];
-		existingInjections.push({
-			index: parameterIndex,
-			token
-		});
-		Reflect.defineMetadata(INJECT_PARAM_METADATA_KEY, existingInjections, target, propertyKey);
-	};
-}
-/**
-* Get method parameter injections
-*
-* @param target - Controller prototype
-* @param propertyKey - Method name
-* @returns Array of parameter injections sorted by index
-*/
-function getMethodInjections(target, propertyKey) {
-	return (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? []).sort((a, b) => a.index - b.index);
-}
-//#endregion
-//#region src/di/decorators.ts
-/**
-* DI Decorators
-*
-* Provides decorators for dependency injection:
-* - @Transient: Mark classes as injectable (lifecycle controlled at registration)
-* - @InjectParam: Inject dependencies into method parameters
-*
-* Lifecycle (Singleton, Request, Transient) is controlled at registration time
-* via the `scope` property in module providers or Container.register().
-*/
-/**
-* Mark a class as injectable
-*
-* This decorator wraps tsyringe's `@injectable` decorator and optionally
-* associates a token with the class. The actual lifecycle (Singleton, Request,
-* Transient) is determined at registration time, not decoration time.
-*
-* **Lifecycle Control:**
-* - Use `scope: Scope.Singleton` in module providers for singleton
-* - Use `scope: Scope.Request` in module providers for request-scoped
-* - Default is Transient (new instance per resolution)
-*
-* @param token - Optional DI token for service resolution
-*
-* @example Basic usage (no token)
-* ```typescript
-* @Transient()
-* export class UserService {
-*   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}
-* }
-*
-* // In module:
-* @Module({
-*   providers: [UserService]  // Transient by default
-* })
-* ```
-*
-* @example With token
-* ```typescript
-* @Transient(DI_TOKENS.ConnectionManager)
-* export class ConnectionManager implements Disposable {
-*   // ...
-* }
-*
-* // In Application.ts:
-* container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)
-* ```
-*
-* @example Singleton via provider scope
-* ```typescript
-* @Transient()
-* export class ConsumerRegistry {
-*   // ...
-* }
-*
-* // In module:
-* @Module({
-*   providers: [
-*     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
-*   ]
-* })
-* ```
-*/
-function Transient(token) {
-	return function(target) {
-		const targetConstructor = target;
-		injectable({ token })(targetConstructor);
-		return target;
-	};
-}
-//#endregion
-//#region src/di/tokens.ts
-/**
-* Token for the Container instance
-* Used for injecting the Container into services that need dynamic resolution
-*/
-const CONTAINER_TOKEN = Symbol.for("stratal:di:container");
-const DI_TOKENS = {
-	CloudflareEnv: Symbol.for("stratal:cloudflare:env"),
-	ExecutionContext: Symbol.for("stratal:execution:context"),
-	Container: CONTAINER_TOKEN,
-	Application: Symbol.for("stratal:application"),
-	ModuleRegistry: Symbol.for("stratal:module:registry"),
-	ExceptionHandler: Symbol.for("stratal:exception:handler"),
-	Database: Symbol.for("stratal:database:service"),
-	Queue: Symbol.for("stratal:queue:manager"),
-	ConsumerRegistry: Symbol.for("stratal:consumer:registry"),
-	Cron: Symbol.for("stratal:cron:manager"),
-	EventRegistry: Symbol.for("stratal:event:registry"),
-	Quarry: Symbol.for("stratal:quarry"),
-	/**
-	* AuthContext: Use for services that need user authentication (userId).
-	*/
-	AuthContext: Symbol.for("stratal:auth:context"),
-	DurableObjectState: Symbol.for("stratal:durable:object:state"),
-	DurableObjectId: Symbol.for("stratal:durable:object:id")
-};
-//#endregion
-//#region src/logger/logger.tokens.ts
-/**
-* Dependency Injection Tokens for Logger Module
-*
-* Symbol-based tokens ensure type-safe dependency injection
-* and prevent naming collisions.
-*/
-const LOGGER_TOKENS = {
-	/**
-	* Main logger service facade
-	*/
-	LoggerService: Symbol.for("stratal:logger:service"),
-	/**
-	* Log formatter (JSON or Pretty)
-	*/
-	Formatter: Symbol.for("stratal:logger:formatter"),
-	/**
-	* Array of active transports
-	*/
-	Transports: Symbol.for("stratal:logger:transports"),
-	/**
-	* Individual transport tokens (for factory registration)
-	*/
-	ConsoleTransport: Symbol.for("stratal:logger:console:transport"),
-	/**
-	* Configured log level for filtering
-	*/
-	LogLevelOptions: Symbol.for("stratal:logger:log:level:options")
-};
-//#endregion
-//#region src/logger/contracts/log-level.ts
-/**
-* Log severity levels
-* Ordered from least to most severe
-*/
-let LogLevel = /* @__PURE__ */ function(LogLevel) {
-	LogLevel["DEBUG"] = "debug";
-	LogLevel["INFO"] = "info";
-	LogLevel["WARN"] = "warn";
-	LogLevel["ERROR"] = "error";
-	return LogLevel;
-}({});
-/**
-* Map log levels to numeric priorities (for filtering)
-* Higher numbers = more severe = higher priority
-*/
-const LOG_LEVEL_PRIORITY = {
-	["debug"]: 0,
-	["info"]: 1,
-	["warn"]: 2,
-	["error"]: 3
-};
-//#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorateParam.js
-function __decorateParam(paramIndex, decorator) {
-	return function(target, key) {
-		decorator(target, key, paramIndex);
-	};
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-//#endregion
-//#region src/logger/services/logger.service.ts
-var _ref, _ref2;
-let LoggerService = class LoggerService {
-	constructor(logLevel, executionContext, formatter, transports) {
-		this.logLevel = logLevel;
-		this.executionContext = executionContext;
-		this.formatter = formatter;
-		this.transports = transports;
-	}
-	/**
-	* Log debug message (development only)
-	*/
-	debug(message, context) {
-		this.log("debug", message, context);
-	}
-	/**
-	* Log info message
-	*/
-	info(message, context) {
-		this.log("info", message, context);
-	}
-	/**
-	* Log warning message
-	*/
-	warn(message, context) {
-		this.log("warn", message, context);
-	}
-	/**
-	* Log error message
-	* Accepts Error object or custom context
-	*/
-	error(message, contextOrError) {
-		let context;
-		let error;
-		if (contextOrError instanceof Error) error = contextOrError;
-		else context = contextOrError;
-		this.log("error", message, context, error);
-	}
-	/**
-	* Core logging implementation
-	* Enriches context, formats message, dispatches to transports
-	* Uses ctx.waitUntil() for async non-blocking processing
-	*/
-	log(level, message, userContext, error) {
-		if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.logLevel]) return;
-		const entry = {
-			level,
-			message,
-			context: this.enrichContext(userContext ?? {}),
-			error: error ? this.serializeError(error) : void 0
-		};
-		const formatted = this.formatter.format(entry);
-		const writePromises = this.transports.map((transport) => transport.write(entry, formatted).catch((err) => {
-			console.error(`Transport ${transport.name} failed:`, err);
-		}));
-		const allWrites = Promise.all(writePromises);
-		try {
-			this.executionContext.waitUntil(allWrites);
-		} catch (error) {
-			if (!(error instanceof Error) || !error.message.includes("global scope")) throw error;
-		}
-	}
-	/**
-	* Enrich log context with request info and timestamp
-	* Context enrichment can be extended by application modules
-	*/
-	enrichContext(userContext) {
-		return {
-			...userContext,
-			timestamp: Date.now()
-		};
-	}
-	/**
-	* Serialize Error object for transport
-	*/
-	serializeError(error) {
-		return {
-			message: error.message,
-			stack: error.stack,
-			name: error.name
-		};
-	}
-};
-LoggerService = __decorate([
-	Transient(),
-	__decorateParam(0, inject(LOGGER_TOKENS.LogLevelOptions)),
-	__decorateParam(1, inject(DI_TOKENS.ExecutionContext)),
-	__decorateParam(2, inject(LOGGER_TOKENS.Formatter)),
-	__decorateParam(3, inject(LOGGER_TOKENS.Transports)),
-	__decorateMetadata("design:paramtypes", [
-		typeof (_ref = typeof LogLevel !== "undefined" && LogLevel) === "function" ? _ref : Object,
-		typeof (_ref2 = typeof globalThis !== "undefined" && globalThis.ExecutionContext) === "function" ? _ref2 : Object,
-		Object,
-		Array
-	])
-], LoggerService);
-//#endregion
-//#region src/logger/formatters/json-formatter.ts
-/**
-* JSON Formatter
-*
-* Produces structured JSON logs for production environments.
-* Optimized for log aggregation systems (Cloudflare Analytics, Datadog, etc.)
-*
-* Output format:
-* {
-*   "level": "info",
-*   "message": "User logged in",
-*   "timestamp": 1234567890,
-*   "userId": "user_456",
-*   "error": { "message": "...", "stack": "..." }
-* }
-*/
-var JsonFormatter = class {
-	format(entry) {
-		const output = {
-			level: entry.level,
-			message: entry.message,
-			...entry.context,
-			...entry.error && { error: entry.error }
-		};
-		return JSON.stringify(output);
-	}
-};
-//#endregion
-//#region src/logger/formatters/pretty-formatter.ts
-/**
-* Pretty Formatter
-*
-* Human-readable colored output for development environments.
-* Uses ANSI color codes for terminal output.
-*
-* Output format:
-* [2024-01-15 10:30:45] INFO: User logged in
-*   userId: user_456
-*/
-var PrettyFormatter = class {
-	colors = {
-		["debug"]: "\x1B[36m",
-		["info"]: "\x1B[32m",
-		["warn"]: "\x1B[33m",
-		["error"]: "\x1B[31m"
-	};
-	reset = "\x1B[0m";
-	format(entry) {
-		let output = `${this.colors[entry.level]}[${new Date(entry.context.timestamp).toISOString()}] ${entry.level.toUpperCase().padEnd(5)}${this.reset}: ${entry.message}`;
-		const { timestamp: _, ...contextWithoutTimestamp } = entry.context;
-		const contextEntries = Object.entries(contextWithoutTimestamp);
-		if (contextEntries.length > 0) {
-			output += "\n";
-			contextEntries.forEach(([key, value]) => {
-				output += `  ${key}: ${JSON.stringify(value)}\n`;
-			});
-		}
-		if (entry.error?.stack) output += `\n${entry.error.stack}\n`;
-		return output.trimEnd();
-	}
-};
-//#endregion
-//#region src/logger/transports/base-transport.ts
-/**
-* Base Transport
-*
-* Abstract base class providing shared transport logic.
-* Reduces code duplication across transport implementations.
-*/
-var BaseTransport = class {
-	/**
-	* Handle transport errors gracefully
-	* Logs to console.error as fallback to prevent log loss
-	*
-	* @param error - Error that occurred during write
-	* @param entry - Log entry that failed
-	*/
-	handleError(error, entry) {
-		console.error(`[${this.name}] Failed to write log:`, {
-			error: error instanceof Error ? error.message : String(error),
-			logMessage: entry.message,
-			level: entry.level
-		});
-	}
-};
-//#endregion
-//#region src/logger/transports/console-transport.ts
-let ConsoleTransport = class ConsoleTransport extends BaseTransport {
-	name = "console";
-	write(entry, formatted) {
-		try {
-			this.getConsoleMethod(entry.level)(formatted);
-		} catch (error) {
-			this.handleError(error, entry);
-		}
-		return Promise.resolve();
-	}
-	/**
-	* Map log level to console method
-	*/
-	getConsoleMethod(level) {
-		switch (level) {
-			case "debug": return console.debug;
-			case "info": return console.info;
-			case "warn": return console.warn;
-			case "error": return console.error;
-			default: return console.log;
-		}
-	}
-};
-ConsoleTransport = __decorate([Transient(LOGGER_TOKENS.ConsoleTransport)], ConsoleTransport);
-//#endregion
-export { __decorate as a, LOG_LEVEL_PRIORITY as c, CONTAINER_TOKEN as d, DI_TOKENS as f, getMethodInjections as g, InjectParam as h, LoggerService as i, LogLevel as l, INJECT_PARAM_METADATA_KEY as m, PrettyFormatter as n, __decorateParam as o, Transient as p, JsonFormatter as r, __decorateMetadata as s, ConsoleTransport as t, LOGGER_TOKENS as u };
-
-//# sourceMappingURL=logger-V6Ms3QnQ.mjs.map