@mks2508/better-logger 0.18.4 → 0.18.5

package/dist/chunks/transports-eCvDrc2q.cjs

@@ -0,0 +1,1459 @@
+const require_core = require("./core-CqS_UBzJ.cjs");
+//#region src/types/transports.ts
+/**
+* Mapea un `LogLevel` a la severidad numérica de OpenTelemetry (1-24) usada
+* por SigNoz / cualquier backend OTLP/HTTP. Valores por banda conformes a la
+* spec: TRACE=1-4, DEBUG=5-8, INFO=9-12, WARN=13-16, ERROR=17-20, FATAL=21-24.
+* Se usa el valor canónico del medio de cada banda.
+*
+* @see https://opentelemetry.io/docs/specs/otel/logs/data-model/#severity-fields
+*/
+const LOG_LEVEL_TO_SEVERITY_NUMBER = {
+	trace: 1,
+	debug: 5,
+	info: 9,
+	warn: 13,
+	error: 17,
+	critical: 21
+};
+/**
+* Mapea un `LogLevel` a su nombre de severidad OpenTelemetry (mayúsculas, spec OTel).
+*/
+const LOG_LEVEL_TO_SEVERITY_TEXT = {
+	trace: "TRACE",
+	debug: "DEBUG",
+	info: "INFO",
+	warn: "WARN",
+	error: "ERROR",
+	critical: "FATAL"
+};
+//#endregion
+//#region src/transports/ConsoleTransport.ts
+/**
+* Transport por defecto que escribe cada {@link TransportRecord} al `console`
+* global del runtime (navegador o Node.js).
+*
+* Es el transport que el Logger registra automáticamente cuando no se configura
+* ninguno explícito, garantizando que los registros siempre lleguen a un
+* destino visible sin configuración adicional.
+*
+* **Mapeo level → console method**: traduce cada nivel de log al método más
+* cercano de la API `console`, de forma que el filtrado nativo del DevTools /
+* `NODE_DEBUG` siga funcionando:
+*
+* | LogLevel     | console method |
+* |--------------|----------------|
+* | `debug`      | `console.log`  |
+* | `info`       | `console.info` |
+* | `warn`       | `console.warn` |
+* | `error`      | `console.error`|
+* | `critical`   | `console.error`|
+*
+* **Formato de output**: cada línea se compone como
+* `[LEVEL] [prefix] message (file:line)`, donde `prefix` y la localización
+* se omiten si el registro no las trae.
+*
+* @example
+* // Uso directo como ITransport
+* import { ConsoleTransport } from '@mks2508/better-logger/transports';
+* const transport = new ConsoleTransport();
+* transport.write({
+*   level: 'info',
+*   msg: 'Arrancando worker',
+*   prefix: 'worker',
+*   // ... resto del TransportRecord
+* });
+* // → console.info("[INFO] [worker] Arrancando worker (worker.ts:12)")
+*
+* @example
+* // Registro a través del Logger (típico — el logger lo añade por defecto)
+* logger.addTransport({ target: new ConsoleTransport() });
+*
+* @see {@link ITransport}
+* @see {@link TransportRecord}
+*/
+var ConsoleTransport = class {
+	options;
+	/** Identificador del transport usado por el Logger para deduplicar y exponer metadatos. */
+	name = "console";
+	/**
+	* Crea una instancia de {@link ConsoleTransport}.
+	*
+	* El parámetro `options` se acepta para cumplir con la firma canónica de
+	* {@link TransportOptions} (filtros de nivel, formateadores, etc.), aunque
+	* la implementación actual escribe el registro tal cual llega sin
+	* transformaciones adicionales.
+	*
+	* @param {TransportOptions} [options] - Configuración opcional del transport
+	* (nivel mínimo, formatter, etc.).
+	*
+	* @example
+	* const transport = new ConsoleTransport({ level: 'warn' });
+	*/
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Escribe un {@link TransportRecord} al `console` global.
+	*
+	* Selecciona el método de console según el nivel del registro, compone el
+	* prefijo `[LEVEL] [prefix]` y, si la localización está disponible, añade
+	* el sufijo `(file:line)`. No lanza ni retorna errores: si `console[method]`
+	* fallara (raro), la excepción propagaría al caller.
+	*
+	* @param {TransportRecord} record - Registro normalizado producido por el Logger.
+	* @returns {void}
+	*
+	* @example
+	* transport.write({
+	*   level: 'error',
+	*   msg: 'DB connection lost',
+	*   prefix: 'db',
+	*   location: { file: 'pool.ts', line: 87, function: 'acquire' },
+	*   // ... resto del TransportRecord
+	* });
+	* // → console.error("[ERROR] [db] DB connection lost (pool.ts:87)")
+	*/
+	write(record) {
+		const method = this.getConsoleMethod(record.level);
+		const prefix = record.prefix ? `[${record.prefix}] ` : "";
+		const location = record.location ? ` (${record.location.file}:${record.location.line})` : "";
+		console[method](`[${record.level.toUpperCase()}]${prefix} ${record.msg}${location}`);
+	}
+	/**
+	* Resuelve el método de `console` apropiado para un {@link LogLevel}.
+	*
+	* Tabla de mapeo:
+	* - `debug`    → `log`    (sin ruido en DevTools por defecto)
+	* - `info`     → `info`
+	* - `warn`     → `warn`
+	* - `error`    → `error`
+	* - `critical` → `error`  (no existe `console.critical`)
+	* - cualquier otro → `log` (fallback seguro)
+	*
+	* @internal Método privado; no forma parte de la API pública del transport.
+	*
+	* @param {LogLevel} level - Nivel del registro a traducir.
+	* @returns {'log' | 'info' | 'warn' | 'error'} Nombre del método de `console`.
+	*/
+	getConsoleMethod(level) {
+		switch (level) {
+			case "debug": return "log";
+			case "info": return "info";
+			case "warn": return "warn";
+			case "error":
+			case "critical": return "error";
+			default: return "log";
+		}
+	}
+};
+//#endregion
+//#region src/transports/FileTransport.ts
+const MAX_BUFFER_DEFAULT = 1e4;
+const BATCH_SIZE_DEFAULT = 100;
+const FS_PROMISES_LOAD_TIMEOUT_MS = 50;
+const LOCAL_STORAGE_KEY_PREFIX = "better-logger:";
+/**
+* Transport que escribe registros a fichero (Node) o `localStorage` (browser).
+*
+* En Node, hace `appendFile` asíncrono vía `fs.promises` cargado con dynamic
+* import (no bloquea el event loop, no envía código Node-only al bundle del
+* browser). En el browser, acumula en `localStorage` con prefijo `better-logger:`
+* y degrada a no-op silencioso si el storage no está disponible (modo privado,
+* sandbox de iframes, quota agotada).
+*
+* El buffer es bounded: al llegar a `maxBufferSize` suelta el registro más
+* viejo (drop-oldest) e invoca `onError` con el payload descartado, de modo
+* que un pico de tráfico sostenido no agota memoria.
+*
+* El `destination` se sanea antes de usarse:
+* - Node: se rechazan rutas con segmento `..` o `~` (path traversal / tilde
+*   sin expandir). Una ruta absoluta explícita (POSIX o Windows) se acepta
+*   tal cual — es al dueño del proceso a quien le toca decidir dónde
+*   escribe. Si se rechaza, ese flush no escribe nada (no hay fallback
+*   silencioso a otra ubicación); se reporta vía `onError` si está cableado.
+* - Browser: se colapsa a `[a-zA-Z0-9_-]` recortado a 64 caracteres.
+*
+* @implements {IBufferedTransport}
+*
+* @example
+* // Node: append a fichero con flush cada segundo
+* logger.addTransport({
+*   target: new FileTransport({
+*     destination: 'logs/app.log',
+*     batchSize: 100,
+*     flushInterval: 1000,
+*     onError: (entry) => captureFailure(entry)
+*   })
+* });
+*
+* @example
+* // Browser: persiste en localStorage bajo 'better-logger:audit'
+* logger.addTransport({
+*   target: new FileTransport({ destination: 'audit' })
+* });
+*
+* @see {@link FileTransportOptions}
+* @see {@link IBufferedTransport}
+*/
+var FileTransport = class {
+	/** Identificador del transport dentro del pipeline (`'file'`). */
+	name = "file";
+	buffer = [];
+	flushTimer;
+	options;
+	closed = false;
+	/**
+	* Construye el transport. Si se pasa `flushInterval`, arranca un timer
+	* periódico que vacía el buffer al vencimiento; si no, el flush se
+	* dispara solo cuando el buffer alcanza `batchSize`.
+	*
+	* @param {FileTransportOptions} [options] - Configuración. Defaults: `batchSize=100`, `maxBufferSize=10000`.
+	*
+	* @example
+	* const t = new FileTransport({ destination: 'app.log', flushInterval: 1000 });
+	*/
+	constructor(options) {
+		this.options = {
+			batchSize: BATCH_SIZE_DEFAULT,
+			maxBufferSize: MAX_BUFFER_DEFAULT,
+			...options ?? {}
+		};
+		if (this.options.flushInterval) this.flushTimer = setInterval(() => {
+			this.flush();
+		}, this.options.flushInterval);
+	}
+	/** Registros pendientes en el buffer (aún sin flush). */
+	get bufferSize() {
+		return this.buffer.length;
+	}
+	/** Capacidad máxima del buffer; al superarla se aplica drop-oldest. */
+	get maxBufferSize() {
+		return this.options.maxBufferSize ?? MAX_BUFFER_DEFAULT;
+	}
+	/**
+	* Indica si el transport acepta escrituras. Devuelve `false` después de
+	* {@link FileTransport.close} — cualquier `write` posterior se descarta.
+	*
+	* @returns {boolean} `true` mientras el transport no esté cerrado.
+	*/
+	isReady() {
+		return !this.closed;
+	}
+	/**
+	* Encola un registro serializado (JSON + `\n`). Si el buffer está a tope,
+	* suelta el registro más viejo (drop-oldest) y emite un evento `onError`
+	* con el payload descartado para que la pérdida sea observable. Si al
+	* encolar se alcanza `batchSize`, dispara un flush asíncrono.
+	*
+	* No-op silencioso si el transport está cerrado.
+	*
+	* @param {TransportRecord} record - Registro a escribir.
+	*/
+	write(record) {
+		if (this.closed) return;
+		if (this.buffer.length >= this.maxBufferSize) {
+			const dropped = this.buffer.shift();
+			if (dropped && this.options.onError) {
+				const entry = {
+					level: "warn",
+					message: "FileTransport buffer overflow: oldest record dropped",
+					args: [],
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					hookEvent: "onError",
+					error: /* @__PURE__ */ new Error("FileTransport buffer overflow"),
+					extra: { droppedRecord: dropped }
+				};
+				this.options.onError(entry);
+			}
+		}
+		this.buffer.push(JSON.stringify(record) + "\n");
+		const batchSize = this.options.batchSize ?? BATCH_SIZE_DEFAULT;
+		if (this.buffer.length >= batchSize) this.flush();
+	}
+	/**
+	* Vuelca el buffer al destino. En Node concatena el contenido y hace
+	* un único `appendFile`; en browser hace un único `setItem` sobre
+	* `localStorage`. El buffer se vacía antes del I/O para que los registros
+	* entrantes no esperen al disco. Los errores de escritura se reportan
+	* vía `onError` (nunca lanzan al caller).
+	*
+	* @returns {Promise<void>} Resuelve cuando el I/O terminó o falló.
+	*/
+	async flush() {
+		if (this.closed || this.buffer.length === 0) return;
+		const payload = this.buffer.join("");
+		this.buffer = [];
+		if (isNodeLike()) await this.flushNode(payload);
+		else await this.flushBrowser(payload);
+	}
+	async flushNode(payload) {
+		const destination = this.resolveNodeDestination();
+		if (destination === null) return;
+		try {
+			await (await loadNodeFsPromises()).appendFile(destination, payload, "utf8");
+		} catch (error) {
+			this.emitError("FileTransport failed to write to disk", error);
+		}
+	}
+	async flushBrowser(payload) {
+		if (typeof localStorage === "undefined") {
+			this.emitError("FileTransport: localStorage is not available in this environment", null);
+			return;
+		}
+		try {
+			const key = LOCAL_STORAGE_KEY_PREFIX + this.resolveBrowserKey();
+			const existing = localStorage.getItem(key) ?? "";
+			localStorage.setItem(key, existing + payload);
+		} catch (error) {
+			this.emitError("FileTransport: localStorage write failed (quota? private mode?)", error);
+		}
+	}
+	/**
+	* Cierra el transport: detiene el timer de flush y dispara un flush
+	* final para no perder registros pendientes. Tras cerrar, `write` y
+	* `flush` se vuelven no-op.
+	*
+	* @returns {Promise<void>} Resuelve cuando el flush final termina.
+	*/
+	async close() {
+		this.closed = true;
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = void 0;
+		}
+		await this.flush();
+	}
+	resolveNodeDestination() {
+		const requested = this.options.destination ?? "app.log";
+		const sanitised = sanitiseNodePath(requested);
+		if (sanitised === null) {
+			this.emitError(`FileTransport: refusing destination with traversal segment: ${requested}`, null);
+			return null;
+		}
+		return sanitised;
+	}
+	resolveBrowserKey() {
+		return sanitiseBrowserKey(this.options.destination ?? "default");
+	}
+	emitError(message, cause) {
+		if (!this.options.onError) return;
+		const entry = {
+			level: "error",
+			message,
+			args: [],
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			hookEvent: "onError",
+			error: cause instanceof Error ? cause : new Error(String(cause))
+		};
+		this.options.onError(entry);
+	}
+};
+/**
+* Detecta si el runtime es Node comprobando `process.versions.node`.
+*
+* @internal Dispatch Node/browser dentro del transport.
+* @returns {boolean} `true` si corre sobre Node.
+*/
+function isNodeLike() {
+	return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+/**
+* Sanea la ruta pedida por el caller: colapsa backslashes a `/`, descarta
+* segmentos `.` y rechaza traversal (`..`) o tilde sin expandir (`~`). Una
+* ruta absoluta explícita (POSIX `/...` o Windows `C:/...`) es una elección
+* legítima del dueño del proceso y se preserva intacta — el guard existe
+* para sanear input no confiable, no para impedir que el caller elija dónde
+* escribe su propio log.
+*
+* @internal
+* @param {string} input - Ruta cruda pedida por el caller.
+* @returns {string | null} Ruta saneada (con el prefijo absoluto intacto si
+*   lo tenía), o `null` si contiene un segmento `..` o `~`.
+*/
+function sanitiseNodePath(input) {
+	if (!input) return null;
+	const normalised = input.replace(/\\/g, "/").trim();
+	if (normalised.length === 0) return null;
+	const isPosixAbsolute = normalised.startsWith("/");
+	const segments = normalised.split("/").filter((s) => s.length > 0 && s !== ".");
+	if (segments.some((s) => s === ".." || s === "~")) return null;
+	const joined = segments.join("/");
+	return isPosixAbsolute ? "/" + joined : joined;
+}
+/**
+* Convierte cualquier string en una clave válida para `localStorage`:
+* colapsa todo carácter fuera de `[a-zA-Z0-9_-]` a `_` y recorta a 64
+* caracteres. Devuelve `'default'` si el resultado es vacío.
+*
+* @internal
+* @param {string} input - Clave cruda pedida por el caller.
+* @returns {string} Clave saneada lista para `localStorage`.
+*/
+function sanitiseBrowserKey(input) {
+	return input.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "default";
+}
+/**
+* Dynamic import cacheado de `node:fs/promises`. La caché es intencionadamente
+* module-scoped para que los flushes posteriores no paguen el coste del import.
+* Además corre el import contra un timeout corto (`FS_PROMISES_LOAD_TIMEOUT_MS`)
+* para que un entorno Node roto (bindings nativos corruptos) no bloquee el
+* transport indefinidamente.
+*
+* @internal
+* @returns {Promise<typeof import('node:fs/promises')>} Módulo `fs/promises` resuelto.
+* @throws {Error} Si el import excede el timeout o el módulo no está disponible.
+*/
+let _fsPromisesPromise = null;
+async function loadNodeFsPromises() {
+	if (_fsPromisesPromise) return _fsPromisesPromise;
+	const importPromise = import("node:fs/promises");
+	const timeoutPromise = new Promise((_, reject) => {
+		setTimeout(() => reject(/* @__PURE__ */ new Error(`fs/promises import timed out after ${FS_PROMISES_LOAD_TIMEOUT_MS}ms`)), FS_PROMISES_LOAD_TIMEOUT_MS);
+	});
+	_fsPromisesPromise = Promise.race([importPromise, timeoutPromise]).catch((err) => {
+		_fsPromisesPromise = null;
+		throw err;
+	});
+	return _fsPromisesPromise;
+}
+//#endregion
+//#region src/transports/HttpTransport.ts
+const DEFAULT_MAX_BUFFER = 1e4;
+const DEFAULT_BATCH_SIZE = 50;
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_INITIAL_BACKOFF = 250;
+const DEFAULT_MAX_BACKOFF = 5e3;
+const DEFAULT_FETCH_TIMEOUT = 1e4;
+/**
+* Transport basado en HTTP. Bufferea records, los batcha por tamaño o
+* intervalo, POSTea el batch como JSON, y reporta fallos vía retry, buffer
+* acotado y un hook `onError` — nunca un `.catch(() => {})` silencioso.
+*
+* Lifecycle de cada batch (driveado internamente por `sendWithRetry`):
+*  1. `fetch(url, { method: 'POST', body, signal })` con un `AbortController`
+*     que aborta tras `fetchTimeoutMs`.
+*  2. Si `response.ok` → batch considerado entregado.
+*  3. Si `4xx` → dropeado sin reintento: el cliente nunca se recupera de un
+*     error de URL/auth/payload mal formado. Se dispara `onError`.
+*  4. Si `5xx` o `fetch` lanza (red caída / abort por timeout) → reintento con
+*     backoff exponencial: arranca en `initialBackoffMs`, duplica por intento,
+*     techo `maxBackoffMs`, hasta `maxRetries` intentos. Tras el agotamiento
+*     el batch se re-bufferiza (o se trimea contra `maxBufferSize`) y se
+*     dispara `onError` con `droppedCount`.
+*
+* El body por defecto es el envelope JSON `{ logs: TransportRecord[] }`.
+* Para cambiar el wire format, sobrescribe los hooks `protected`
+* {@link HttpTransport.serializeBody} y {@link HttpTransport.buildHeaders}
+* (referencia: {@link OtlpTransport}).
+*
+* Extender esta clase es la vía recomendada para shippear un transport
+* nuevo orientado a HTTP.
+*
+* @example
+* // Registro en un logger
+* import logger from '@mks2508/better-logger';
+* import { HttpTransport } from '@mks2508/better-logger/transports';
+*
+* logger.addTransport({
+*   target: new HttpTransport({
+*     url: 'https://logs.example.com/ingest',
+*     flushInterval: 5_000,
+*     batchSize: 100,
+*     onError: (entry) => console.error('[log-drop]', entry.message)
+*   })
+* });
+*
+* @see {@link HttpTransportOptions}
+* @see {@link OtlpTransport}
+*/
+var HttpTransport = class {
+	/** Identificador del transport. Los loggers lo usan para lookup, dedup y logs de diagnóstico. */
+	name = "http";
+	buffer = [];
+	flushTimer;
+	closed = false;
+	/** Bag de options — `protected` para que subclasses (ej. {@link OtlpTransport}) puedan leerlo o extenderlo. */
+	options;
+	/**
+	* Crea una instancia de {@link HttpTransport}.
+	*
+	* Los campos omitidos en `options` se rellenan con defaults sensatos
+	* (`batchSize=50`, `maxBufferSize=10_000`, `maxRetries=3`,
+	* `initialBackoffMs=250`, `maxBackoffMs=5_000`, `fetchTimeoutMs=10_000`).
+	* Si se pasa `flushInterval`, arranca un `setInterval` que flushea cada
+	* N ms; si se omite, el flush solo dispara por llenado de `batchSize`.
+	*
+	* @param {HttpTransportOptions} [options] - Configuración opcional. Si se omite por completo, el transport queda inactivo hasta que se setee `options.url` por otra vía (subclasses).
+	*
+	* @example
+	* const t = new HttpTransport({
+	*   url: 'https://logs.example.com/ingest',
+	*   flushInterval: 5_000
+	* });
+	*/
+	constructor(options) {
+		this.options = {
+			batchSize: DEFAULT_BATCH_SIZE,
+			maxBufferSize: DEFAULT_MAX_BUFFER,
+			maxRetries: DEFAULT_MAX_RETRIES,
+			initialBackoffMs: DEFAULT_INITIAL_BACKOFF,
+			maxBackoffMs: DEFAULT_MAX_BACKOFF,
+			fetchTimeoutMs: DEFAULT_FETCH_TIMEOUT,
+			...options ?? {}
+		};
+		if (this.options.flushInterval) this.flushTimer = setInterval(() => {
+			this.flush();
+		}, this.options.flushInterval);
+	}
+	/** Records actualmente encolados esperando el próximo flush. */
+	get bufferSize() {
+		return this.buffer.length;
+	}
+	/** Capacidad máxima del buffer. Al superarla, el registro más viejo se dropea y se notifica vía `onError`. */
+	get maxBufferSize() {
+		return this.options.maxBufferSize ?? DEFAULT_MAX_BUFFER;
+	}
+	/**
+	* Indica si el transport está listo para aceptar y entregar records.
+	* Devuelve `false` tras {@link close} o si no se configuró `url`.
+	*
+	* @returns {boolean} `true` si el transport puede enviar.
+	*/
+	isReady() {
+		return !this.closed && Boolean(this.options.url);
+	}
+	/**
+	* Encola un record en el buffer. Si el buffer está lleno, aplica la
+	* política de overflow (dropea el más viejo + dispara `onError`). Si tras
+	* el push se alcanza `batchSize`, dispara un flush asíncrono (sin await).
+	*
+	* No-op si el transport ya fue cerrado ({@link close}).
+	*
+	* @param {TransportRecord} record - Registro a encolar.
+	*/
+	write(record) {
+		if (this.closed) return;
+		if (this.buffer.length >= this.maxBufferSize) this.applyOverflowPolicy();
+		this.buffer.push(record);
+		const batchSize = this.options.batchSize ?? DEFAULT_BATCH_SIZE;
+		if (this.buffer.length >= batchSize) this.flush();
+	}
+	/**
+	* Serializa un batch al body de la request. Las subclasses sobrescriben
+	* para cambiar la codificación (ej. {@link OtlpTransport} produce OTLP/HTTP
+	* JSON en vez del envelope default `{ logs: [...] }`).
+	*
+	*/
+	serializeBody(records) {
+		return JSON.stringify({ logs: records });
+	}
+	/**
+	* Construye los headers de la request. Las subclasses pueden prependear
+	* headers transport-specific (ej. `signoz-ingestion-key`).
+	*
+	*/
+	buildHeaders() {
+		return {
+			"Content-Type": "application/json",
+			...this.options.headers ?? {}
+		};
+	}
+	applyOverflowPolicy() {
+		const dropped = this.buffer.shift();
+		if (dropped && this.options.onError) {
+			const entry = {
+				level: "warn",
+				message: "HttpTransport buffer overflow: oldest record dropped",
+				args: [dropped],
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				hookEvent: "onError",
+				error: /* @__PURE__ */ new Error("HttpTransport buffer overflow"),
+				extra: { droppedRecord: dropped }
+			};
+			this.options.onError(entry);
+		}
+	}
+	/**
+	* Flushea el buffer actual: toma un snapshot de los records pendientes,
+	* los envía con retry/backoff vía `sendWithRetry`, y ante fallo los
+	* re-bufferiza preservando el orden. Si la re-bufferización excede
+	* `maxBufferSize`, trimea los más viejos y dispara `onError` con
+	* `droppedCount`.
+	*
+	* No-op si el transport está cerrado, el buffer está vacío o no hay
+	* `url` configurada.
+	*
+	* @returns {Promise<void>} Resuelve cuando el intento de entrega del batch actual terminó (success, drop definitivo o no-op).
+	*
+	* @see {@link HttpTransportOptions.onError}
+	*/
+	async flush() {
+		if (this.closed || this.buffer.length === 0 || !this.options.url) return;
+		const records = [...this.buffer];
+		this.buffer = [];
+		if (!await this.sendWithRetry(records)) {
+			const combined = records.concat(this.buffer);
+			if (combined.length > this.maxBufferSize) {
+				const trimmed = combined.slice(combined.length - this.maxBufferSize);
+				const droppedCount = combined.length - trimmed.length;
+				if (droppedCount > 0 && this.options.onError) {
+					const entry = {
+						level: "error",
+						message: `HttpTransport dropped ${droppedCount} records after retry exhaustion`,
+						args: [],
+						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+						hookEvent: "onError",
+						error: /* @__PURE__ */ new Error("HttpTransport retry exhaustion"),
+						extra: { droppedCount }
+					};
+					this.options.onError(entry);
+				}
+				this.buffer = trimmed;
+			} else this.buffer = combined;
+		}
+	}
+	async sendWithRetry(records) {
+		const url = this.options.url;
+		if (!url) return false;
+		const maxRetries = this.options.maxRetries ?? DEFAULT_MAX_RETRIES;
+		const initialBackoff = this.options.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF;
+		const maxBackoff = this.options.maxBackoffMs ?? DEFAULT_MAX_BACKOFF;
+		const fetchTimeout = this.options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT;
+		const body = this.serializeBody(records);
+		const headers = this.buildHeaders();
+		let attempt = 0;
+		let backoff = initialBackoff;
+		while (attempt <= maxRetries) {
+			try {
+				const controller = new AbortController();
+				const timeoutId = setTimeout(() => controller.abort(), fetchTimeout);
+				const response = await fetch(url, {
+					method: "POST",
+					headers,
+					body,
+					signal: controller.signal
+				});
+				clearTimeout(timeoutId);
+				if (response.ok) return true;
+				if (response.status >= 400 && response.status < 500) {
+					if (this.options.onError) {
+						const entry = {
+							level: "error",
+							message: `HttpTransport ${response.status} ${response.statusText} (not retried)`,
+							args: [],
+							timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+							hookEvent: "onError",
+							error: /* @__PURE__ */ new Error(`HTTP ${response.status}`),
+							extra: { responseStatus: response.status }
+						};
+						this.options.onError(entry);
+					}
+					return false;
+				}
+				if (attempt === maxRetries) break;
+				await sleep(backoff);
+				backoff = Math.min(backoff * 2, maxBackoff);
+			} catch (error) {
+				if (attempt === maxRetries) {
+					if (this.options.onError) {
+						const entry = {
+							level: "error",
+							message: `HttpTransport fetch failed after ${maxRetries + 1} attempts`,
+							args: [],
+							timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+							hookEvent: "onError",
+							error: error instanceof Error ? error : new Error(String(error))
+						};
+						this.options.onError(entry);
+					}
+					return false;
+				}
+				await sleep(backoff);
+				backoff = Math.min(backoff * 2, maxBackoff);
+			}
+			attempt++;
+		}
+		return false;
+	}
+	/**
+	* Cierra el transport: marca el flag `closed`, detiene el timer de
+	* `flushInterval` si estaba corriendo, y ejecuta un flush final para
+	* entregar lo pendiente.
+	*
+	* Tras `close()`, todo {@link write} posterior es no-op y
+	* {@link isReady} devuelve `false`.
+	*
+	* @returns {Promise<void>} Resuelve cuando el flush final termina.
+	*
+	* @see {@link flush}
+	*/
+	async close() {
+		this.closed = true;
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = void 0;
+		}
+		await this.flush();
+	}
+};
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/transports/OtlpTransport.ts
+/**
+* Transport OTLP/HTTP para SigNoz (o cualquier backend compatible con OTLP).
+*
+* Extiende {@link HttpTransport} — hereda retry, buffer acotado, status check,
+* close asincrónico y el hook on-error. Overridea únicamente la shape del
+* payload y los headers del request.
+*
+* @example
+* ```ts
+* logger.addTransport({
+*   target: new OtlpTransport({
+*     endpoint: 'https://otelcollector.example.com:4318',
+*     serviceName: 'my-app',
+*     serviceVersion: '1.2.3',
+*     environment: 'production',
+*     ingestKeyEnvVar: 'SIGNOZ_KEY'
+*   })
+* });
+* ```
+*/
+var OtlpTransport = class extends HttpTransport {
+	name = "otlp";
+	resource;
+	/** Resuelto al construir. Nunca se loguea, nunca se escribe a source. */
+	ingestKeyValue;
+	constructor(options) {
+		if (!options.endpoint) throw new Error("OtlpTransport: `endpoint` is required");
+		if (!options.serviceName) throw new Error("OtlpTransport: `serviceName` is required");
+		const ingestKey = readIngestKey(options.ingestKeyEnvVar);
+		const httpOptions = {
+			url: `${stripTrailingSlash(options.endpoint)}/v1/logs`,
+			headers: {
+				...ingestKey ? { "signoz-ingestion-key": ingestKey } : {},
+				...options.headers ?? {}
+			},
+			batchSize: options.batchSize,
+			flushInterval: options.flushInterval,
+			maxBufferSize: options.maxBufferSize,
+			maxRetries: options.maxRetries,
+			initialBackoffMs: options.initialBackoffMs,
+			maxBackoffMs: options.maxBackoffMs,
+			fetchTimeoutMs: options.fetchTimeoutMs,
+			onError: options.onError
+		};
+		super(httpOptions);
+		this.resource = {
+			"service.name": options.serviceName,
+			...options.serviceVersion ? { "service.version": options.serviceVersion } : {},
+			...options.environment ? { "deployment.environment": options.environment } : {},
+			...options.resourceAttributes ?? {}
+		};
+		this.ingestKeyValue = ingestKey;
+	}
+	/**
+	* Construye el payload JSON OTLP/HTTP a partir de los records bufferizados.
+	* Un bloque `resourceLogs` por batch (sigue la guía de batching del
+	* collector OTel). Expuesto para tests y para subclasses custom de transport.
+	*
+	* @param records - Records de log a serializar dentro del payload.
+	* @returns Objeto `LogsData` listo para `JSON.stringify`.
+	* @see {@link OtlpLogsPayload}
+	*/
+	buildPayload(records) {
+		return { resourceLogs: [{
+			resource: { attributes: Object.entries(this.resource).filter((entry) => typeof entry[1] === "string").map(([key, value]) => ({
+				key,
+				value: { stringValue: value }
+			})) },
+			scopeLogs: [{
+				scope: {
+					name: "better-logger",
+					version: "5.1.0"
+				},
+				logRecords: records.map((r) => this.toLogRecord(r))
+			}]
+		}] };
+	}
+	/**
+	* Serializa un batch al body JSON del request OTLP/HTTP. Override de
+	* {@link HttpTransport.serializeBody}.
+	*
+	* @param records - Records del batch a serializar.
+	* @returns String JSON listo para usar como `body` del fetch POST.
+	*/
+	serializeBody(records) {
+		return JSON.stringify(this.buildPayload(records));
+	}
+	/**
+	* Construye los headers del request. Agrega `signoz-ingestion-key` con el
+	* valor resuelto al construir (nunca se loguea, nunca se escribe a source).
+	*
+	* @returns Record de headers a merguear en el fetch.
+	*/
+	buildHeaders() {
+		return {
+			"Content-Type": "application/json",
+			...this.ingestKeyValue ? { "signoz-ingestion-key": this.ingestKeyValue } : {},
+			...this.options.headers ?? {}
+		};
+	}
+	toLogRecord(record) {
+		const timeUnixNano = String(BigInt(record.time) * 1000000n);
+		const base = {
+			timeUnixNano,
+			observedTimeUnixNano: timeUnixNano,
+			severityNumber: LOG_LEVEL_TO_SEVERITY_NUMBER[record.level],
+			severityText: record.severityText,
+			body: { stringValue: record.msg }
+		};
+		const attributes = collectAttributes(record);
+		if (attributes.length > 0) base.attributes = attributes;
+		if (record.traceId) base.traceId = record.traceId;
+		if (record.spanId) base.spanId = record.spanId;
+		return base;
+	}
+};
+/**
+* Quita la barra final de un endpoint si la lleva.
+*
+* @internal Compartido con {@link OtlpTraceTransport}; no es API pública.
+*/
+function stripTrailingSlash(value) {
+	return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+/**
+* Lee la ingest API key desde `process.env[name]`. Devuelve `undefined`
+* silenciosamente si `process` no está disponible (bundles estrictos de
+* browser) o si la variable no está seteada. Nunca throwea, nunca loguea
+* el valor.
+*
+* @internal Helper del constructor de {@link OtlpTransport} y
+*   {@link OtlpTraceTransport}; no es API pública.
+* @param envVarName - Nombre de la env var a leer.
+* @returns Valor de la key, o `undefined` si no está disponible.
+*/
+function readIngestKey(envVarName) {
+	if (!envVarName) return void 0;
+	if (typeof process === "undefined") return void 0;
+	const value = process.env?.[envVarName];
+	if (!value) return void 0;
+	return value;
+}
+function collectAttributes(record) {
+	const out = [];
+	if (record.prefix) out.push({
+		key: "logger.prefix",
+		value: { stringValue: record.prefix }
+	});
+	if (record.tag) out.push({
+		key: "logger.tag",
+		value: { stringValue: record.tag }
+	});
+	if (record.location) {
+		out.push({
+			key: "code.filepath",
+			value: { stringValue: record.location.file }
+		});
+		out.push({
+			key: "code.lineno",
+			value: { intValue: record.location.line }
+		});
+		if (record.location.function) out.push({
+			key: "code.function",
+			value: { stringValue: record.location.function }
+		});
+	}
+	if (record.attributes) for (const [key, value] of Object.entries(record.attributes)) {
+		const mapped = toOtlpAttribute(value);
+		if (mapped) out.push({
+			key,
+			value: mapped
+		});
+	}
+	return out;
+}
+/**
+* Convierte un valor JS a un `AnyValue` de OTel. Compartido con
+* {@link OtlpTraceTransport} para serializar attributes de span con el mismo
+* mapping.
+*
+* @internal Exportado para reuse entre transports OTLP; no es API pública.
+*/
+function toOtlpAttribute(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") return { stringValue: value };
+	if (typeof value === "number") {
+		if (Number.isInteger(value)) return { intValue: value };
+		return { doubleValue: value };
+	}
+	if (typeof value === "boolean") return { boolValue: value };
+	if (Array.isArray(value)) return { arrayValue: { values: value.map((v) => toOtlpAttribute(v)).filter((v) => v !== null) } };
+	return { stringValue: JSON.stringify(value) };
+}
+//#endregion
+//#region src/transports/OtlpTraceTransport.ts
+/**
+* Transport OTLP/HTTP para traces (spans) — POST a `<endpoint>/v1/traces`.
+*
+* Espeja {@link OtlpTransport} (que va a `/v1/logs`): hereda de
+* {@link HttpTransport} el batch, retry con backoff, buffer acotado, close
+* asincrónico y el hook on-error. Solo cambia la shape del payload y acepta
+* exclusivamente records de kind `'span'` (`accepts = ['span']`): el
+* {@link TransportManager} garantiza que jamás recibe un log record.
+*
+* @example
+* ```ts
+* logger.addTransport({
+*   target: new OtlpTraceTransport({
+*     endpoint: 'https://otelcollector.example.com:4318',
+*     serviceName: 'my-app',
+*     scopeVersion: '1.2.3'
+*   })
+* });
+*
+* await logger.span('db.query', { table: 'users' }, async () => {
+*   await db.select();
+* });
+* ```
+*/
+var OtlpTraceTransport = class extends HttpTransport {
+	name = "otlp-trace";
+	/** Este transport SOLO acepta spans — jamás recibe log records. */
+	accepts = ["span"];
+	resource;
+	scopeVersion;
+	/** Resuelto al construir. Nunca se loguea, nunca se escribe a source. */
+	ingestKeyValue;
+	constructor(options) {
+		if (!options.endpoint) throw new Error("OtlpTraceTransport: `endpoint` is required");
+		if (!options.serviceName) throw new Error("OtlpTraceTransport: `serviceName` is required");
+		const ingestKey = readIngestKey(options.ingestKeyEnvVar);
+		const httpOptions = {
+			url: `${stripTrailingSlash(options.endpoint)}/v1/traces`,
+			headers: {
+				...ingestKey ? { "signoz-ingestion-key": ingestKey } : {},
+				...options.headers ?? {}
+			},
+			batchSize: options.batchSize,
+			flushInterval: options.flushInterval,
+			maxBufferSize: options.maxBufferSize,
+			maxRetries: options.maxRetries,
+			initialBackoffMs: options.initialBackoffMs,
+			maxBackoffMs: options.maxBackoffMs,
+			fetchTimeoutMs: options.fetchTimeoutMs,
+			onError: options.onError
+		};
+		super(httpOptions);
+		this.resource = {
+			"service.name": options.serviceName,
+			...options.serviceVersion ? { "service.version": options.serviceVersion } : {},
+			...options.environment ? { "deployment.environment": options.environment } : {},
+			...options.resourceAttributes ?? {}
+		};
+		this.scopeVersion = options.scopeVersion;
+		this.ingestKeyValue = ingestKey;
+	}
+	/**
+	* Construye el payload JSON OTLP/HTTP a partir de los spans bufferizados.
+	* Un bloque `resourceSpans` por batch. Expuesto para tests y subclasses.
+	*
+	* @param spans - Spans a serializar dentro del payload.
+	* @returns Objeto `TracesData` listo para `JSON.stringify`.
+	*/
+	buildPayload(spans) {
+		return { resourceSpans: [{
+			resource: { attributes: Object.entries(this.resource).filter((entry) => typeof entry[1] === "string").map(([key, value]) => ({
+				key,
+				value: { stringValue: value }
+			})) },
+			scopeSpans: [{
+				scope: {
+					name: "better-logger",
+					...this.scopeVersion ? { version: this.scopeVersion } : {}
+				},
+				spans: spans.map((s) => this.toOtlpSpan(s))
+			}]
+		}] };
+	}
+	/**
+	* Serializa un batch al body JSON del request OTLP/HTTP. Override de
+	* {@link HttpTransport.serializeBody}.
+	*/
+	serializeBody(records) {
+		return JSON.stringify(this.buildPayload(records));
+	}
+	/**
+	* Construye los headers del request. Agrega `signoz-ingestion-key` con el
+	* valor resuelto al construir.
+	*/
+	buildHeaders() {
+		return {
+			"Content-Type": "application/json",
+			...this.ingestKeyValue ? { "signoz-ingestion-key": this.ingestKeyValue } : {},
+			...this.options.headers ?? {}
+		};
+	}
+	toOtlpSpan(span) {
+		const attributes = [{
+			key: "logger.scope",
+			value: { stringValue: span.scope }
+		}];
+		for (const [key, value] of Object.entries(span.attributes)) {
+			const mapped = toOtlpAttribute(value);
+			if (mapped) attributes.push({
+				key,
+				value: mapped
+			});
+		}
+		if (span.incomplete) attributes.push({
+			key: "span.incomplete",
+			value: { boolValue: true }
+		});
+		const out = {
+			traceId: span.traceId,
+			spanId: span.spanId,
+			...span.parentSpanId ? { parentSpanId: span.parentSpanId } : {},
+			name: span.name,
+			kind: span.spanKind,
+			startTimeUnixNano: span.startTimeUnixNano,
+			endTimeUnixNano: span.endTimeUnixNano,
+			attributes
+		};
+		if (span.status) out.status = span.status;
+		return out;
+	}
+};
+//#endregion
+//#region src/transports/TransportManager.ts
+/**
+* Genera un id opaco y estable en el tiempo para cada transport añadido al
+* manager. Combina timestamp (base36) con un sufijo aleatorio para evitar
+* colisiones entre adds casi simultáneos.
+*
+* @internal No es API pública — el formato del id es inestable y los callers
+*   deben tratarlo como opaco (solo compararlo y pasárselo a `remove`).
+*/
+function generateTransportId() {
+	return `transport-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+* Registry estático de los transports built-in, con el que se inicializa el
+* registry vivo de cada instancia de {@link TransportManager}. Los customs
+* se añaden al registry por-instancia vía {@link TransportManager.register}
+* (no a este Map módulo-nivel).
+*
+* Los cinco built-ins registrados automáticamente:
+*   - `'console'`     → {@link ConsoleTransport} (logs)
+*   - `'file'`        → {@link FileTransport} (logs)
+*   - `'http'`        → {@link HttpTransport} (logs)
+*   - `'otlp'`        → {@link OtlpTransport} (logs → `/v1/logs`)
+*   - `'otlp-trace'`  → {@link OtlpTraceTransport} (spans → `/v1/traces`)
+*
+* @internal No exportado — los callers externos usan
+*   {@link TransportManager.register} / {@link TransportManager.listRegistered}.
+*/
+const BUILTIN_REGISTRY = /* @__PURE__ */ new Map([
+	["console", ConsoleTransport],
+	["file", FileTransport],
+	["http", HttpTransport],
+	["otlp", OtlpTransport],
+	["otlp-trace", OtlpTraceTransport]
+]);
+/** `accepts` efectivo cuando el transport no lo declara: log-only. */
+const DEFAULT_ACCEPTS = ["log"];
+/** Estrecha un record del pipeline a su kind: todo lo que no es span es log. */
+function recordKind(record) {
+	return record.kind === "span" ? "span" : "log";
+}
+/**
+* Registry y dispatcher de transports. Mantiene el set activo de destinos
+* de log (console, file, http, otlp, o transports custom registrados vía
+* {@link TransportManager.register}) y les dispatcha cada
+* {@link TransportRecord} producido por el Logger.
+*
+* Cada transport added se identifica por un `id` opaco (generado por la
+* propia instancia) que devuelven {@link add} y {@link list}, y que acepta
+* {@link remove}. El registry arranca con los cuatro built-ins
+* (`console` / `file` / `http` / `otlp`) ya cargados; {@link register}
+* añade customs sin poder sobreescribir los built-ins (lanza).
+*
+* El dispatch ({@link write}) aplica el filtro de `level` por transport y
+* el `transform` opcional de {@link TransportOptions}, y captura toda
+* excepción / rechazo de cada transport para que un transport roto nunca
+* rompa el log call del caller. El propio Logger habla con el manager a
+* través del facade {@link TransportBridge} (ver
+* `Logger.addTransport` / `Logger.getTransportManager`).
+*
+* Implementa {@link ITransportManager}.
+*
+* @example
+* // Manager con nivel default y transports añadidos por nombre
+* const tm = new TransportManager('info');
+* tm.add({ target: 'console' });
+* tm.add({ target: 'file', options: { path: './app.log' } });
+*
+* @example
+* // Registrar un transport custom y usarlo por nombre
+* tm.register('datadog', DatadogTransport);
+* tm.add({ target: 'datadog', options: { apiKey: env('DD_KEY') } });
+*
+* @example
+* // Pasar una instancia de ITransport directamente (sin pasar por registry)
+* tm.add({ target: new MyTransport(), level: 'warn' });
+*
+* @example
+* // Dispatch + ciclo de vida
+* await tm.write(record);
+* await tm.flush();   // flusha todos los buffered
+* await tm.close();   // flush + close + clear
+*
+* @see {@link ITransportManager}
+* @see {@link TransportTarget}
+* @see {@link TransportBridge}
+*/
+var TransportManager = class {
+	transports = /* @__PURE__ */ new Map();
+	defaultLevel = "info";
+	registry = new Map(BUILTIN_REGISTRY);
+	/**
+	* Crea un nuevo manager.
+	*
+	* @param {LogLevel} [defaultLevel='info'] - Nivel mínimo por defecto
+	*   para transports añadidos sin `level` explícito en su
+	*   {@link TransportTarget}. Records con `levelValue` inferior al del
+	*   transport se descartan en {@link write}.
+	*
+	* @example
+	* const tm = new TransportManager('debug'); // todo pasa salvo filter propio
+	*/
+	constructor(defaultLevel) {
+		if (defaultLevel) this.defaultLevel = defaultLevel;
+	}
+	/**
+	* Registra un constructor de transport bajo un nombre string. Tras el
+	* registro, `add({ target: name, options })` instancia ese transport con
+	* las options pasadas.
+	*
+	* No se puede sobreescribir un built-in (`console` / `file` / `http` /
+	* `otlp`): lanza para evitar silenciar un transport crítico por un
+	* accidente de naming. El registro es por-instancia (no comparte entre
+	* managers).
+	*
+	* @param {string} name - Nombre bajo el que registrar (usado luego como
+	*   `target` en {@link TransportTarget}).
+	* @param {TransportConstructor} ctor - Constructor que acepta
+	*   {@link TransportOptions} y devuelve un {@link ITransport}.
+	* @throws {Error} Si `name` colisiona con un built-in del registry.
+	*
+	* @example
+	* tm.register('datadog', DatadogTransport);
+	* tm.add({ target: 'datadog', options: { apiKey: env('DD_KEY') } });
+	*
+	* @see {@link listRegistered}
+	*/
+	register(name, ctor) {
+		if (BUILTIN_REGISTRY.has(name)) throw new Error(`TransportManager.register: '${name}' is a built-in and cannot be overridden`);
+		this.registry.set(name, ctor);
+	}
+	/**
+	* Lista los nombres de transports registrados en esta instancia
+	* (built-ins + customs añadidos vía {@link register}).
+	*
+	* @returns {string[]} Nombres registrados. Incluye siempre los cuatro
+	*   built-ins.
+	*
+	* @example
+	* tm.register('loki', LokiTransport);
+	* tm.listRegistered(); // ['console', 'file', 'http', 'otlp', 'loki']
+	*/
+	listRegistered() {
+		return [...this.registry.keys()];
+	}
+	/**
+	* Añade un transport al set activo y devuelve su id opaco.
+	*
+	* Acepta dos formas de `target`:
+	*   - **string**: se resuelve contra el registry (built-ins + customs
+	*     vía {@link register}). Lanza si el nombre no existe, listando los
+	*     registrados para facilitar el debug.
+	*   - **ITransport instancia**: se registra tal cual, sin pasar por el
+	*     registry. Útil para transports one-off o cuya configuración no
+	*     encaja en un constructor reutilizable.
+	*
+	* El `level` (explícito en el target o `defaultLevel` del manager) fija
+	* el filtro por transport — los records con `levelValue` inferior se
+	* descartan en {@link write}. El `transform` opcional de
+	* {@link TransportOptions} se aplica por transport antes de delegar al
+	* `write` concreto.
+	*
+	* @param {TransportTarget} target - Especificación del transport a añadir.
+	* @returns {string} Id opaco del transport añadido. Úsalo con
+	*   {@link remove}; aparece en {@link list}.
+	* @throws {Error} Si `target.target` es un string no presente en el
+	*   registry.
+	*
+	* @example
+	* // Por nombre (built-in o custom registrado)
+	* const id = tm.add({ target: 'console' });
+	*
+	* @example
+	* // Instancia directa con nivel y transform propios
+	* const id = tm.add({
+	*   target: new MyTransport(),
+	*   level: 'warn',
+	*   options: { transform: r => r.level === 'debug' ? null : r }
+	* });
+	*
+	* @see {@link TransportTarget}
+	*/
+	add(target) {
+		const id = generateTransportId();
+		const level = target.level || this.defaultLevel;
+		let transport;
+		if (typeof target.target === "string") {
+			const ctor = this.registry.get(target.target);
+			if (!ctor) throw new Error(`TransportManager.add: unknown transport name '${target.target}'. Registered: ${this.listRegistered().join(", ")}`);
+			transport = new ctor(target.options ?? {});
+		} else transport = target.target;
+		const entry = {
+			id,
+			transport,
+			options: target.options || {},
+			level,
+			levelValue: require_core.LOG_LEVELS[level]
+		};
+		this.transports.set(id, entry);
+		return id;
+	}
+	/**
+	* Elimina un transport del set por su id. Si el transport expone
+	* `close()`, lo invoca para liberar recursos (timers, sockets, file
+	* handles). Si `close()` devuelve una Promise, su eventual rechazo se
+	* ignora de forma best-effort — los errores de close durante la
+	* remoción no se propagan al caller.
+	*
+	* @param {string} id - Id devuelto por {@link add}.
+	* @returns {boolean} `true` si había un transport con ese id (y se
+	*   eliminó), `false` si el id no existía.
+	*
+	* @example
+	* const id = tm.add({ target: 'file', options: { path: './app.log' } });
+	* tm.remove(id); // true — FileTransport.close() se invoca
+	*/
+	remove(id) {
+		const entry = this.transports.get(id);
+		if (entry) {
+			const closeResult = entry.transport.close?.();
+			if (closeResult instanceof Promise) closeResult.catch(() => {});
+			return this.transports.delete(id);
+		}
+		return false;
+	}
+	/**
+	* Dispatcha un {@link TransportRecord} o {@link SpanRecord} a todos los
+	* transports activos que acepten su kind.
+	*
+	* Por cada transport, en orden:
+	*   1. **Routing por kind**: el kind del record (`'log'` o `'span'`)
+	*      debe estar en el `accepts` del transport (default `['log']` cuando
+	*      no lo declara). Un `SpanRecord` JAMÁS llega a un transport
+	*      log-only, y viceversa — esto evita que un `OtlpTransport` serialice
+	*      spans como `logRecords` hacia `/v1/logs`.
+	*   2. **Filtro de nivel** (solo logs): si `record.levelValue <
+	*      entry.levelValue`, se skipa. Los spans no tienen nivel.
+	*   3. **Transform** (solo logs): si `entry.options.transform` está
+	*      seteado, se aplica al record. Si devuelve `null`, el record se
+	*      droppea para este transport. Los spans NO pasan por transform —
+	*      su contrato asume shape de log (muta `record.message`).
+	*   4. **Write**: se llama a `transport.write(record)`. Si
+	*      devuelve una Promise, se añade al batch await. Toda excepción
+	*      sincrónica o rechazo de Promise se captura y se loguea por
+	*      consola — el log call original del caller nunca rompe por un
+	*      transport roto.
+	*
+	* El método es async: retorna después de que todos los transports hayan
+	* resuelto (o fallado) su write. Para fire-and-forget desde el Logger,
+	* el caller puede ignorar la Promise.
+	*
+	* @param {TransportDispatchRecord} record - Record (log o span) a dispatchar.
+	* @returns {Promise<void>} Resuelve cuando todos los writes terminaron
+	*   (exitosos o fallidos). Nunca rechaza.
+	*
+	* @example
+	* await tm.write({
+	*   level: 'info', levelValue: 1, severityNumber: 9, severityText: 'INFO',
+	*   time: Date.now(), msg: 'boot ok'
+	* });
+	*
+	* @see {@link TransportRecord}
+	* @see {@link SpanRecord}
+	*/
+	async write(record) {
+		const promises = [];
+		const kind = recordKind(record);
+		for (const entry of this.transports.values()) {
+			if (!(entry.transport.accepts ?? DEFAULT_ACCEPTS).includes(kind)) continue;
+			let dispatchRecord = record;
+			if (kind === "log") {
+				const logRecord = record;
+				if (logRecord.levelValue < entry.levelValue) continue;
+				if (entry.options.transform) {
+					const result = entry.options.transform(logRecord);
+					if (result === null) continue;
+					dispatchRecord = result;
+				}
+			}
+			try {
+				const result = entry.transport.write(dispatchRecord);
+				if (result instanceof Promise) promises.push(result.catch((err) => {
+					console.error("TransportManager.write: transport failed:", err);
+				}));
+			} catch (error) {
+				console.error("TransportManager.write: transport threw synchronously:", error);
+			}
+		}
+		await Promise.all(promises);
+	}
+	/**
+	* Flushea todos los transports que expongan `flush()` (buffered transports
+	* como {@link HttpTransport}, {@link FileTransport}, {@link OtlpTransport}).
+	* Los transports sin `flush()` (p.ej. {@link ConsoleTransport}) se
+	* skipan sin error.
+	*
+	* Errores de flush (sync throw o Promise rejection) se capturan y
+	* loguean por consola — nunca propagan al caller. Útil para forzar el
+	* envío del batch pendiente antes de un graceful shutdown.
+	*
+	* @returns {Promise<void>} Resuelve cuando todos los flushes terminaron.
+	*
+	* @example
+	* await tm.flush();
+	*/
+	async flush() {
+		const promises = [];
+		for (const entry of this.transports.values()) if (entry.transport.flush) try {
+			const result = entry.transport.flush();
+			if (result instanceof Promise) promises.push(result.catch((err) => {
+				console.error("TransportManager.flush: transport failed:", err);
+			}));
+		} catch (error) {
+			console.error("TransportManager.flush: transport threw synchronously:", error);
+		}
+		await Promise.all(promises);
+	}
+	/**
+	* Shutdown ordenado: flushea todos los transports buffered, luego
+	* invoca `close()` en cada uno, y finalmente limpia el set interno.
+	* Tras esto la instancia queda sin transports — reusarla requiere
+	* `add()` de nuevo.
+	*
+	* Los errores de close (sync throw o Promise rejection) se capturan y
+	* loguean — nunca propagan al caller.
+	*
+	* @returns {Promise<void>} Resuelve cuando flush + close de todos los
+	*   transports terminaron.
+	*
+	* @example
+	* // Shutdown limpio del proceso
+	* process.on('SIGTERM', async () => {
+	*   await logger.getTransportManager()?.close();
+	*   process.exit(0);
+	* });
+	*/
+	async close() {
+		await this.flush();
+		const promises = [];
+		for (const entry of this.transports.values()) if (entry.transport.close) try {
+			const result = entry.transport.close();
+			if (result instanceof Promise) promises.push(result.catch((err) => {
+				console.error("TransportManager.close: transport failed:", err);
+			}));
+		} catch (error) {
+			console.error("TransportManager.close: transport threw synchronously:", error);
+		}
+		await Promise.all(promises);
+		this.transports.clear();
+	}
+	/**
+	* Número de transports actualmente en el set activo.
+	*
+	* @returns {number}
+	*
+	* @example
+	* if (tm.count === 0) console.warn('no transports configured');
+	*/
+	get count() {
+		return this.transports.size;
+	}
+	/**
+	* Lista los ids opacos de los transports actualmente activos.
+	*
+	* @returns {string[]} Array de ids (mismo formato opaco que devolvió
+	*   {@link add}).
+	*
+	* @example
+	* for (const id of tm.list()) {
+	*   console.log('removing transport', id);
+	*   tm.remove(id);
+	* }
+	*/
+	list() {
+		return Array.from(this.transports.keys());
+	}
+};
+//#endregion
+Object.defineProperty(exports, "ConsoleTransport", {
+	enumerable: true,
+	get: function() {
+		return ConsoleTransport;
+	}
+});
+Object.defineProperty(exports, "FileTransport", {
+	enumerable: true,
+	get: function() {
+		return FileTransport;
+	}
+});
+Object.defineProperty(exports, "HttpTransport", {
+	enumerable: true,
+	get: function() {
+		return HttpTransport;
+	}
+});
+Object.defineProperty(exports, "LOG_LEVEL_TO_SEVERITY_NUMBER", {
+	enumerable: true,
+	get: function() {
+		return LOG_LEVEL_TO_SEVERITY_NUMBER;
+	}
+});
+Object.defineProperty(exports, "LOG_LEVEL_TO_SEVERITY_TEXT", {
+	enumerable: true,
+	get: function() {
+		return LOG_LEVEL_TO_SEVERITY_TEXT;
+	}
+});
+Object.defineProperty(exports, "OtlpTraceTransport", {
+	enumerable: true,
+	get: function() {
+		return OtlpTraceTransport;
+	}
+});
+Object.defineProperty(exports, "OtlpTransport", {
+	enumerable: true,
+	get: function() {
+		return OtlpTransport;
+	}
+});
+Object.defineProperty(exports, "TransportManager", {
+	enumerable: true,
+	get: function() {
+		return TransportManager;
+	}
+});
+
+//# sourceMappingURL=transports-eCvDrc2q.cjs.map