logixia 1.12.4 → 1.12.6

package/dist/{transport.manager-ciG4r5uz.js → transport.manager-BivyUTtU.js}

@@ -1,127 +1,20 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let node_events = require("node:events");
-node_events = __toESM(node_events);
-let node_readline = require("node:readline");
-node_readline = __toESM(node_readline);
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_internal_log = require('./internal-log-BUJYMZbE.js');
+const require_safe_stringify = require('./safe-stringify-DWo3aZp_.js');
+const require_coerce_utils = require('./coerce.utils-BN980Y9V.js');
 let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
+node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
-node_path = __toESM(node_path);
+node_path = require_chunk.__toESM(node_path);
+let node_events = require("node:events");
+node_events = require_chunk.__toESM(node_events);
 let node_stream_promises = require("node:stream/promises");
-node_stream_promises = __toESM(node_stream_promises);
+node_stream_promises = require_chunk.__toESM(node_stream_promises);
 let node_util = require("node:util");
-node_util = __toESM(node_util);
+node_util = require_chunk.__toESM(node_util);
 let node_zlib = require("node:zlib");
-node_zlib = __toESM(node_zlib);
-
-//#region src/utils/internal-log.ts
-/**
-* Internal logging helpers for use within the logixia library itself.
-*
-* These functions write directly to stderr/stdout without going through
-* LogixiaLogger — this avoids circular dependencies and ensures internal
-* diagnostics still surface even when the logger is misconfigured.
-*
-* Library code must NEVER call console.log/warn/error directly. Use these
-* helpers instead so that internal output can be silenced in tests by setting
-* the LOGIXIA_SILENT_INTERNAL=1 environment variable.
-*/
-/**
-* Read the silence flag on each call rather than caching it at import time, so
-* setting LOGIXIA_SILENT_INTERNAL=1 AFTER the module is first imported (e.g. in
-* a test setup file) still takes effect — the documented test-silencing
-* behavior was previously unreliable because the value was frozen at load.
-*/
-function isSilent() {
-	return process.env.LOGIXIA_SILENT_INTERNAL === "1";
-}
-/**
-* Emit an internal debug/info message to stderr.
-* Use for field-enable/disable notifications that a developer might want to see
-* during development but should not appear in production log streams.
-*/
-function internalLog(message) {
-	if (!isSilent()) process.stderr.write(`[logixia] ${message}\n`);
-}
-/**
-* Emit an internal warning to stderr.
-* Use when something is misconfigured but logixia can continue operating.
-*/
-function internalWarn(message) {
-	if (!isSilent()) process.stderr.write(`[logixia:warn] ${message}\n`);
-}
-/**
-* Emit an internal error to stderr.
-* Use when a transport write fails or a serious internal error occurs.
-*/
-function internalError(message, error) {
-	if (!isSilent()) {
-		let errStr = "";
-		if (error instanceof Error) errStr = ` — ${error.message}`;
-		else if (error != null) errStr = ` — ${String(error)}`;
-		process.stderr.write(`[logixia:error] ${message}${errStr}\n`);
-	}
-}
+node_zlib = require_chunk.__toESM(node_zlib);
 
-//#endregion
-//#region src/utils/coerce.utils.ts
-/**
-* Defensive value coercion helpers for Logixia.
-*
-* Logger inputs come from third-party code (NestJS framework internals,
-* user payloads, error objects) where the runtime type is not always what
-* the TypeScript signature promises. The formatter / transport hot paths
-* call `.replace()` on string fields and crash if the field is anything
-* else. Use these helpers anywhere a downstream consumer assumes a string.
-*/
-/**
-* Coerce any value to a string without throwing.
-*
-* - `undefined` / `null` → `''` (so the field is rendered as empty rather
-*   than the literal string "undefined")
-* - strings → returned as-is (zero allocation on the hot path)
-* - Errors → `error.message` (matches what users would expect to see)
-* - everything else → `JSON.stringify` if possible, falling back to
-*   `String(value)` for circular refs / values without a stringifier.
-*/
-function safeToString(value) {
-	var _constructor;
-	if (typeof value === "string") return value;
-	if (value === void 0 || value === null) return "";
-	if (value instanceof Error) return value.message;
-	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
-	if (typeof value === "symbol") return value.toString();
-	if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
-	try {
-		const json = JSON.stringify(value);
-		if (json !== void 0) return json;
-	} catch {}
-	return `[${((_constructor = value.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "object"}]`;
-}
-
-//#endregion
 //#region src/transports/console.transport.ts
 /**
 * Writes log entries to stdout (info/debug/verbose) and stderr (error/warn).
@@ -154,7 +47,7 @@ var ConsoleTransport = class ConsoleTransport {
 	]);
 	static #_2 = this.CONTROL_CHARS_RE = /[\x00-\x08\x0B-\x1F\x7F-\x9F]/g;
 	static sanitize(value) {
-		return safeToString(value).replace(ConsoleTransport.CONTROL_CHARS_RE, "");
+		return require_coerce_utils.safeToString(value).replace(ConsoleTransport.CONTROL_CHARS_RE, "");
 	}
 	constructor(config = {}) {
 		this.config = config;
@@ -167,7 +60,7 @@ var ConsoleTransport = class ConsoleTransport {
 		(lvl === "error" || lvl === "warn" ? process.stderr : process.stdout).write(formatted);
 	}
 	formatEntry(entry) {
-		if (this.config.format === "json") return JSON.stringify({
+		if (this.config.format === "json") return require_safe_stringify.stringifyForLog({
 			timestamp: this.config.timestamp !== false ? entry.timestamp.toISOString() : void 0,
 			level: entry.level,
 			message: entry.message,
@@ -195,7 +88,7 @@ var ConsoleTransport = class ConsoleTransport {
 		}
 		parts.push(ConsoleTransport.sanitize(entry.message));
 		if (entry.data && Object.keys(entry.data).length > 0) {
-			const data = JSON.stringify(entry.data);
+			const data = require_safe_stringify.stringifyForLog(entry.data);
 			parts.push(this.colorize(data, "blue"));
 		}
 		return parts.join(" ");
@@ -230,6 +123,15 @@ var ConsoleTransport = class ConsoleTransport {
 * Validates that a SQL identifier (table/index name) contains only safe characters.
 * Prevents SQL injection via user-supplied table names.
 */
+const POSTGRES_MAX_PARAMS = 65535;
+const POSTGRES_COLUMNS = 8;
+const POSTGRES_ROWS_PER_INSERT = Math.floor(POSTGRES_MAX_PARAMS / POSTGRES_COLUMNS);
+const MYSQL_ROWS_PER_INSERT = 5e3;
+function chunk(items, size) {
+	const chunks = [];
+	for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
+	return chunks;
+}
 function validateSqlIdentifier(name, label = "table") {
 	if (!/^[a-zA-Z_]\w*$/.test(name)) throw new Error(`Invalid ${label} name "${name}". Only letters, digits, and underscores are allowed, and the name must start with a letter or underscore.`);
 }
@@ -300,7 +202,7 @@ var DatabaseTransport = class {
 					default: throw new Error(`Unsupported database type: ${this.config.type}`);
 				}
 			} catch (error) {
-				internalError("Database flush error", error);
+				require_internal_log.internalError("Database flush error", error);
 				this.batch.unshift(...entriesToFlush);
 				throw error;
 			}
@@ -431,22 +333,38 @@ var DatabaseTransport = class {
 	}
 	async flushToPostgreSQL(entries) {
 		const tableName = this.config.table || "logs";
-		const values = entries.map((entry) => [
+		const chunks = chunk(entries.map((entry) => [
 			entry.timestamp,
 			entry.level,
 			entry.message,
-			JSON.stringify(entry.data || {}),
+			require_safe_stringify.stringifyForLog(entry.data || {}),
 			entry.context,
 			entry.traceId,
 			entry.appName,
 			entry.environment
-		]);
-		const query = `
+		]), POSTGRES_ROWS_PER_INSERT);
+		const insertChunk = async (rows) => {
+			const query = `
       INSERT INTO ${tableName} 
       (timestamp, level, message, payload, context, trace_id, app_name, environment)
-      VALUES ${values.map((_, i) => `($${i * 8 + 1}, $${i * 8 + 2}, $${i * 8 + 3}, $${i * 8 + 4}, $${i * 8 + 5}, $${i * 8 + 6}, $${i * 8 + 7}, $${i * 8 + 8})`).join(", ")}
+      VALUES ${rows.map((_, i) => {
+				return `(${Array.from({ length: POSTGRES_COLUMNS }, (_unused, c) => `$${i * POSTGRES_COLUMNS + c + 1}`).join(", ")})`;
+			}).join(", ")}
     `;
-		await this.connection.query(query, values.flat());
+			await this.connection.query(query, rows.flat());
+		};
+		if (chunks.length === 1) {
+			await insertChunk(chunks[0]);
+			return;
+		}
+		await this.connection.query("BEGIN");
+		try {
+			for (const rows of chunks) await insertChunk(rows);
+			await this.connection.query("COMMIT");
+		} catch (error) {
+			await this.connection.query("ROLLBACK").catch(() => {});
+			throw error;
+		}
 	}
 	async flushToMySQL(entries) {
 		const tableName = this.config.table || "logs";
@@ -454,7 +372,7 @@ var DatabaseTransport = class {
 			entry.timestamp,
 			entry.level,
 			entry.message,
-			JSON.stringify(entry.data || {}),
+			require_safe_stringify.stringifyForLog(entry.data || {}),
 			entry.context,
 			entry.traceId,
 			entry.appName,
@@ -465,7 +383,19 @@ var DatabaseTransport = class {
       (timestamp, level, message, payload, context, trace_id, app_name, environment)
       VALUES ?
     `;
-		await this.connection.query(query, [values]);
+		const chunks = chunk(values, MYSQL_ROWS_PER_INSERT);
+		if (chunks.length === 1) {
+			await this.connection.query(query, [values]);
+			return;
+		}
+		await this.connection.beginTransaction();
+		try {
+			for (const rows of chunks) await this.connection.query(query, [rows]);
+			await this.connection.commit();
+		} catch (error) {
+			await this.connection.rollback().catch(() => {});
+			throw error;
+		}
 	}
 	async flushToSQLite(entries) {
 		const tableName = this.config.table || "logs";
@@ -474,8 +404,16 @@ var DatabaseTransport = class {
       (timestamp, level, message, payload, context, trace_id, app_name, environment)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `);
-		for (const entry of entries) await stmt.run(entry.timestamp instanceof Date ? entry.timestamp.toISOString() : entry.timestamp, entry.level, entry.message, JSON.stringify(entry.data || {}), entry.context, entry.traceId, entry.appName, entry.environment);
-		await stmt.finalize();
+		await this.connection.exec("BEGIN");
+		try {
+			for (const entry of entries) await stmt.run(entry.timestamp instanceof Date ? entry.timestamp.toISOString() : entry.timestamp, entry.level, entry.message, require_safe_stringify.stringifyForLog(entry.data || {}), entry.context, entry.traceId, entry.appName, entry.environment);
+			await this.connection.exec("COMMIT");
+		} catch (error) {
+			await this.connection.exec("ROLLBACK").catch(() => {});
+			throw error;
+		} finally {
+			await stmt.finalize().catch(() => {});
+		}
 	}
 	async createPostgreSQLTable() {
 		const tableName = this.config.table || "logs";
@@ -543,11 +481,13 @@ var DatabaseTransport = class {
 		await this.connection.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_trace_id ON ${tableName} (trace_id)`);
 	}
 	setupFlushTimer() {
+		var _this$flushTimer$unre, _this$flushTimer;
 		this.flushTimer = setInterval(() => {
 			this.flush().catch((error) => {
-				internalError("Scheduled database flush error", error);
+				require_internal_log.internalError("Scheduled database flush error", error);
 			});
 		}, this.flushInterval);
+		(_this$flushTimer$unre = (_this$flushTimer = this.flushTimer).unref) === null || _this$flushTimer$unre === void 0 || _this$flushTimer$unre.call(_this$flushTimer);
 	}
 	async close() {
 		if (this.flushTimer) {
@@ -555,12 +495,13 @@ var DatabaseTransport = class {
 			this.flushTimer = void 0;
 		}
 		const MAX_CLOSE_FLUSH_ATTEMPTS = 3;
+		if (this.flushPromise) await this.flushPromise.catch(() => {});
 		for (let attempt = 0; attempt < MAX_CLOSE_FLUSH_ATTEMPTS && this.batch.length > 0; attempt += 1) try {
 			await this.flush();
 		} catch (error) {
-			internalError("Database flush during close failed; entries remain buffered", error);
+			require_internal_log.internalError("Database flush during close failed; entries remain buffered", error);
 		}
-		if (this.batch.length > 0) internalError(`Database transport closing with ${this.batch.length} unflushed log entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
+		if (this.batch.length > 0) require_internal_log.internalError(`Database transport closing with ${this.batch.length} unflushed log entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
 		if (this.connection) switch (this.config.type) {
 			case "mongodb":
 				await this.connection.close();
@@ -590,14 +531,22 @@ var DatabaseTransport = class {
 		try {
 			switch (this.config.type) {
 				case "mongodb": return await this.connection.db(this.config.database).collection(this.config.collection || "logs").countDocuments();
-				case "postgresql":
-				case "mysql":
-				case "sqlite": {
-					var _result$rows, _result$;
+				case "postgresql": {
+					var _result$rows;
 					const tableName = this.config.table || "logs";
 					const result = await this.connection.query(`SELECT COUNT(*) as count FROM ${tableName}`);
-					const rawCount = ((_result$rows = result.rows) === null || _result$rows === void 0 || (_result$rows = _result$rows[0]) === null || _result$rows === void 0 ? void 0 : _result$rows.count) ?? ((_result$ = result[0]) === null || _result$ === void 0 ? void 0 : _result$.count) ?? 0;
-					return Number(rawCount) || 0;
+					return Number((_result$rows = result.rows) === null || _result$rows === void 0 || (_result$rows = _result$rows[0]) === null || _result$rows === void 0 ? void 0 : _result$rows.count) || 0;
+				}
+				case "mysql": {
+					var _rows$;
+					const tableName = this.config.table || "logs";
+					const [rows] = await this.connection.query(`SELECT COUNT(*) as count FROM ${tableName}`);
+					return Number(rows === null || rows === void 0 || (_rows$ = rows[0]) === null || _rows$ === void 0 ? void 0 : _rows$.count) || 0;
+				}
+				case "sqlite": {
+					const tableName = this.config.table || "logs";
+					const row = await this.connection.get(`SELECT COUNT(*) as count FROM ${tableName}`);
+					return Number(row === null || row === void 0 ? void 0 : row.count) || 0;
 				}
 				default: return 0;
 			}
@@ -624,20 +573,23 @@ var AnalyticsTransport = class {
 		this.level = config.level;
 		this.batchSize = this.config.batchSize || 50;
 		this.flushInterval = this.config.flushInterval || 1e4;
-		this.initialize();
 	}
 	async write(entry) {
-		if (!this.isReady) await this.waitForReady();
+		if (!this.isReady) await this.ensureReady();
 		if (this.shouldSkipEntry(entry)) return;
 		if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(entry);
 		else await this.sendEntry(entry);
 	}
 	addToBatch(entry) {
 		this.batch.push(entry);
-		if (this.batch.length >= (this.config.batchSize || 50)) this.flush().catch((err) => internalError(`${this.name} batch flush failed`, err));
-		else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
-			this.flush().catch((err) => internalError(`${this.name} interval flush failed`, err));
-		}, this.config.flushInterval);
+		if (this.batch.length >= (this.config.batchSize || 50)) this.flush().catch((err) => require_internal_log.internalError(`${this.name} batch flush failed`, err));
+		else if (!this.batchTimer && this.config.flushInterval) {
+			var _this$batchTimer$unre, _this$batchTimer;
+			this.batchTimer = setTimeout(() => {
+				this.flush().catch((err) => require_internal_log.internalError(`${this.name} interval flush failed`, err));
+			}, this.config.flushInterval);
+			(_this$batchTimer$unre = (_this$batchTimer = this.batchTimer).unref) === null || _this$batchTimer$unre === void 0 || _this$batchTimer$unre.call(_this$batchTimer);
+		}
 	}
 	async flush() {
 		if (this.batchTimer) {
@@ -663,7 +615,7 @@ var AnalyticsTransport = class {
 			try {
 				await this.sendBatch(entriesToSend);
 			} catch (error) {
-				internalError(`Analytics transport ${this.name} flush failed`, error);
+				require_internal_log.internalError(`Analytics transport ${this.name} flush failed`, error);
 				this.batch.unshift(...entriesToSend);
 				return;
 			}
@@ -676,7 +628,7 @@ var AnalyticsTransport = class {
 		}
 		const MAX_CLOSE_FLUSH_ATTEMPTS = 3;
 		for (let attempt = 0; attempt < MAX_CLOSE_FLUSH_ATTEMPTS && this.batch.length > 0; attempt += 1) await this.flush();
-		if (this.batch.length > 0) internalError(`Analytics transport ${this.name} closing with ${this.batch.length} unflushed entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
+		if (this.batch.length > 0) require_internal_log.internalError(`Analytics transport ${this.name} closing with ${this.batch.length} unflushed entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
 		await this.cleanup();
 	}
 	shouldSkipEntry(entry) {
@@ -696,10 +648,20 @@ var AnalyticsTransport = class {
 		if (this.config.customProperties) Object.assign(transformed, this.config.customProperties);
 		return transformed;
 	}
-	async waitForReady(timeout = 5e3) {
-		const startTime = Date.now();
-		while (!this.isReady && Date.now() - startTime < timeout) await new Promise((resolve) => setTimeout(resolve, 100));
-		if (!this.isReady) throw new Error(`Analytics transport ${this.name} failed to initialize within ${timeout}ms`);
+	/**
+	* Runs initialize() once. A bad config (say, a missing API key) fails every
+	* write with the same error instead of an unhandled rejection at startup.
+	*/
+	ensureReady() {
+		this.initPromise ??= (async () => {
+			await this.initialize();
+			this.isReady = true;
+		})();
+		return this.initPromise;
+	}
+	/** @deprecated Use ensureReady(); kept for subclasses that call it. */
+	async waitForReady() {
+		await this.ensureReady();
 	}
 };
 
@@ -725,10 +687,9 @@ var DataDogTransport = class extends AnalyticsTransport {
 	async initialize() {
 		try {
 			if (!this.datadogConfig.apiKey) throw new Error("DataDog API key is required");
-			await this.testConnection();
 			this.isReady = true;
 		} catch (error) {
-			internalError("DataDog transport initialization failed", error);
+			require_internal_log.internalError("DataDog transport initialization failed", error);
 			throw error;
 		}
 	}
@@ -776,11 +737,11 @@ var DataDogTransport = class extends AnalyticsTransport {
 			timestamp: entry.timestamp.toISOString(),
 			level: this.mapLogLevel(entry.level),
 			message: entry.message,
-			service: this.datadogConfig.service || "logitron",
+			service: this.datadogConfig.service || "logixia",
 			version: this.datadogConfig.version,
 			env: this.datadogConfig.env || "production",
 			logger: {
-				name: "logitron",
+				name: "logixia",
 				thread_name: "main"
 			},
 			...transformed,
@@ -798,7 +759,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 			host: this.getHostname(),
 			tags: [
 				`level:${entry.level}`,
-				`service:${this.datadogConfig.service || "logitron"}`,
+				`service:${this.datadogConfig.service || "logixia"}`,
 				`env:${this.datadogConfig.env || "production"}`,
 				...entry.context ? [`context:${entry.context}`] : [],
 				...entry.appName ? [`app:${entry.appName}`] : []
@@ -811,7 +772,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 			span_id: this.generateSpanId(),
 			parent_id: null,
 			name: "log.entry",
-			service: this.datadogConfig.service || "logitron",
+			service: this.datadogConfig.service || "logixia",
 			resource: entry.message,
 			type: "log",
 			start: entry.timestamp.getTime() * 1e6,
@@ -848,7 +809,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 					"Content-Type": "application/json",
 					"DD-API-KEY": this.datadogConfig.apiKey
 				},
-				body: JSON.stringify(data)
+				body: require_safe_stringify.stringifyForLog(data)
 			});
 			if (!response.ok) throw new Error(`DataDog Logs API error: ${response.status} ${response.statusText}`);
 		} catch (error) {
@@ -864,23 +825,13 @@ var DataDogTransport = class extends AnalyticsTransport {
 					"Content-Type": "application/json",
 					"DD-API-KEY": this.datadogConfig.apiKey
 				},
-				body: JSON.stringify(data)
+				body: require_safe_stringify.stringifyForLog(data)
 			});
 			if (!response.ok) throw new Error(`DataDog Metrics API error: ${response.status} ${response.statusText}`);
 		} catch (error) {
 			throw new Error(`Failed to send metrics to DataDog: ${error.message}`, { cause: error });
 		}
 	}
-	async testConnection() {
-		const testMetric = { series: [{
-			metric: "logitron.test",
-			points: [[Math.floor(Date.now() / 1e3), 1]],
-			type: "count",
-			host: this.getHostname(),
-			tags: ["test:true"]
-		}] };
-		await this.makeMetricsRequest("/api/v1/series", testMetric);
-	}
 	generateSpanId() {
 		return Math.floor(Math.random() * 0xffffffffffff).toString(16);
 	}
@@ -908,11 +859,11 @@ var DataDogTransport = class extends AnalyticsTransport {
 			date_happened: Math.floor(Date.now() / 1e3),
 			priority: "normal",
 			tags: [
-				`service:${this.datadogConfig.service || "logitron"}`,
+				`service:${this.datadogConfig.service || "logixia"}`,
 				`env:${this.datadogConfig.env || "production"}`,
 				...tags
 			],
-			source_type_name: "logitron"
+			source_type_name: "logixia"
 		};
 		const url = `${this.baseUrl}/api/v1/events`;
 		try {
@@ -922,7 +873,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 					"Content-Type": "application/json",
 					"DD-API-KEY": this.datadogConfig.apiKey
 				},
-				body: JSON.stringify(payload)
+				body: require_safe_stringify.stringifyForLog(payload)
 			});
 			if (!response.ok) throw new Error(`DataDog Events API error: ${response.status} ${response.statusText}`);
 		} catch (error) {
@@ -933,16 +884,46 @@ var DataDogTransport = class extends AnalyticsTransport {
 
 //#endregion
 //#region src/transports/file.transport.ts
-const writeFile = (0, node_util.promisify)(node_fs.writeFile);
-const mkdir = (0, node_util.promisify)(node_fs.mkdir);
+const appendFile = (0, node_util.promisify)(node_fs.appendFile);
+const rename = (0, node_util.promisify)(node_fs.rename);
 const unlink = (0, node_util.promisify)(node_fs.unlink);
 const readdir = (0, node_util.promisify)(node_fs.readdir);
 const stat = (0, node_util.promisify)(node_fs.stat);
+const DROP_WARN_INTERVAL_MS = 5e3;
+const SIZE_UNITS = {
+	"": 1,
+	k: 1024,
+	m: 1024 ** 2,
+	g: 1024 ** 3,
+	t: 1024 ** 4
+};
+/**
+* Parses a size like `50MB`, `1.5g`, `512 KiB` or a plain byte count.
+* Units are binary (1KB = 1024 bytes). Returns undefined for anything else.
+*/
+function parseSize(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+	const match = /^(\d+(?:\.\d+)?) ?([kmgt]?)(?:i?b)?$/i.exec(value.trim());
+	if (!match) return void 0;
+	const bytes = Math.floor(Number(match[1]) * (SIZE_UNITS[(match[2] ?? "").toLowerCase()] ?? 1));
+	return bytes > 0 ? bytes : void 0;
+}
+/** Formats a date with the YYYY, MM, DD, HH, mm and ss tokens, in local time. */
+function formatDatePattern(date, pattern) {
+	const pad = (n) => String(n).padStart(2, "0");
+	return pattern.replace(/YYYY/g, String(date.getFullYear())).replace(/MM/g, pad(date.getMonth() + 1)).replace(/DD/g, pad(date.getDate())).replace(/HH/g, pad(date.getHours())).replace(/mm/g, pad(date.getMinutes())).replace(/ss/g, pad(date.getSeconds()));
+}
 /**
 * Appends log entries to a local file with automatic rotation.
 *
-* Supports batched writes, size-based and date-based rotation, and optional
-* gzip compression of rotated files.
+* Rotates by size (`maxSize`), by date (`datePattern`), by interval
+* (`rotation.interval`) or by a custom `rotation.shouldRotate` check. Rotated
+* files can be gzipped (`zippedArchive`) and pruned to the newest `maxFiles`.
+*
+* Without a `rotation` block the live file keeps its name (`app.log`) and
+* rotated files are renamed beside it (`app-2026-10-22T09-30-00-000.log`).
+* With a `rotation` block every file, the live one included, is timestamped.
 *
 * @example
 * transports: { file: { filename: 'app.log', dirname: './logs', maxSize: '50MB' } }
@@ -952,7 +933,17 @@ var FileTransport = class {
 		this.name = "file";
 		this.batch = [];
 		this.lastRotation = /* @__PURE__ */ new Date();
-		this.isRotating = false;
+		this.bytesWritten = 0;
+		this.rotateRequested = false;
+		this.rotationWaiters = [];
+		this.enqueued = 0;
+		this.settled = 0;
+		this.flushWaiters = [];
+		this.spaceWaiters = [];
+		this.inFlight = 0;
+		this.dropped = 0;
+		this.lastDropWarning = 0;
+		this.housekeeping = Promise.resolve();
 		this.config = {
 			format: "json",
 			batchSize: 100,
@@ -963,100 +954,257 @@ var FileTransport = class {
 		this.batchSize = this.config.batchSize || 100;
 		this.flushInterval = this.config.flushInterval || 5e3;
 		if (config.filter) this.filter = config.filter;
-		this.currentFilePath = this.generateFilePath();
-		this.ensureDirectoryExists();
+		const rotation = config.rotation;
+		const rawMaxSize = (rotation === null || rotation === void 0 ? void 0 : rotation.maxSize) ?? config.maxSize;
+		this.maxBytes = parseSize(rawMaxSize);
+		if (rawMaxSize !== void 0 && this.maxBytes === void 0) require_internal_log.internalWarn(`FileTransport: maxSize ${JSON.stringify(rawMaxSize)} is not a valid size (try '50MB'); size rotation is off`);
+		const maxQueue = config.maxQueue;
+		if (maxQueue !== void 0 && !(Number.isInteger(maxQueue) && maxQueue > 0)) require_internal_log.internalWarn(`FileTransport: maxQueue ${String(maxQueue)} is not a positive integer; ignored`);
+		else this.maxQueue = maxQueue;
+		this.queuePolicy = config.queuePolicy ?? "drop-oldest";
+		this.maxFiles = (rotation === null || rotation === void 0 ? void 0 : rotation.maxFiles) ?? config.maxFiles;
+		this.compress = (rotation === null || rotation === void 0 ? void 0 : rotation.compress) ?? config.zippedArchive ?? false;
+		this.intervalMs = (rotation === null || rotation === void 0 ? void 0 : rotation.interval) ? this.parseInterval(rotation.interval) : void 0;
+		this.timestampedActive = rotation !== void 0;
+		this.dir = this.resolveDir();
+		this.ext = node_path.extname(config.filename);
+		this.base = node_path.basename(config.filename, this.ext);
+		try {
+			node_fs.mkdirSync(this.dir, { recursive: true });
+		} catch (error) {
+			require_internal_log.internalError(`FileTransport could not create ${this.dir}`, error);
+		}
+		this.currentFilePath = this.timestampedActive ? this.uniquePath(this.timestamp(/* @__PURE__ */ new Date())) : node_path.join(this.dir, `${this.base}${this.ext}`);
+		let existing;
+		try {
+			existing = node_fs.statSync(this.currentFilePath);
+		} catch {
+			existing = void 0;
+		}
+		this.bytesWritten = (existing === null || existing === void 0 ? void 0 : existing.size) ?? 0;
+		if (config.datePattern) this.period = formatDatePattern((existing === null || existing === void 0 ? void 0 : existing.mtime) ?? /* @__PURE__ */ new Date(), config.datePattern);
 	}
 	async write(entry) {
 		try {
-			if (this.shouldRotateNow() && !this.isRotating) {
-				this.isRotating = true;
-				try {
-					await this.rotate();
-				} finally {
-					this.isRotating = false;
-				}
-			}
+			while (this.queuePolicy === "block" && this.queueFull()) await this.roomAvailable();
 			if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(entry);
-			else await this.writeBatch([entry]);
+			else {
+				this.enqueue(entry);
+				await this.flush();
+			}
 		} catch (error) {
 			throw new Error(`File transport write failed: ${error.message}`, { cause: error });
 		}
 	}
+	/**
+	* Resolves once every entry queued before the call is on disk. It does not
+	* wait for entries queued afterwards, so under steady traffic it still returns
+	* instead of waiting for a quiet moment that never comes.
+	*/
 	async flush() {
 		if (this.batchTimer) {
 			clearTimeout(this.batchTimer);
 			this.batchTimer = void 0;
 		}
-		if (!this.flushPromise) this.flushPromise = this.drain().finally(() => {
-			this.flushPromise = void 0;
+		if (this.settled >= this.enqueued) return;
+		const done = new Promise((resolve, reject) => {
+			this.flushWaiters.push({
+				upTo: this.enqueued,
+				resolve,
+				reject
+			});
+		});
+		this.startDrain();
+		await done;
+	}
+	/** Writes out anything pending, then starts a new file. */
+	async rotate() {
+		await this.flush();
+		const done = new Promise((resolve) => this.rotationWaiters.push(resolve));
+		this.rotateRequested = true;
+		this.startDrain();
+		await done;
+	}
+	enqueue(entry) {
+		if (this.queueFull()) {
+			if (this.queuePolicy === "drop-oldest" && this.batch.length > 0) {
+				this.batch.shift();
+				this.batch.push(entry);
+			}
+			this.noteDropped();
+			return;
+		}
+		this.batch.push(entry);
+		this.enqueued += 1;
+	}
+	queueFull() {
+		return this.maxQueue !== void 0 && this.batch.length + this.inFlight >= this.maxQueue;
+	}
+	roomAvailable() {
+		const room = new Promise((resolve) => this.spaceWaiters.push(resolve));
+		this.startDrain();
+		return room;
+	}
+	releaseWaiters() {
+		const waiting = this.spaceWaiters;
+		this.spaceWaiters = [];
+		for (const resolve of waiting) resolve();
+	}
+	noteDropped() {
+		this.dropped += 1;
+		this.reportDropped(DROP_WARN_INTERVAL_MS);
+	}
+	reportDropped(minGapMs) {
+		const now = Date.now();
+		if (this.dropped === 0 || now - this.lastDropWarning < minGapMs) return;
+		require_internal_log.internalWarn(`FileTransport: dropped ${this.dropped} log line${this.dropped === 1 ? "" : "s"} (queue full at maxQueue ${this.maxQueue}, policy ${this.queuePolicy})`);
+		this.dropped = 0;
+		this.lastDropWarning = now;
+	}
+	startDrain() {
+		if (this.draining) return;
+		this.draining = this.drain().finally(() => {
+			this.draining = void 0;
 		});
-		await this.flushPromise;
 	}
 	/**
-	* Drains the batch to disk one snapshot at a time. Entries appended while a
-	* write is in flight are picked up by the next loop iteration, so a single
-	* drain() empties the batch completely regardless of concurrent writes.
+	* Writes the batch one snapshot at a time. Entries queued while a write is in
+	* flight are picked up by the next iteration, so one drain empties the batch
+	* however much is logged meanwhile.
 	*/
 	async drain() {
-		while (this.batch.length > 0) {
+		while (this.batch.length > 0 || this.rotateRequested) {
+			if (this.rotateRequested) {
+				this.rotateRequested = false;
+				const waiting = this.rotationWaiters;
+				this.rotationWaiters = [];
+				try {
+					await this.rotateFile();
+				} catch (error) {
+					require_internal_log.internalError("FileTransport rotation failed", error);
+				}
+				for (const resolve of waiting) resolve();
+				continue;
+			}
 			const pending = this.batch;
 			this.batch = [];
-			await this.writeBatch(pending);
+			this.inFlight = pending.length;
+			let failure;
+			try {
+				await this.writeBatch(pending);
+			} catch (error) {
+				failure = error;
+			}
+			this.inFlight = 0;
+			this.settled += pending.length;
+			this.settle(failure);
+			this.releaseWaiters();
 		}
 	}
+	/**
+	* Resolves the flush() calls whose entries are now written. A failed batch
+	* fails every flush still waiting, since each one covers that batch.
+	*/
+	settle(failure) {
+		if (failure !== void 0) {
+			if (this.flushWaiters.length === 0) require_internal_log.internalError("FileTransport write failed", failure);
+			for (const waiter of this.flushWaiters) waiter.error ??= failure;
+		}
+		const waiting = [];
+		for (const waiter of this.flushWaiters) if (waiter.upTo > this.settled) waiting.push(waiter);
+		else if (waiter.error === void 0) waiter.resolve();
+		else waiter.reject(waiter.error);
+		this.flushWaiters = waiting;
+	}
 	formatEntry(entry) {
 		switch (this.config.format) {
-			case "json": return JSON.stringify({
+			case "json": return require_safe_stringify.stringifyForLog({
 				timestamp: entry.timestamp.toISOString(),
 				level: entry.level,
 				message: entry.message,
 				...entry.data || {}
 			});
 			case "csv": {
-				const safeMessage = safeToString(entry.message);
+				const safeMessage = require_coerce_utils.safeToString(entry.message);
 				return [
 					entry.timestamp.toISOString(),
 					entry.level,
 					`"${safeMessage.replace(/"/g, "\"\"")}"`,
-					safeToString(entry.context),
-					safeToString(entry.traceId),
-					JSON.stringify(entry.data || {})
+					require_coerce_utils.safeToString(entry.context),
+					require_coerce_utils.safeToString(entry.traceId),
+					require_safe_stringify.stringifyForLog(entry.data || {})
 				].join(",");
 			}
 			case "text":
-			default: return `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${safeToString(entry.message)}${entry.data ? " " + JSON.stringify(entry.data) : ""}`;
+			default: return `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${require_coerce_utils.safeToString(entry.message)}${entry.data ? " " + require_safe_stringify.stringifyForLog(entry.data) : ""}`;
 		}
 	}
 	addToBatch(entry) {
-		this.batch.push(entry);
-		if (this.batch.length >= (this.config.batchSize || 100)) {
+		this.enqueue(entry);
+		const threshold = Math.min(this.config.batchSize || 100, this.maxQueue ?? Infinity);
+		if (this.batch.length >= threshold && !this.draining) {
 			if (this.batchTimer) {
 				clearTimeout(this.batchTimer);
 				this.batchTimer = void 0;
 			}
-			this.flush().catch((err) => internalError("FileTransport batch flush failed", err));
+			this.startDrain();
 		} else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
-			this.flush().catch((err) => internalError("FileTransport interval flush failed", err));
+			this.flush().catch((err) => require_internal_log.internalError("FileTransport interval flush failed", err));
 		}, this.config.flushInterval);
 	}
+	/** Only ever called from drain(), so writes and rotations never overlap. */
 	async writeBatch(entries) {
 		if (entries.length === 0) return;
-		const content = entries.map((entry) => this.formatEntry(entry)).join("\n") + "\n";
-		if (this.writeStream) return new Promise((resolve, reject) => {
-			this.writeStream.write(content, (error) => {
-				if (error) reject(error);
-				else resolve();
-			});
-		});
-		else await writeFile(this.currentFilePath, content, { flag: "a" });
+		if (this.timeToRotate()) await this.rotateFile();
+		if (this.maxBytes === void 0) {
+			const content = entries.map((entry) => this.formatEntry(entry)).join("\n") + "\n";
+			await this.append(content);
+			return;
+		}
+		let chunk$1 = "";
+		let chunkBytes = 0;
+		for (const entry of entries) {
+			const line = this.formatEntry(entry) + "\n";
+			const lineBytes = Buffer.byteLength(line);
+			const used = this.bytesWritten + chunkBytes;
+			if (used > 0 && used + lineBytes > this.maxBytes) {
+				if (chunk$1) await this.append(chunk$1, chunkBytes);
+				chunk$1 = "";
+				chunkBytes = 0;
+				await this.rotateFile();
+			}
+			chunk$1 += line;
+			chunkBytes += lineBytes;
+		}
+		if (chunk$1) await this.append(chunk$1, chunkBytes);
 	}
-	shouldRotateNow() {
+	async append(content, bytes = Buffer.byteLength(content)) {
+		await appendFile(this.currentFilePath, content);
+		this.bytesWritten += bytes;
+	}
+	timeToRotate() {
 		var _this$config$rotation;
-		if (!((_this$config$rotation = this.config.rotation) === null || _this$config$rotation === void 0 ? void 0 : _this$config$rotation.interval)) return false;
-		return (/* @__PURE__ */ new Date()).getTime() - this.lastRotation.getTime() >= this.parseInterval(this.config.rotation.interval);
+		if (this.intervalMs !== void 0 && Date.now() - this.lastRotation.getTime() >= this.intervalMs) return true;
+		if (this.config.datePattern && this.period !== void 0) {
+			if (formatDatePattern(/* @__PURE__ */ new Date(), this.config.datePattern) !== this.period) return true;
+		}
+		const shouldRotate = (_this$config$rotation = this.config.rotation) === null || _this$config$rotation === void 0 ? void 0 : _this$config$rotation.shouldRotate;
+		if (shouldRotate) {
+			const stats = {
+				size: this.bytesWritten,
+				created: this.lastRotation,
+				modified: /* @__PURE__ */ new Date()
+			};
+			try {
+				return shouldRotate(this.currentFilePath, stats);
+			} catch (error) {
+				require_internal_log.internalError("FileTransport rotation.shouldRotate threw", error);
+			}
+		}
+		return false;
 	}
 	parseInterval(interval) {
-		const match = (/* @__PURE__ */ new RegExp(/(\d+)([hdwmy])/i)).exec(interval);
+		const match = /^(\d{1,6})([hdwmy])$/i.exec(interval.trim());
 		if (!match) return 1440 * 60 * 1e3;
 		const value = Number.parseInt(match[1] || "1", 10);
 		switch ((match[2] || "h").toLowerCase()) {
@@ -1068,40 +1216,54 @@ var FileTransport = class {
 			default: return value * 60 * 60 * 1e3;
 		}
 	}
-	async rotate() {
-		var _this$config$rotation2, _this$config$rotation3;
-		await this.flush();
-		if (this.writeStream) {
-			await new Promise((resolve) => {
-				this.writeStream.end(() => resolve());
-			});
-			this.writeStream = void 0;
+	async rotateFile() {
+		const now = /* @__PURE__ */ new Date();
+		let archived;
+		if (this.timestampedActive) {
+			archived = this.currentFilePath;
+			this.currentFilePath = this.uniquePath(this.timestamp(now));
+		} else {
+			archived = this.uniquePath(this.period ?? this.timestamp(now));
+			try {
+				await rename(this.currentFilePath, archived);
+			} catch (error) {
+				if (error.code !== "ENOENT") {
+					require_internal_log.internalError(`FileTransport could not rotate ${this.currentFilePath}`, error);
+					this.bytesWritten = 0;
+					return;
+				}
+				archived = void 0;
+			}
 		}
-		const oldPath = this.currentFilePath;
-		this.currentFilePath = this.generateFilePath();
-		this.lastRotation = /* @__PURE__ */ new Date();
-		if ((_this$config$rotation2 = this.config.rotation) === null || _this$config$rotation2 === void 0 ? void 0 : _this$config$rotation2.compress) await this.compressFile(oldPath);
-		if ((_this$config$rotation3 = this.config.rotation) === null || _this$config$rotation3 === void 0 ? void 0 : _this$config$rotation3.maxFiles) await this.cleanupOldFiles();
+		this.bytesWritten = 0;
+		this.lastRotation = now;
+		if (this.config.datePattern) this.period = formatDatePattern(now, this.config.datePattern);
+		if (archived === void 0 || !node_fs.existsSync(archived)) return;
+		const file = archived;
+		this.housekeeping = this.housekeeping.then(async () => {
+			if (this.compress) await this.compressFile(file);
+			if (this.maxFiles) await this.cleanupOldFiles();
+		});
+	}
+	timestamp(date) {
+		return date.toISOString().replace(/[:.]/g, "-").slice(0, 23);
+	}
+	/** `<base>-<stamp><ext>`, with `.1`, `.2`… added if that name (or its .gz) is taken. */
+	uniquePath(stamp) {
+		const taken = (p) => node_fs.existsSync(p) || node_fs.existsSync(`${p}.gz`);
+		let candidate = node_path.join(this.dir, `${this.base}-${stamp}${this.ext}`);
+		let n = 0;
+		while (taken(candidate) || candidate === this.currentFilePath) {
+			n += 1;
+			candidate = node_path.join(this.dir, `${this.base}-${stamp}.${n}${this.ext}`);
+		}
+		return candidate;
 	}
 	resolveDir() {
 		if (this.config.dirname) return this.config.dirname;
 		const fromFilename = node_path.dirname(this.config.filename);
 		return fromFilename === "." ? process.cwd() : fromFilename;
 	}
-	generateFilePath() {
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-		const dir = this.resolveDir();
-		const ext = node_path.extname(this.config.filename);
-		const base = node_path.basename(this.config.filename, ext);
-		if (this.config.rotation) return node_path.join(dir, `${base}-${timestamp}${ext}`);
-		return node_path.join(dir, `${base}${ext}`);
-	}
-	async ensureDirectoryExists() {
-		const dir = this.resolveDir();
-		try {
-			await mkdir(dir, { recursive: true });
-		} catch {}
-	}
 	/**
 	* Gzip the rotated file to `<file>.gz` and remove the original. Streams the
 	* data so large log files don't have to be buffered in memory. Best-effort:
@@ -1114,39 +1276,48 @@ var FileTransport = class {
 			await (0, node_stream_promises.pipeline)(node_fs.createReadStream(filePath), (0, node_zlib.createGzip)(), node_fs.createWriteStream(gzPath));
 			await unlink(filePath);
 		} catch (error) {
-			internalError("Failed to compress rotated log file", error);
+			require_internal_log.internalError("Failed to compress rotated log file", error);
 			try {
 				await unlink(gzPath);
 			} catch {}
 		}
 	}
+	/**
+	* True for this transport's rotated files only: `<base>-<stamp><ext>` where the
+	* stamp is digits and separators, optionally `.gz`. Another transport's
+	* `app-error.log` must not count as one of `app.log`'s rotations.
+	*/
+	isOwnRotatedFile(file) {
+		const name = file.endsWith(".gz") ? file.slice(0, -3) : file;
+		if (!name.startsWith(`${this.base}-`) || !name.endsWith(this.ext)) return false;
+		const stamp = name.slice(this.base.length + 1, name.length - this.ext.length);
+		return /^\d[\d\-_.T]*$/.test(stamp);
+	}
 	async cleanupOldFiles() {
-		var _this$config$rotation4;
-		if (!((_this$config$rotation4 = this.config.rotation) === null || _this$config$rotation4 === void 0 ? void 0 : _this$config$rotation4.maxFiles)) return;
+		if (!this.maxFiles) return;
 		try {
-			const dir = this.resolveDir();
-			const files = await readdir(dir);
-			const ext = node_path.extname(this.config.filename);
-			const base = node_path.basename(this.config.filename, ext);
-			const isOwnRotatedFile = (file) => file.startsWith(`${base}-`) && (file.endsWith(ext) || file.endsWith(`${ext}.gz`));
-			const logFiles = files.filter(isOwnRotatedFile).map(async (file) => {
-				const filePath = node_path.join(dir, file);
+			const files = await readdir(this.dir);
+			const active = node_path.basename(this.currentFilePath);
+			const newestFirst = (await Promise.all(files.filter((file) => file !== active && this.isOwnRotatedFile(file)).map(async (file) => {
+				const filePath = node_path.join(this.dir, file);
 				return {
 					path: filePath,
-					mtime: (await stat(filePath)).mtime
+					mtime: (await stat(filePath)).mtimeMs
 				};
-			});
-			const filesToDelete = (await Promise.all(logFiles)).sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(this.config.rotation.maxFiles);
-			for (const file of filesToDelete) await unlink(file.path);
+			}))).sort((a, b) => b.mtime - a.mtime || b.path.localeCompare(a.path));
+			for (const file of newestFirst.slice(this.maxFiles)) await unlink(file.path);
 		} catch (error) {
-			internalError("Failed to cleanup old log files", error);
+			require_internal_log.internalError("Failed to cleanup old log files", error);
 		}
 	}
 	async close() {
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = void 0;
+		}
 		await this.flush();
-		if (this.writeStream) return new Promise((resolve) => {
-			this.writeStream.end(() => resolve());
-		});
+		await this.housekeeping;
+		this.reportDropped(0);
 	}
 };
 
@@ -1171,10 +1342,9 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 		try {
 			if (!this.gaConfig.measurementId) throw new Error("Google Analytics Measurement ID is required");
 			if (!this.gaConfig.apiSecret) throw new Error("Google Analytics API Secret is required");
-			await this.testConnection();
 			this.isReady = true;
 		} catch (error) {
-			internalError("Google Analytics transport initialization failed", error);
+			require_internal_log.internalError("Google Analytics transport initialization failed", error);
 			throw error;
 		}
 	}
@@ -1240,10 +1410,10 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 	}
 	async sendEvents(events) {
 		const chunks = this.chunkArray(events, 25);
-		for (const chunk of chunks) {
+		for (const chunk$1 of chunks) {
 			const payload = {
 				client_id: this.gaConfig.clientId || this.generateClientId(),
-				events: chunk
+				events: chunk$1
 			};
 			await this.makeRequest(payload);
 		}
@@ -1258,7 +1428,7 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 			const response = await fetch(`${url}?${params}`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify(payload)
+				body: require_safe_stringify.stringifyForLog(payload)
 			});
 			if (!response.ok) {
 				const errorText = await response.text();
@@ -1266,28 +1436,12 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 			}
 			if (debug) {
 				const result = await response.json();
-				internalLog(`GA4 Debug Response: ${JSON.stringify(result)}`);
+				require_internal_log.internalLog(`GA4 Debug Response: ${JSON.stringify(result)}`);
 			}
 		} catch (error) {
 			throw new Error(`Failed to send data to Google Analytics: ${error.message}`, { cause: error });
 		}
 	}
-	async testConnection() {
-		const testEvent = {
-			name: "logitron_test",
-			params: {
-				event_category: "Test",
-				event_label: "Connection Test",
-				test: true,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString()
-			}
-		};
-		const payload = {
-			client_id: this.gaConfig.clientId || this.generateClientId(),
-			events: [testEvent]
-		};
-		await this.makeRequest(payload, true);
-	}
 	generateClientId() {
 		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
 			const r = Math.random() * 16 | 0;
@@ -1398,10 +1552,9 @@ var MixpanelTransport = class extends AnalyticsTransport {
 	async initialize() {
 		try {
 			if (!this.mixpanelConfig.token) throw new Error("Mixpanel token is required");
-			await this.testConnection();
 			this.isReady = true;
 		} catch (error) {
-			internalError("Mixpanel transport initialization failed", error);
+			require_internal_log.internalError("Mixpanel transport initialization failed", error);
 			throw error;
 		}
 	}
@@ -1457,7 +1610,7 @@ var MixpanelTransport = class extends AnalyticsTransport {
 					"Content-Type": "application/json",
 					Accept: "text/plain"
 				},
-				body: JSON.stringify(data)
+				body: require_safe_stringify.stringifyForLog(data)
 			});
 			if (!response.ok) throw new Error(`Mixpanel API error: ${response.status} ${response.statusText}`);
 			const result = await response.text();
@@ -1466,18 +1619,6 @@ var MixpanelTransport = class extends AnalyticsTransport {
 			throw new Error(`Failed to send data to Mixpanel: ${error.message}`, { cause: error });
 		}
 	}
-	async testConnection() {
-		const testEvent = {
-			event: "logitron_test",
-			properties: {
-				token: this.mixpanelConfig.token,
-				distinct_id: "test_user",
-				test: true,
-				time: Date.now()
-			}
-		};
-		await this.makeRequest("/track", [testEvent]);
-	}
 	generateInsertId(entry) {
 		return `${entry.timestamp.getTime()}_${this.simpleHash(entry.message + (entry.traceId || ""))}`;
 	}
@@ -1524,6 +1665,17 @@ var MixpanelTransport = class extends AnalyticsTransport {
 	}
 };
 
+//#endregion
+//#region src/version.ts
+/**
+* The published version of this package.
+*
+* Kept in sync with `version` in package.json by the release process. Importing
+* from here (instead of reading package.json at runtime) keeps the built `dist`
+* free of a JSON import that bundlers and consumers would have to resolve.
+*/
+const LOGIXIA_VERSION = "1.12.0";
+
 //#endregion
 //#region src/transports/segment.transport.ts
 /**
@@ -1547,10 +1699,9 @@ var SegmentTransport = class extends AnalyticsTransport {
 	async initialize() {
 		try {
 			if (!this.segmentConfig.writeKey) throw new Error("Segment Write Key is required");
-			await this.testConnection();
 			this.isReady = true;
 		} catch (error) {
-			internalError("Segment transport initialization failed", error);
+			require_internal_log.internalError("Segment transport initialization failed", error);
 			throw error;
 		}
 	}
@@ -1588,7 +1739,7 @@ var SegmentTransport = class extends AnalyticsTransport {
 			context: {
 				library: {
 					name: "logixia",
-					version: "1.0.0"
+					version: LOGIXIA_VERSION
 				},
 				app: {
 					name: entry.appName || "unknown",
@@ -1608,8 +1759,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 	}
 	async batchTrack(events) {
 		const chunks = this.chunkArray(events, this.segmentConfig.maxBatchSize || 100);
-		for (const chunk of chunks) {
-			const payload = { batch: chunk };
+		for (const chunk$1 of chunks) {
+			const payload = { batch: chunk$1 };
 			await this.makeRequest("/v1/batch", payload);
 		}
 	}
@@ -1622,9 +1773,9 @@ var SegmentTransport = class extends AnalyticsTransport {
 				headers: {
 					"Content-Type": "application/json",
 					Authorization: `Basic ${auth}`,
-					"User-Agent": "logixia/1.0.0"
+					"User-Agent": `logixia/${LOGIXIA_VERSION}`
 				},
-				body: JSON.stringify(data)
+				body: require_safe_stringify.stringifyForLog(data)
 			});
 			if (!response.ok) {
 				const errorText = await response.text();
@@ -1634,24 +1785,6 @@ var SegmentTransport = class extends AnalyticsTransport {
 			throw new Error(`Failed to send data to Segment: ${error.message}`, { cause: error });
 		}
 	}
-	async testConnection() {
-		const testEvent = {
-			type: "track",
-			event: "Logixia Test",
-			userId: "test-user",
-			anonymousId: this.generateAnonymousId(),
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			properties: {
-				test: true,
-				source: "logixia"
-			},
-			context: { library: {
-				name: "logixia",
-				version: "1.0.0"
-			} }
-		};
-		await this.makeRequest("/v1/track", testEvent);
-	}
 	extractUserId(entry) {
 		if (entry.data) {
 			const d = entry.data;
@@ -1681,8 +1814,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 				...user.traits
 			},
 			context: { library: {
-				name: "logitron",
-				version: "1.0.0"
+				name: "logixia",
+				version: LOGIXIA_VERSION
 			} }
 		};
 		await this.makeRequest("/v1/identify", payload);
@@ -1700,8 +1833,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 			},
 			context: {
 				library: {
-					name: "logitron",
-					version: "1.0.0"
+					name: "logixia",
+					version: LOGIXIA_VERSION
 				},
 				page: {
 					url: properties.url || `/${name.toLowerCase().replace(/\s+/g, "-")}`,
@@ -1720,8 +1853,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 			properties: { ...properties },
 			context: {
 				library: {
-					name: "logitron",
-					version: "1.0.0"
+					name: "logixia",
+					version: LOGIXIA_VERSION
 				},
 				screen: { name }
 			}
@@ -1737,8 +1870,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			traits,
 			context: { library: {
-				name: "logitron",
-				version: "1.0.0"
+				name: "logixia",
+				version: LOGIXIA_VERSION
 			} }
 		};
 		await this.makeRequest("/v1/group", payload);
@@ -1750,8 +1883,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 			previousId,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			context: { library: {
-				name: "logitron",
-				version: "1.0.0"
+				name: "logixia",
+				version: LOGIXIA_VERSION
 			} }
 		};
 		await this.makeRequest("/v1/alias", payload);
@@ -1765,8 +1898,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			properties,
 			context: { library: {
-				name: "logitron",
-				version: "1.0.0"
+				name: "logixia",
+				version: LOGIXIA_VERSION
 			} }
 		};
 		await this.makeRequest("/v1/track", payload);
@@ -1784,8 +1917,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 				products
 			},
 			context: { library: {
-				name: "logitron",
-				version: "1.0.0"
+				name: "logixia",
+				version: LOGIXIA_VERSION
 			} }
 		};
 		await this.makeRequest("/v1/track", payload);
@@ -1798,8 +1931,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			properties: product,
 			context: { library: {
-				name: "logitron",
-				version: "1.0.0"
+				name: "logixia",
+				version: LOGIXIA_VERSION
 			} }
 		};
 		await this.makeRequest("/v1/track", payload);
@@ -1818,7 +1951,7 @@ var TransportManager = class extends node_events.EventEmitter {
 		this.metrics = /* @__PURE__ */ new Map();
 		this.isShuttingDown = false;
 		this.transportLevelPreferences = /* @__PURE__ */ new Map();
-		this.promptForLevels = false;
+		this.warnedPromptDeprecated = false;
 		this.setupTransports(config);
 	}
 	setupTransports(config) {
@@ -1918,17 +2051,24 @@ var TransportManager = class extends node_events.EventEmitter {
 		if (entry.context !== void 0) transportEntry.context = entry.context;
 		if (entry.traceId !== void 0) transportEntry.traceId = entry.traceId;
 		if (entry.environment !== void 0) transportEntry.environment = entry.environment;
-		if (this.promptForLevels) return this._writeAsyncWithPrompt(transportEntry);
 		let pending;
+		let syncFailure;
 		for (const [id, transport] of this.transports) {
 			if (!this.shouldTransportHandle(transport, transportEntry.level, id)) continue;
 			if (transport.filter && !transport.filter(transportEntry)) continue;
-			const result = this.writeToTransport(id, transport, transportEntry);
+			let result;
+			try {
+				result = this.writeToTransport(id, transport, transportEntry);
+			} catch (error) {
+				syncFailure ??= { error };
+				continue;
+			}
 			if (result && typeof result.then === "function") {
 				if (pending === void 0) pending = [];
 				pending.push(result);
 			}
 		}
+		if (syncFailure) throw syncFailure.error;
 		if (pending === void 0) return;
 		return Promise.allSettled(pending).then((results) => {
 			const failures = results.filter((r) => r.status === "rejected");
@@ -1938,22 +2078,6 @@ var TransportManager = class extends node_events.EventEmitter {
 			}
 		});
 	}
-	/** Slow path used only when interactive level-prompting is enabled. */
-	async _writeAsyncWithPrompt(transportEntry) {
-		const writePromises = [];
-		for (const [id, transport] of this.transports) {
-			if (!this.transportLevelPreferences.has(id)) await this.configureTransportLevels(id);
-			if (!this.shouldTransportHandle(transport, transportEntry.level, id)) continue;
-			if (transport.filter && !transport.filter(transportEntry)) continue;
-			const result = this.writeToTransport(id, transport, transportEntry);
-			if (result && typeof result.then === "function") writePromises.push(result);
-		}
-		const failures = (await Promise.allSettled(writePromises)).filter((r) => r.status === "rejected");
-		if (failures.length > 0) {
-			const errors = failures.map((f) => f.reason);
-			this.emit("error", /* @__PURE__ */ new Error(`Transport write failures: ${errors.join(", ")}`), "multiple");
-		}
-	}
 	writeToTransport(id, transport, entry) {
 		const startTime = Date.now();
 		const metrics = this.metrics.get(id);
@@ -2140,63 +2264,29 @@ var TransportManager = class extends node_events.EventEmitter {
 			details
 		};
 	}
+	/** @deprecated Library code never prompts on stdin. Use setTransportLevels(). No-op. */
 	enableLevelPrompting() {
-		this.promptForLevels = true;
-		internalLog("Transport level prompting enabled");
+		this.warnPromptingRemoved();
 	}
+	/** @deprecated Library code never prompts on stdin. No-op. */
 	disableLevelPrompting() {
-		this.promptForLevels = false;
-		internalLog("Transport level prompting disabled");
-	}
-	async promptUserForTransportLevels(transportId) {
-		const availableLevels = [
-			"error",
-			"warn",
-			"info",
-			"debug",
-			"trace",
-			"verbose"
-		];
-		return new Promise((resolve) => {
-			const rl = node_readline.createInterface({
-				input: process.stdin,
-				output: process.stdout
-			});
-			process.stdout.write(`\nConfigure log levels for transport '${transportId}'\n`);
-			process.stdout.write(`Available levels: ${availableLevels.join(", ")}\n`);
-			process.stdout.write("Enter levels separated by commas (e.g., error,warn,info) or \"all\" for all levels:\n");
-			rl.question("> ", (answer) => {
-				rl.close();
-				if (answer.toLowerCase().trim() === "all") resolve(availableLevels);
-				else {
-					const selectedLevels = answer.split(",").map((level) => level.trim().toLowerCase()).filter((level) => availableLevels.includes(level));
-					if (selectedLevels.length === 0) {
-						internalWarn("No valid levels selected, using all levels");
-						resolve(availableLevels);
-					} else {
-						internalLog(`Selected levels for ${transportId}: ${selectedLevels.join(", ")}`);
-						resolve(selectedLevels);
-					}
-				}
-			});
-		});
+		this.warnPromptingRemoved();
 	}
-	async configureTransportLevels(transportId) {
-		if (this.promptForLevels && !this.transportLevelPreferences.has(transportId)) {
-			const selectedLevels = await this.promptUserForTransportLevels(transportId);
-			this.transportLevelPreferences.set(transportId, selectedLevels);
-		}
+	warnPromptingRemoved() {
+		if (this.warnedPromptDeprecated) return;
+		this.warnedPromptDeprecated = true;
+		require_internal_log.internalWarn("Transport level prompting was removed: logixia never reads stdin. Use setTransportLevels(id, levels) instead.");
 	}
 	setTransportLevels(transportId, levels) {
 		this.transportLevelPreferences.set(transportId, levels);
-		internalLog(`Transport '${transportId}' configured for levels: ${levels.join(", ")}`);
+		require_internal_log.internalLog(`Transport '${transportId}' configured for levels: ${levels.join(", ")}`);
 	}
 	getTransportLevels(transportId) {
 		return this.transportLevelPreferences.get(transportId);
 	}
 	clearTransportLevelPreferences() {
 		this.transportLevelPreferences.clear();
-		internalLog("Transport level preferences cleared");
+		require_internal_log.internalLog("Transport level preferences cleared");
 	}
 };
 
@@ -2255,34 +2345,4 @@ Object.defineProperty(exports, 'TransportManager', {
     return TransportManager;
   }
 });
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
-Object.defineProperty(exports, 'internalError', {
-  enumerable: true,
-  get: function () {
-    return internalError;
-  }
-});
-Object.defineProperty(exports, 'internalLog', {
-  enumerable: true,
-  get: function () {
-    return internalLog;
-  }
-});
-Object.defineProperty(exports, 'internalWarn', {
-  enumerable: true,
-  get: function () {
-    return internalWarn;
-  }
-});
-Object.defineProperty(exports, 'safeToString', {
-  enumerable: true,
-  get: function () {
-    return safeToString;
-  }
-});
-//# sourceMappingURL=transport.manager-ciG4r5uz.js.map
+//# sourceMappingURL=transport.manager-BivyUTtU.js.map