@mks2508/better-logger 0.18.3 → 0.18.4

package/dist/chunks/transports-yK6CL0Ml.cjs

@@ -1,1278 +0,0 @@
-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 segmentos `..`, `~` o absolutas (path traversal).
-* - 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();
-		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 "app.log";
-		}
-		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;
-}
-/**
-* Rechaza rutas que escapan del working directory. Permite rutas relativas
-* bajo `cwd/`. Las rutas absolutas se rechazan a propósito — si un caller
-* necesita una ubicación absoluta, debe usar un escape hatch documentado
-* (no expuesto aquí).
-*
-* @internal
-* @param {string} input - Ruta cruda pedida por el caller.
-* @returns {string | null} Ruta saneada, o `null` si se rechaza por traversal.
-*/
-function sanitiseNodePath(input) {
-	if (!input) return null;
-	const normalised = input.replace(/\\/g, "/").trim();
-	if (normalised.length === 0) return null;
-	if (normalised.startsWith("/") || /^[a-zA-Z]:\//.test(normalised)) return null;
-	const segments = normalised.split("/").filter((s) => s.length > 0 && s !== ".");
-	if (segments.some((s) => s === ".." || s === "~")) return null;
-	return segments.join("/");
-}
-/**
-* 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;
-	}
-};
-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}; 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;
-}
-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/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 cuatro built-ins registrados automáticamente:
-*   - `'console'` → {@link ConsoleTransport}
-*   - `'file'`    → {@link FileTransport}
-*   - `'http'`    → {@link HttpTransport}
-*   - `'otlp'`    → {@link OtlpTransport}
-*
-* @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]
-]);
-/**
-* 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} a todos los transports activos
-	* que pasen el filtro de nivel.
-	*
-	* Por cada transport, en orden:
-	*   1. **Filtro de nivel**: si `record.levelValue < entry.levelValue`,
-	*      se skipa (ese transport no recibe este record).
-	*   2. **Transform**: si `entry.options.transform` está seteado, se
-	*      aplica al record. Si devuelve `null`, el record se droppea para
-	*      este transport (no para los demás).
-	*   3. **Write**: se llama a `transport.write(transformedRecord)`. 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 {TransportRecord} record - Record 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}
-	*/
-	async write(record) {
-		const promises = [];
-		for (const entry of this.transports.values()) {
-			if (record.levelValue < entry.levelValue) continue;
-			let transformedRecord = record;
-			if (entry.options.transform) {
-				const result = entry.options.transform(record);
-				if (result === null) continue;
-				transformedRecord = result;
-			}
-			try {
-				const result = entry.transport.write(transformedRecord);
-				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, "OtlpTransport", {
-	enumerable: true,
-	get: function() {
-		return OtlpTransport;
-	}
-});
-Object.defineProperty(exports, "TransportManager", {
-	enumerable: true,
-	get: function() {
-		return TransportManager;
-	}
-});
-
-//# sourceMappingURL=transports-yK6CL0Ml.cjs.map