logixia 1.13.3 → 2.0.0

package/dist/{nestjs-extras-ImbuDhs1.mjs → builder-0gEzRopq.mjs}

@@ -1,15 +1,86 @@
 import { t as __require } from "./chunk-DLSkYcPk.mjs";
 import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
 import { i as stringifyForLog } from "./safe-stringify-DJ66tW5I.mjs";
-import { d as sanitizeIncomingId, i as TraceContext, l as getTraceContextKey, s as extractTraceId, t as DEFAULT_TRACE_HEADERS } from "./trace.utils-CvXgaiQT.mjs";
+import { i as TraceContext } from "./trace.utils-CvXgaiQT.mjs";
 import { t as LogixiaContext } from "./async-context-BzJrbfQs.mjs";
 import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
-import { t as TransportManager, u as stripControlChars } from "./transport.manager-CpdVHEGP.mjs";
+import { d as stripControlChars, t as TransportManager } from "./transport.manager-BiuCAJd2.mjs";
 import { constants } from "node:os";
 import buildFastStringify from "fast-json-stringify";
-import { Catch, Inject, Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
-import { EMPTY, Observable } from "rxjs";
 
+//#region src/types/index.ts
+const LogLevel = {
+	ERROR: "error",
+	WARN: "warn",
+	INFO: "info",
+	DEBUG: "debug",
+	TRACE: "trace",
+	VERBOSE: "verbose"
+};
+const DEFAULT_LOG_LEVELS = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4,
+	verbose: 5
+};
+const DEFAULT_LOG_COLORS = {
+	error: "red",
+	warn: "yellow",
+	info: "green",
+	debug: "blue",
+	trace: "magenta",
+	verbose: "cyan"
+};
+
+//#endregion
+//#region src/core/default-config.ts
+/**
+* Default configuration for Logixia logger
+*/
+const DEFAULT_CONFIG = {
+	appName: "App",
+	environment: "development",
+	traceId: true,
+	format: {
+		timestamp: true,
+		colorize: true,
+		json: false
+	},
+	silent: false,
+	levelOptions: {
+		level: LogLevel.INFO,
+		levels: {
+			[LogLevel.ERROR]: 0,
+			[LogLevel.WARN]: 1,
+			[LogLevel.INFO]: 2,
+			[LogLevel.DEBUG]: 3,
+			[LogLevel.TRACE]: 4,
+			[LogLevel.VERBOSE]: 5
+		},
+		colors: {
+			[LogLevel.ERROR]: "red",
+			[LogLevel.WARN]: "yellow",
+			[LogLevel.INFO]: "blue",
+			[LogLevel.DEBUG]: "green",
+			[LogLevel.TRACE]: "gray",
+			[LogLevel.VERBOSE]: "cyan"
+		}
+	},
+	fields: {
+		timestamp: true,
+		level: true,
+		appName: true,
+		traceId: true,
+		message: true,
+		payload: true,
+		timeTaken: true
+	},
+	outputs: ["console"]
+};
+
+//#endregion
 //#region src/plugin.ts
 /**
 * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
@@ -116,33 +187,6 @@ function usePlugin(plugin) {
 	globalPluginRegistry.register(plugin);
 }
 
-//#endregion
-//#region src/types/index.ts
-const LogLevel = {
-	ERROR: "error",
-	WARN: "warn",
-	INFO: "info",
-	DEBUG: "debug",
-	TRACE: "trace",
-	VERBOSE: "verbose"
-};
-const DEFAULT_LOG_LEVELS = {
-	error: 0,
-	warn: 1,
-	info: 2,
-	debug: 3,
-	trace: 4,
-	verbose: 5
-};
-const DEFAULT_LOG_COLORS = {
-	error: "red",
-	warn: "yellow",
-	info: "green",
-	debug: "blue",
-	trace: "magenta",
-	verbose: "cyan"
-};
-
 //#endregion
 //#region src/utils/error.utils.ts
 const EXTRA_FIELDS = [
@@ -1722,683 +1766,6 @@ function createLogger(config, context) {
 	return logger;
 }
 
-//#endregion
-//#region \0@oxc-project+runtime@0.95.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.95.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/core/logitron-nestjs.service.ts
-var _LogixiaLoggerService;
-let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1 {
-	constructor(config) {
-		this._mergedConfig = {
-			appName: "NestJS-App",
-			environment: "development",
-			traceId: true,
-			format: {
-				timestamp: true,
-				colorize: true,
-				json: false
-			},
-			silent: false,
-			levelOptions: {
-				level: LogLevel.INFO,
-				levels: {
-					error: 0,
-					warn: 1,
-					log: 2,
-					debug: 3,
-					verbose: 4
-				},
-				colors: {
-					error: "red",
-					warn: "yellow",
-					log: "green",
-					debug: "blue",
-					verbose: "cyan"
-				}
-			},
-			fields: {
-				timestamp: "[yyyy-mm-dd HH:MM:ss.MS]",
-				level: "[log_level]",
-				appName: "[app_name]",
-				traceId: "[trace_id]",
-				message: "[message]",
-				payload: "[payload]",
-				timeTaken: "[time_taken_MS]"
-			},
-			...config
-		};
-		this.logger = new LogixiaLogger(this._mergedConfig);
-		this._createCustomLevelMethods();
-	}
-	_createCustomLevelMethods() {
-		var _this$_mergedConfig$l;
-		const levels = (_this$_mergedConfig$l = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l === void 0 ? void 0 : _this$_mergedConfig$l.levels;
-		if (!levels) return;
-		for (const levelName of Object.keys(levels)) {
-			const lower = levelName.toLowerCase();
-			if (typeof this[lower] !== "undefined") continue;
-			this[lower] = async (message, data) => {
-				return this.logger.logLevel(lower, message, data);
-			};
-		}
-	}
-	/**
-	* NestJS `LoggerService.log` — void, string context.
-	* Maps internally to `info`.
-	*
-	* @example `logger.log('User signed up', 'AuthService')`
-	*/
-	log(message, context) {
-		this.setContextIfProvided(context);
-		this.logger.info(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.log failed", err));
-	}
-	/**
-	* Native async `info` — structured data, returns `Promise<void>`.
-	*
-	* @example `await logger.info('User signed up', { userId: 'u_abc' })`
-	*/
-	async info(message, data) {
-		return this.logger.info(message, data);
-	}
-	error(message, dataOrTrace, context) {
-		if (typeof dataOrTrace === "object" && dataOrTrace !== null) return message instanceof Error ? this.logger.error(message, dataOrTrace) : this.logger.error(this.formatMessage(message), dataOrTrace);
-		this.setContextIfProvided(context);
-		const errorData = {};
-		if (typeof dataOrTrace === "string" && dataOrTrace) errorData.stack = dataOrTrace;
-		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => internalError("LogixiaLoggerService.error failed", err));
-	}
-	warn(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.warn(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.warn failed", err));
-	}
-	debug(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.debug(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.debug failed", err));
-	}
-	verbose(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.trace(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.verbose failed", err));
-	}
-	/**
-	* Native async `trace` — lowest verbosity level, structured data.
-	*/
-	async trace(message, data) {
-		return this.logger.trace(message, data);
-	}
-	/**
-	* Log at any named level with structured data.
-	*/
-	logLevel(level, message, data) {
-		return this.logger.logLevel(level, message, data);
-	}
-	time(label) {
-		this.logger.time(label);
-	}
-	async timeEnd(label) {
-		return this.logger.timeEnd(label);
-	}
-	async timeAsync(label, fn) {
-		return this.logger.timeAsync(label, fn);
-	}
-	setContext(context) {
-		const coerced = typeof context === "string" ? context : safeToString(context);
-		this.context = coerced;
-		this.logger.setContext(coerced);
-	}
-	getContext() {
-		return this.context;
-	}
-	setLevel(level) {
-		this.logger.setLevel(level);
-	}
-	getLevel() {
-		return this.logger.getLevel();
-	}
-	child(context, data) {
-		const childService = new _LogixiaLoggerService(this._mergedConfig);
-		childService.logger = this.logger.child(context, data);
-		childService.context = context;
-		return childService;
-	}
-	getCurrentTraceId() {
-		return TraceContext.instance.getCurrentTraceId();
-	}
-	/** Returns the AsyncLocalStorage key currently used to store the trace ID. */
-	get traceContextKey() {
-		return getTraceContextKey();
-	}
-	async close() {
-		return this.logger.close();
-	}
-	static create(config) {
-		return new _LogixiaLoggerService(config);
-	}
-	getLogger() {
-		return this.logger;
-	}
-	setContextIfProvided(context) {
-		if (typeof context !== "string" || context.length === 0) return;
-		if (context !== this.context) this.setContext(context);
-	}
-	formatMessage(message) {
-		if (typeof message === "string") return message;
-		return safeToString(message);
-	}
-};
-LogixiaLoggerService = _LogixiaLoggerService = __decorate([Injectable({ scope: Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
-
-//#endregion
-//#region src/core/kafka-trace.interceptor.ts
-var _KafkaTraceInterceptor;
-let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
-	static {
-		_KafkaTraceInterceptor = this;
-	}
-	static #_ = this.metrics = {
-		accepted: 0,
-		acceptedWithoutTrace: 0,
-		dropped: 0
-	};
-	/** Reset counters (tests). */
-	static resetMetrics() {
-		_KafkaTraceInterceptor.metrics.accepted = 0;
-		_KafkaTraceInterceptor.metrics.acceptedWithoutTrace = 0;
-		_KafkaTraceInterceptor.metrics.dropped = 0;
-	}
-	/**
-	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
-	* @param requireTraceId - When true, messages with no traceId are silently skipped
-	*                         (EMPTY Observable — message is ack'd, consumer stays alive).
-	*                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
-	*                         increments so the missing traceId is observable end-to-end.
-	*                         Default: false (handler runs without trace context).
-	*/
-	constructor(config, requireTraceId = false) {
-		this.config = config;
-		this.requireTraceId = requireTraceId;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const rpcContext = context.switchToRpc();
-		const data = rpcContext.getData();
-		const rpcData = rpcContext.getContext();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId({
-			body: data,
-			headers: (rpcData === null || rpcData === void 0 ? void 0 : rpcData.headers) ?? {},
-			query: {},
-			params: {}
-		}, this.config.extractor);
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) {
-			if (this.requireTraceId) {
-				var _LogixiaLoggerModule$;
-				_KafkaTraceInterceptor.metrics.dropped++;
-				(_LogixiaLoggerModule$ = LogixiaLoggerModule.getGlobalLogger()) === null || _LogixiaLoggerModule$ === void 0 || _LogixiaLoggerModule$.warn(`[KafkaTraceInterceptor] Missing traceId on topic "${rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic}" — message skipped.`);
-				return EMPTY;
-			}
-			_KafkaTraceInterceptor.metrics.acceptedWithoutTrace++;
-			return next.handle();
-		}
-		_KafkaTraceInterceptor.metrics.accepted++;
-		const kafkaContext = {
-			messageType: "kafka",
-			topic: rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic,
-			partition: rpcData === null || rpcData === void 0 ? void 0 : rpcData.partition,
-			offset: rpcData === null || rpcData === void 0 ? void 0 : rpcData.offset,
-			key: rpcData === null || rpcData === void 0 ? void 0 : rpcData.key,
-			timestamp: rpcData === null || rpcData === void 0 ? void 0 : rpcData.timestamp
-		};
-		return new Observable((subscriber) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => subscriber.next(value),
-					error: (err) => subscriber.error(err),
-					complete: () => subscriber.complete()
-				});
-			}, kafkaContext);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
-	}
-};
-KafkaTraceInterceptor = _KafkaTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
-function __decorateParam(paramIndex, decorator) {
-	return function(target, key) {
-		decorator(target, key, paramIndex);
-	};
-}
-
-//#endregion
-//#region src/core/trace.middleware.ts
-/** Default response header used to echo the resolved traceId back to the caller. */
-const DEFAULT_TRACE_RESPONSE_HEADER = "X-Trace-Id";
-/**
-* Resolve the response header name from config.
-* - `undefined`   → default `'X-Trace-Id'`
-* - `string`      → user's custom header
-* - `false`       → `null` (suppress entirely)
-*/
-function resolveResponseHeader(config) {
-	if ((config === null || config === void 0 ? void 0 : config.responseHeader) === false) return null;
-	return (config === null || config === void 0 ? void 0 : config.responseHeader) ?? DEFAULT_TRACE_RESPONSE_HEADER;
-}
-/**
-* Echo the trace ID on the response, tolerating non-Express responses and
-* already-sent headers. NestJS can run on Fastify (reply.header() instead of
-* res.setHeader()), and on a closed/sent response setHeader throws — neither
-* should crash the request. The trace ID is still propagated via async context.
-*/
-function writeTraceHeader(res, header, traceId) {
-	const r = res;
-	if (r.headersSent) return;
-	try {
-		if (typeof r.setHeader === "function") r.setHeader(header, traceId);
-		else if (typeof r.header === "function") r.header(header, traceId);
-	} catch {}
-}
-let TraceMiddleware = class TraceMiddleware$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		const defaultExtractor = {
-			header: DEFAULT_TRACE_HEADERS,
-			query: ["traceId", "trace_id"]
-		};
-		this.config = {
-			enabled: true,
-			generator: () => this.ctx.generate(),
-			contextKey: "traceId",
-			...config,
-			extractor: (config === null || config === void 0 ? void 0 : config.extractor) ? {
-				...defaultExtractor,
-				...config.extractor
-			} : defaultExtractor
-		};
-		if (this.config.enabled) this.ctx.setContextKey(this.config.contextKey ?? "traceId");
-	}
-	use(req, res, next) {
-		var _this$config, _req$socket, _req$connection;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId(req, this.config.extractor);
-		if (!traceId && this.config.generator) {
-			const candidate = this.config.generator();
-			if (typeof candidate === "string" && candidate.trim().length > 0) traceId = candidate;
-			else internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
-		}
-		if (!traceId) traceId = this.ctx.generate();
-		req.traceId = traceId;
-		const header = resolveResponseHeader(this.config);
-		if (header) writeTraceHeader(res, header, traceId);
-		this.ctx.run(traceId, () => next(), {
-			method: req.method,
-			url: req.url,
-			userAgent: req.get("User-Agent"),
-			ip: req.ip || ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) || ((_req$connection = req.connection) === null || _req$connection === void 0 ? void 0 : _req$connection.remoteAddress)
-		});
-	}
-};
-TraceMiddleware = __decorate([
-	Injectable(),
-	__decorateParam(0, Optional()),
-	__decorateMetadata("design:paramtypes", [Object])
-], TraceMiddleware);
-
-//#endregion
-//#region src/core/websocket-trace.interceptor.ts
-let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"],
-				query: ["traceId", "trace_id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config, _client$handshake3;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const wsContext = context.switchToWs();
-		const data = wsContext.getData();
-		const client = wsContext.getClient();
-		let traceId;
-		if (this.config.extractor) {
-			var _client$handshake, _client$handshake2;
-			traceId = extractTraceId({
-				body: data,
-				headers: (client === null || client === void 0 || (_client$handshake = client.handshake) === null || _client$handshake === void 0 ? void 0 : _client$handshake.headers) || {},
-				query: (client === null || client === void 0 || (_client$handshake2 = client.handshake) === null || _client$handshake2 === void 0 ? void 0 : _client$handshake2.query) || {},
-				params: {}
-			}, this.config.extractor);
-		}
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) return next.handle();
-		const wsContextData = {
-			messageType: "websocket",
-			event: data === null || data === void 0 ? void 0 : data.event,
-			socketId: client === null || client === void 0 ? void 0 : client.id,
-			rooms: (client === null || client === void 0 ? void 0 : client.rooms) ? Array.from(client.rooms) : [],
-			clientAddress: client === null || client === void 0 || (_client$handshake3 = client.handshake) === null || _client$handshake3 === void 0 ? void 0 : _client$handshake3.address
-		};
-		return new Observable((observer) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => observer.next(value),
-					error: (err) => observer.error(err),
-					complete: () => observer.complete()
-				});
-			}, wsContextData);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
-	}
-};
-WebSocketTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object])], WebSocketTraceInterceptor);
-
-//#endregion
-//#region src/core/logitron-logger.module.ts
-var _LogixiaLoggerModule;
-const DEFAULT_ROUTES = [{
-	path: "*",
-	method: RequestMethod.ALL
-}];
-const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
-const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
-const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
-let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
-	static {
-		_LogixiaLoggerModule = this;
-	}
-	constructor() {
-		this.config = {};
-	}
-	static #_ = this.loggerConfig = {};
-	static #_2 = this._globalLogger = null;
-	/**
-	* @internal Set the global logger exactly once.
-	*
-	* Called from the module's forRoot / forRootAsync factory. If the module is
-	* initialised more than once in the same process (nested DI context, test
-	* harness creating multiple apps, hot reload, etc.) a warning is written to
-	* stderr and the first logger wins — silently overwriting would allow the
-	* newer instance's transport config to replace the live one while the old
-	* one is still being used by registered shutdown hooks, decorators, etc.
-	*
-	* Use {@link _resetGlobalLogger} in tests to reset between runs.
-	*/
-	static _setGlobalLogger(service) {
-		if (_LogixiaLoggerModule._globalLogger !== null) {
-			internalWarn("LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.");
-			return;
-		}
-		_LogixiaLoggerModule._globalLogger = service;
-	}
-	/** @internal Clear the global logger. Tests only. */
-	static _resetGlobalLogger() {
-		_LogixiaLoggerModule._globalLogger = null;
-	}
-	/**
-	* Returns the global LogixiaLoggerService instance that was created when the
-	* module booted. Useful for logging outside of NestJS DI — utility functions,
-	* plain scripts, decorators — without injecting the service everywhere.
-	*
-	* Returns `null` if called before `LogixiaLoggerModule.forRoot[Async]()` has
-	* been initialised (i.e. before the NestJS app has started).
-	*
-	* @example
-	* ```ts
-	* // some-util.ts
-	* import { LogixiaLoggerModule } from 'logixia/nest';
-	*
-	* export function doSomething() {
-	*   LogixiaLoggerModule.getGlobalLogger()?.info('doing something');
-	* }
-	* ```
-	*/
-	static getGlobalLogger() {
-		return _LogixiaLoggerModule._globalLogger;
-	}
-	configure(consumer) {
-		const { forRoutes = DEFAULT_ROUTES, exclude } = this.config;
-		let resolvedTraceConfig;
-		if (typeof _LogixiaLoggerModule.loggerConfig.traceId === "object") resolvedTraceConfig = _LogixiaLoggerModule.loggerConfig.traceId;
-		else if (_LogixiaLoggerModule.loggerConfig.traceId === true) resolvedTraceConfig = {
-			enabled: true,
-			contextKey: "traceId",
-			generator: () => TraceContext.instance.generate()
-		};
-		const middleware = new TraceMiddleware(resolvedTraceConfig);
-		const middlewareConfig = (req, res, next) => middleware.use(req, res, next);
-		if (exclude) consumer.apply(middlewareConfig).exclude(...exclude).forRoutes(...forRoutes);
-		else consumer.apply(middlewareConfig).forRoutes(...forRoutes);
-	}
-	/**
-	* Configure the module with synchronous options
-	*/
-	static forRoot(config) {
-		_LogixiaLoggerModule.loggerConfig = config || {};
-		const traceConfig = (config === null || config === void 0 ? void 0 : config.traceId) && typeof config.traceId === "object" ? config.traceId : { enabled: !!(config === null || config === void 0 ? void 0 : config.traceId) };
-		return {
-			module: _LogixiaLoggerModule,
-			providers: [
-				{
-					provide: LOGIXIA_LOGGER_CONFIG,
-					useValue: config || {}
-				},
-				{
-					provide: LOGIXIA_TRACE_CONFIG,
-					useValue: traceConfig
-				},
-				{
-					provide: LogixiaLoggerService,
-					useFactory: (loggerConfig) => {
-						const service = new LogixiaLoggerService({
-							level: "info",
-							service: "NestJSApp",
-							environment: "development",
-							fields: {},
-							formatters: ["text"],
-							outputs: ["console"],
-							levelOptions: {
-								level: "info",
-								levels: {
-									error: 0,
-									warn: 1,
-									info: 2,
-									debug: 3,
-									verbose: 4
-								},
-								colors: {
-									error: "red",
-									warn: "yellow",
-									info: "green",
-									debug: "blue",
-									verbose: "cyan"
-								}
-							},
-							...loggerConfig
-						});
-						_LogixiaLoggerModule._setGlobalLogger(service);
-						return service;
-					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig$1) => new KafkaTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig$1) => new WebSocketTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Configure the module with asynchronous options
-	*/
-	static forRootAsync(options) {
-		return {
-			module: _LogixiaLoggerModule,
-			imports: options.imports || [],
-			providers: [
-				...this.createAsyncProviders(options),
-				{
-					provide: LOGIXIA_TRACE_CONFIG,
-					useFactory: (loggerConfig) => {
-						return typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : { enabled: !!(loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) };
-					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: LogixiaLoggerService,
-					useFactory: (loggerConfig) => {
-						const defaultConfig = {
-							level: "info",
-							service: "NestJSApp",
-							environment: "development",
-							fields: {},
-							formatters: ["text"],
-							outputs: ["console"],
-							levelOptions: {
-								level: "info",
-								levels: {
-									error: 0,
-									warn: 1,
-									info: 2,
-									debug: 3,
-									verbose: 4
-								},
-								colors: {
-									error: "red",
-									warn: "yellow",
-									info: "green",
-									debug: "blue",
-									verbose: "cyan"
-								}
-							},
-							...loggerConfig
-						};
-						_LogixiaLoggerModule.loggerConfig = defaultConfig;
-						const service = new LogixiaLoggerService(defaultConfig);
-						_LogixiaLoggerModule._setGlobalLogger(service);
-						return service;
-					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig) => new KafkaTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Create feature-specific logger instances
-	*/
-	static forFeature(context) {
-		const providerToken = `${LOGIXIA_LOGGER_PREFIX}${context.toUpperCase()}`;
-		return {
-			module: _LogixiaLoggerModule,
-			providers: [{
-				provide: providerToken,
-				useFactory: (baseLogger) => {
-					return baseLogger.child(context);
-				},
-				inject: [LogixiaLoggerService]
-			}],
-			exports: [providerToken]
-		};
-	}
-	static createAsyncProviders(options) {
-		if (options.useExisting || options.useFactory) return [this.createAsyncOptionsProvider(options)];
-		return [this.createAsyncOptionsProvider(options), {
-			provide: options.useClass,
-			useClass: options.useClass
-		}];
-	}
-	static createAsyncOptionsProvider(options) {
-		if (options.useFactory) return {
-			provide: LOGIXIA_LOGGER_CONFIG,
-			useFactory: options.useFactory,
-			inject: options.inject || []
-		};
-		return {
-			provide: LOGIXIA_LOGGER_CONFIG,
-			useFactory: async (optionsFactory) => await optionsFactory.createLogixiaOptions(),
-			inject: [options.useExisting || options.useClass]
-		};
-	}
-};
-LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([Module({})], LogixiaLoggerModule);
-
 //#endregion
 //#region src/exceptions/exception.ts
 var LogixiaException = class extends Error {
@@ -2613,166 +1980,5 @@ var ErrorResponseBuilder = class {
 };
 
 //#endregion
-//#region src/core/nestjs-extras.ts
-var _ref;
-/**
-* Inject the Logixia logger registered in the current NestJS DI container.
-*
-* Equivalent to `@Inject(LOGIXIA_LOGGER_TOKEN)` but without needing to import
-* the internal token constant yourself.
-*
-* @example
-* ```ts
-* constructor(@InjectLogger() private readonly logger: LogixiaLoggerService) {}
-* ```
-*/
-const InjectLogger = () => Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`);
-/**
-* Method decorator that auto-logs entry, exit, duration, and errors.
-*
-* Preserves the original method's sync/async contract: a synchronous method
-* stays synchronous (returns its value directly, with logs emitted
-* fire-and-forget), and an async method is awaited so exit/error logs reflect
-* the resolved result. Attaches to the logger found on the class instance via a
-* `logger` property (the conventional NestJS name).
-*
-* @example
-* ```ts
-* @LogMethod({ level: 'info', logArgs: true })
-* async processPayment(orderId: string): Promise<void> { … }
-* ```
-*/
-function LogMethod(options = {}) {
-	const { level = "debug", logArgs = true, logResult = false, logErrors = true } = options;
-	return function(target, propertyKey, descriptor) {
-		var _constructor;
-		const originalMethod = descriptor.value;
-		if (typeof originalMethod !== "function") return descriptor;
-		const methodName = String(propertyKey);
-		const className = ((_constructor = target.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "Unknown";
-		const label = options.label ?? `${className}.${methodName}`;
-		let _warnedNoLogger = false;
-		const reportLogFailure = (phase, err) => {
-			internalError(`@LogMethod(${label}) ${phase} log failed: ${String(err)}`);
-		};
-		const emit = (logger, phase, message, data) => {
-			const logFnRaw = logger[level];
-			const p = (typeof logFnRaw === "function" ? logFnRaw : logger.debug).bind(logger)(message, data);
-			if (p && typeof p.catch === "function") p.catch((e) => reportLogFailure(phase, e));
-		};
-		const emitError = (logger, error, start) => {
-			const err = error instanceof Error ? error : new Error(String(error));
-			const errLog = logger.error(err, {
-				method: label,
-				durationMs: Date.now() - start
-			});
-			if (errLog && typeof errLog.catch === "function") errLog.catch((e) => reportLogFailure("error", e));
-		};
-		descriptor.value = function(...args) {
-			const logger = this.logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
-			if (!logger && !_warnedNoLogger) {
-				_warnedNoLogger = true;
-				internalWarn(`@LogMethod on ${label}: no logger available. Either inject LogixiaLoggerService as this.logger or ensure LogixiaLoggerModule is initialised.`);
-			}
-			const start = Date.now();
-			const entry = { method: label };
-			if (logArgs && args.length > 0) entry["args"] = args;
-			if (logger) emit(logger, "entry", `→ ${label}`, entry);
-			const buildExit = (result$1) => {
-				const exit = {
-					method: label,
-					durationMs: Date.now() - start
-				};
-				if (logResult) exit["result"] = result$1;
-				return exit;
-			};
-			let result;
-			try {
-				result = originalMethod.apply(this, args);
-			} catch (error) {
-				if (logger && logErrors) emitError(logger, error, start);
-				throw error;
-			}
-			if (result && typeof result.then === "function") return result.then((resolved) => {
-				if (logger) emit(logger, "exit", `← ${label}`, buildExit(resolved));
-				return resolved;
-			}, (error) => {
-				if (logger && logErrors) emitError(logger, error, start);
-				throw error;
-			});
-			if (logger) emit(logger, "exit", `← ${label}`, buildExit(result));
-			return result;
-		};
-		return descriptor;
-	};
-}
-/** Injection token for {@link LogixiaExceptionFilterOptions}. */
-const LOGIXIA_EXCEPTION_FILTER_OPTIONS = "LOGIXIA_EXCEPTION_FILTER_OPTIONS";
-let LogixiaExceptionFilter = class LogixiaExceptionFilter$1 {
-	constructor(logger, loggerConfig, options) {
-		this._options = options ?? {};
-		this._logger = logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
-		this._traceConfig = typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : void 0;
-	}
-	catch(exception, host) {
-		var _request$headers;
-		const ctx = host.switchToHttp();
-		const request = ctx.getRequest();
-		const response = ctx.getResponse();
-		const traceId = TraceContext.instance.getCurrentTraceId() ?? sanitizeIncomingId((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers["x-trace-id"]) ?? sanitizeIncomingId(request.id) ?? void 0;
-		const { response: errorResponse, httpStatus } = ErrorResponseBuilder.build({
-			exception,
-			traceId,
-			path: request.url ?? "/",
-			startTime: request.startTime,
-			exposeDebug: this._options.exposeDebug === true,
-			exposeCause: this._options.exposeCause === true
-		});
-		if (this._logger) {
-			const requestMeta = {
-				method: request.method ?? "",
-				url: request.url ?? "",
-				status: httpStatus,
-				...errorResponse.meta.trace_id !== void 0 ? { trace_id: errorResponse.meta.trace_id } : {}
-			};
-			const onLogFailure = (err) => {
-				internalError(`ExceptionFilter failed to write log entry: ${String(err)}`);
-			};
-			let logPromise;
-			if (httpStatus >= 500) {
-				const err = exception instanceof Error ? exception : new Error(String(exception));
-				logPromise = this._logger.error(err, requestMeta);
-			} else if (isLogixiaException(exception)) logPromise = this._logger.warn(`[${errorResponse.error.code}] ${errorResponse.error.message}`, requestMeta);
-			else logPromise = this._logger.warn(`[${httpStatus}] ${errorResponse.error.message}`, requestMeta);
-			if (logPromise && typeof logPromise.catch === "function") logPromise.catch(onLogFailure);
-		}
-		if (errorResponse.meta.trace_id) {
-			const traceHeader = resolveResponseHeader(this._traceConfig);
-			if (traceHeader) try {
-				response.setHeader(traceHeader, errorResponse.meta.trace_id);
-			} catch {}
-		}
-		if (httpStatus === 429) try {
-			response.setHeader("Retry-After", "60");
-		} catch {}
-		response.status(httpStatus).json(errorResponse);
-	}
-};
-LogixiaExceptionFilter = __decorate([
-	Catch(),
-	__decorateParam(0, Optional()),
-	__decorateParam(0, Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`)),
-	__decorateParam(1, Optional()),
-	__decorateParam(1, Inject(LOGIXIA_LOGGER_CONFIG)),
-	__decorateParam(2, Optional()),
-	__decorateParam(2, Inject(LOGIXIA_EXCEPTION_FILTER_OPTIONS)),
-	__decorateMetadata("design:paramtypes", [
-		Object,
-		typeof (_ref = typeof Partial !== "undefined" && Partial) === "function" ? _ref : Object,
-		Object
-	])
-], LogixiaExceptionFilter);
-
-//#endregion
-export { initOtelBridge as A, registerForShutdown as C, disableOtelBridge as D, redactObject as E, DEFAULT_LOG_LEVELS as F, LogLevel as I, PluginRegistry as L, normalizeError as M, serializeError as N, getActiveOtelContext as O, DEFAULT_LOG_COLORS as P, globalPluginRegistry as R, flushOnExit as S, applyRedaction as T, LogixiaLoggerService as _, ErrorResponseBuilder as a, _shutdownRegistrySize as b, LogixiaException as c, LOGIXIA_LOGGER_PREFIX as d, LOGIXIA_TRACE_CONFIG as f, KafkaTraceInterceptor as g, TraceMiddleware as h, LogixiaExceptionFilter as i, isError as j, getOtelMetaFields as k, isLogixiaException as l, WebSocketTraceInterceptor as m, LOGIXIA_EXCEPTION_FILTER_OPTIONS as n, generateRequestId as o, LogixiaLoggerModule as p, LogMethod as r, generateTraceId as s, InjectLogger as t, LOGIXIA_LOGGER_CONFIG as u, LogixiaLogger as v, resetShutdownHandlers as w, deregisterFromShutdown as x, createLogger as y, usePlugin as z };
-//# sourceMappingURL=nestjs-extras-ImbuDhs1.mjs.map
+export { globalPluginRegistry as C, DEFAULT_LOG_LEVELS as D, DEFAULT_LOG_COLORS as E, LogLevel as O, PluginRegistry as S, DEFAULT_CONFIG as T, getOtelMetaFields as _, isLogixiaException as a, normalizeError as b, _shutdownRegistrySize as c, registerForShutdown as d, resetShutdownHandlers as f, getActiveOtelContext as g, disableOtelBridge as h, LogixiaException as i, deregisterFromShutdown as l, redactObject as m, generateRequestId as n, LogixiaLogger as o, applyRedaction as p, generateTraceId as r, createLogger as s, ErrorResponseBuilder as t, flushOnExit as u, initOtelBridge as v, usePlugin as w, serializeError as x, isError as y };
+//# sourceMappingURL=builder-0gEzRopq.mjs.map