logixia 1.12.4 → 1.12.6

package/dist/worker-entry.js

@@ -0,0 +1,1241 @@
+//#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_worker_threads = require("node:worker_threads");
+node_worker_threads = __toESM(node_worker_threads);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_stream_promises = require("node:stream/promises");
+node_stream_promises = __toESM(node_stream_promises);
+let node_util = require("node:util");
+node_util = __toESM(node_util);
+let node_zlib = require("node:zlib");
+node_zlib = __toESM(node_zlib);
+
+//#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/utils/safe-stringify.ts
+/** Build a JSONPath like `$["a"][0]["b"]` for a decycle pointer. */
+function jsonPath(parts) {
+	let path = "$";
+	for (const p of parts) path += typeof p === "number" ? `[${p}]` : `[${JSON.stringify(p)}]`;
+	return path;
+}
+/**
+* Serialize any value to JSON without throwing on circular references or BigInt.
+* Circular refs become `"[Circular]"` (or `{ $ref }` pointers when `decycle`).
+*/
+function safeStringify(value, options = {}) {
+	const { indent, deterministic = false, decycle = false, bigint = "string" } = options;
+	if (decycle) return JSON.stringify(decycleValue(value, bigint), void 0, indent);
+	const seen = /* @__PURE__ */ new WeakSet();
+	const transform = (val) => {
+		if (typeof val === "bigint") return bigint === "number" ? Number(val) : val.toString();
+		if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+		if (typeof val === "symbol") return val.toString();
+		if (val === null || typeof val !== "object") return val;
+		if (seen.has(val)) return "[Circular]";
+		seen.add(val);
+		let out;
+		const toJSON = val.toJSON;
+		if (Array.isArray(val)) out = val.map((item) => transform(item));
+		else if (typeof toJSON === "function") out = transform(toJSON.call(val));
+		else {
+			const rec = val;
+			const keys = deterministic ? Object.keys(rec).sort() : Object.keys(rec);
+			const obj = {};
+			for (const k of keys) {
+				if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+				obj[k] = transform(rec[k]);
+			}
+			out = obj;
+		}
+		seen.delete(val);
+		return out;
+	};
+	return JSON.stringify(transform(value), void 0, indent);
+}
+/**
+* Replace repeated object references with round-trippable `{ "$ref": "$..." }`
+* JSONPath pointers (the classic Crockford decycle). Pair with {@link retrocycle}
+* to reconstruct the original shared/circular graph.
+*/
+function decycleValue(value, bigint = "string") {
+	const paths = /* @__PURE__ */ new WeakMap();
+	const walk = (val, path) => {
+		if (typeof val === "bigint") return bigint === "number" ? Number(val) : val.toString();
+		if (val === null || typeof val !== "object") return val;
+		if (val instanceof Date) return val.toISOString();
+		const existing = paths.get(val);
+		if (existing !== void 0) return { $ref: existing };
+		paths.set(val, jsonPath(path));
+		if (Array.isArray(val)) return val.map((item, i) => walk(item, [...path, i]));
+		const rec = val;
+		const obj = {};
+		for (const k of Object.keys(rec)) {
+			if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+			obj[k] = walk(rec[k], [...path, k]);
+		}
+		return obj;
+	};
+	return walk(value, []);
+}
+/**
+* `JSON.stringify` for log output. Takes the plain fast path first and only
+* falls back to {@link safeStringify} when that throws (a cycle, a BigInt, a
+* throwing `toJSON`), so a bad payload costs nothing until it shows up.
+* Never throws: if even the safe walk fails, the value is replaced by a marker.
+*/
+function stringifyForLog(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		try {
+			return safeStringify(value);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			return JSON.stringify(`[Unserializable: ${reason}]`);
+		}
+	}
+}
+
+//#endregion
+//#region src/transports/console.transport.ts
+/**
+* Writes log entries to stdout (info/debug/verbose) and stderr (error/warn).
+*
+* Supports pretty-printed colorized output and compact JSON mode.
+*
+* @example
+* transports: { console: { format: 'json' } }
+*/
+var ConsoleTransport = class ConsoleTransport {
+	static #_ = this.COLORS = new Map([
+		["black", "\x1B[30m"],
+		["red", "\x1B[31m"],
+		["green", "\x1B[32m"],
+		["yellow", "\x1B[33m"],
+		["blue", "\x1B[34m"],
+		["magenta", "\x1B[35m"],
+		["cyan", "\x1B[36m"],
+		["white", "\x1B[37m"],
+		["gray", "\x1B[90m"],
+		["grey", "\x1B[90m"],
+		["brightred", "\x1B[91m"],
+		["brightgreen", "\x1B[92m"],
+		["brightyellow", "\x1B[93m"],
+		["brightblue", "\x1B[94m"],
+		["brightmagenta", "\x1B[95m"],
+		["brightcyan", "\x1B[96m"],
+		["brightwhite", "\x1B[97m"],
+		["reset", "\x1B[0m"]
+	]);
+	static #_2 = this.CONTROL_CHARS_RE = /[\x00-\x08\x0B-\x1F\x7F-\x9F]/g;
+	static sanitize(value) {
+		return safeToString(value).replace(ConsoleTransport.CONTROL_CHARS_RE, "");
+	}
+	constructor(config = {}) {
+		this.config = config;
+		this.name = "console";
+		if (config.filter) this.filter = config.filter;
+	}
+	write(entry) {
+		const formatted = this.formatEntry(entry) + "\n";
+		const lvl = entry.level.toLowerCase();
+		(lvl === "error" || lvl === "warn" ? process.stderr : process.stdout).write(formatted);
+	}
+	formatEntry(entry) {
+		if (this.config.format === "json") return stringifyForLog({
+			timestamp: this.config.timestamp !== false ? entry.timestamp.toISOString() : void 0,
+			level: entry.level,
+			message: entry.message,
+			...entry.data || {},
+			context: entry.context,
+			traceId: entry.traceId,
+			appName: entry.appName,
+			environment: entry.environment
+		});
+		const parts = [];
+		if (this.config.timestamp !== false) {
+			const timestamp = entry.timestamp.toISOString();
+			parts.push(this.colorize(timestamp, "gray"));
+		}
+		const level = ConsoleTransport.sanitize(entry.level).toUpperCase().padEnd(5);
+		const coloredLevel = this.colorize(level, this.getLevelColor(entry.level));
+		parts.push(coloredLevel);
+		if (entry.context) {
+			const context = `[${ConsoleTransport.sanitize(entry.context)}]`;
+			parts.push(this.colorize(context, "cyan"));
+		}
+		if (entry.traceId) {
+			const traceId = `(${ConsoleTransport.sanitize(entry.traceId)})`;
+			parts.push(this.colorize(traceId, "magenta"));
+		}
+		parts.push(ConsoleTransport.sanitize(entry.message));
+		if (entry.data && Object.keys(entry.data).length > 0) {
+			const data = stringifyForLog(entry.data);
+			parts.push(this.colorize(data, "blue"));
+		}
+		return parts.join(" ");
+	}
+	getLevelColor(level) {
+		var _this$config$levelCol;
+		const lower = level.toLowerCase();
+		if ((_this$config$levelCol = this.config.levelColors) === null || _this$config$levelCol === void 0 ? void 0 : _this$config$levelCol[lower]) return this.config.levelColors[lower];
+		return {
+			error: "red",
+			warn: "yellow",
+			warning: "yellow",
+			info: "green",
+			debug: "blue",
+			trace: "magenta",
+			verbose: "cyan"
+		}[lower] || "gray";
+	}
+	colorize(text, color) {
+		if (this.config.colorize === false) return text;
+		const reset = ConsoleTransport.COLORS.get("reset");
+		return `${ConsoleTransport.COLORS.get(color) ?? ConsoleTransport.COLORS.get("white")}${text}${reset}`;
+	}
+	close() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#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 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`);
+	}
+}
+
+//#endregion
+//#region src/transports/database.transport.ts
+/**
+* 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.`);
+}
+/**
+* Persists log entries to a database in batches.
+*
+* Supports MongoDB, PostgreSQL, MySQL, and SQLite. Entries are buffered and
+* flushed on a configurable interval or batch size threshold to minimize
+* round-trips.
+*
+* @example
+* transports: {
+*   database: { type: 'postgresql', host: 'localhost', database: 'appdb', table: 'logs' }
+* }
+*/
+var DatabaseTransport = class {
+	constructor(config) {
+		this.config = config;
+		this.name = "database";
+		this.batch = [];
+		this.isConnected = false;
+		this.batchSize = config.batchSize || 100;
+		this.flushInterval = config.flushInterval || 5e3;
+		if (config.filter) this.filter = config.filter;
+		if (config.table) validateSqlIdentifier(config.table, "table");
+		this.setupFlushTimer();
+	}
+	async write(entry) {
+		if (!this.isConnected) await this.connect();
+		this.addToBatch(entry);
+		if (this.batch.length >= this.batchSize) await this.flush();
+	}
+	addToBatch(entry) {
+		this.batch.push(entry);
+	}
+	async flush() {
+		if (!this.flushPromise) this.flushPromise = this.drain().finally(() => {
+			this.flushPromise = void 0;
+		});
+		await this.flushPromise;
+	}
+	/**
+	* Drains the batch to the database one snapshot at a time. The current batch
+	* is detached SYNCHRONOUSLY before awaiting the write, so entries appended by
+	* concurrent write() calls land in a fresh array and are never written twice.
+	* On write failure the snapshot is restored to the front of the batch for the
+	* next flush cycle and the loop stops, so a persistently failing DB does not
+	* hot-spin retrying the same entries.
+	*/
+	async drain() {
+		while (this.batch.length > 0) {
+			const entriesToFlush = this.batch;
+			this.batch = [];
+			try {
+				switch (this.config.type) {
+					case "mongodb":
+						await this.flushToMongoDB(entriesToFlush);
+						break;
+					case "postgresql":
+						await this.flushToPostgreSQL(entriesToFlush);
+						break;
+					case "mysql":
+						await this.flushToMySQL(entriesToFlush);
+						break;
+					case "sqlite":
+						await this.flushToSQLite(entriesToFlush);
+						break;
+					default: throw new Error(`Unsupported database type: ${this.config.type}`);
+				}
+			} catch (error) {
+				internalError("Database flush error", error);
+				this.batch.unshift(...entriesToFlush);
+				throw error;
+			}
+		}
+	}
+	async isReady() {
+		try {
+			if (!this.isConnected) await this.connect();
+			return this.isConnected;
+		} catch {
+			return false;
+		}
+	}
+	async connect() {
+		if (this.connectionPromise) return this.connectionPromise;
+		this.connectionPromise = this.establishConnection().catch((error) => {
+			this.connectionPromise = void 0;
+			throw error;
+		});
+		return this.connectionPromise;
+	}
+	async establishConnection() {
+		try {
+			switch (this.config.type) {
+				case "mongodb":
+					await this.connectMongoDB();
+					break;
+				case "postgresql":
+					await this.connectPostgreSQL();
+					break;
+				case "mysql":
+					await this.connectMySQL();
+					break;
+				case "sqlite":
+					await this.connectSQLite();
+					break;
+			}
+			this.isConnected = true;
+		} catch (error) {
+			this.isConnected = false;
+			throw new Error(`Database connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectMongoDB() {
+		try {
+			const { MongoClient } = await import("mongodb").catch(() => {
+				throw new Error("MongoDB driver not installed. Run: npm install mongodb");
+			});
+			this.connection = new MongoClient(this.config.connectionString || `mongodb://${this.config.host}:${this.config.port}/${this.config.database}`);
+			await this.connection.connect();
+			await this.connection.db(this.config.database).admin().ping();
+		} catch (error) {
+			throw new Error(`MongoDB connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectPostgreSQL() {
+		try {
+			const { Client } = await import("pg").catch(() => {
+				throw new Error("PostgreSQL driver not installed. Run: npm install pg @types/pg");
+			});
+			const config = {
+				connectionString: this.config.connectionString,
+				host: this.config.host,
+				port: this.config.port,
+				database: this.config.database
+			};
+			if (this.config.username) config.user = this.config.username;
+			if (this.config.password) config.password = this.config.password;
+			if (this.config.ssl) config.ssl = typeof this.config.ssl === "boolean" ? {} : this.config.ssl;
+			this.connection = new Client(config);
+			await this.connection.connect();
+			await this.createPostgreSQLTable();
+		} catch (error) {
+			throw new Error(`PostgreSQL connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectMySQL() {
+		try {
+			const mysql = await import("mysql2/promise").catch(() => {
+				throw new Error("MySQL driver not installed. Run: npm install mysql2");
+			});
+			const config = {
+				host: this.config.host,
+				port: this.config.port,
+				database: this.config.database
+			};
+			if (this.config.username) config.user = this.config.username;
+			if (this.config.password) config.password = this.config.password;
+			if (this.config.ssl) config.ssl = typeof this.config.ssl === "boolean" ? {} : this.config.ssl;
+			this.connection = await mysql.createConnection(config);
+			await this.createMySQLTable();
+		} catch (error) {
+			throw new Error(`MySQL connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectSQLite() {
+		try {
+			const sqlite3ModuleName = "sqlite3";
+			const sqliteModuleName = "sqlite";
+			const sqlite3 = await import(sqlite3ModuleName).catch(() => {
+				throw new Error("SQLite driver not installed. Run: npm install sqlite3 sqlite");
+			});
+			const { open } = await import(sqliteModuleName).catch(() => {
+				throw new Error("SQLite driver not installed. Run: npm install sqlite3 sqlite");
+			});
+			this.connection = await open({
+				filename: this.config.database,
+				driver: sqlite3.Database
+			});
+			await this.createSQLiteTable();
+		} catch (error) {
+			throw new Error(`SQLite connection failed: ${error}`, { cause: error });
+		}
+	}
+	async flushToMongoDB(entries) {
+		const collection = this.connection.db(this.config.database).collection(this.config.collection || "logs");
+		const documents = entries.map((entry) => ({
+			timestamp: entry.timestamp,
+			level: entry.level,
+			message: entry.message,
+			payload: entry.data,
+			context: entry.context,
+			traceId: entry.traceId,
+			appName: entry.appName,
+			environment: entry.environment
+		}));
+		await collection.insertMany(documents);
+	}
+	async flushToPostgreSQL(entries) {
+		const tableName = this.config.table || "logs";
+		const chunks = chunk(entries.map((entry) => [
+			entry.timestamp,
+			entry.level,
+			entry.message,
+			stringifyForLog(entry.data || {}),
+			entry.context,
+			entry.traceId,
+			entry.appName,
+			entry.environment
+		]), POSTGRES_ROWS_PER_INSERT);
+		const insertChunk = async (rows) => {
+			const query = `
+      INSERT INTO ${tableName} 
+      (timestamp, level, message, payload, context, trace_id, app_name, environment)
+      VALUES ${rows.map((_, i) => {
+				return `(${Array.from({ length: POSTGRES_COLUMNS }, (_unused, c) => `$${i * POSTGRES_COLUMNS + c + 1}`).join(", ")})`;
+			}).join(", ")}
+    `;
+			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";
+		const values = entries.map((entry) => [
+			entry.timestamp,
+			entry.level,
+			entry.message,
+			stringifyForLog(entry.data || {}),
+			entry.context,
+			entry.traceId,
+			entry.appName,
+			entry.environment
+		]);
+		const query = `
+      INSERT INTO ${tableName} 
+      (timestamp, level, message, payload, context, trace_id, app_name, environment)
+      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";
+		const stmt = await this.connection.prepare(`
+      INSERT INTO ${tableName} 
+      (timestamp, level, message, payload, context, trace_id, app_name, environment)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+		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, 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";
+		const query = `
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        id SERIAL PRIMARY KEY,
+        timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        level VARCHAR(20) NOT NULL,
+        message TEXT NOT NULL,
+        payload JSONB,
+        context VARCHAR(255),
+        trace_id VARCHAR(255),
+        app_name VARCHAR(255),
+        environment VARCHAR(50),
+        time_taken INTEGER,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+		await this.connection.query(query);
+		await this.connection.query(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName} (timestamp)`);
+		await this.connection.query(`CREATE INDEX IF NOT EXISTS idx_${tableName}_level ON ${tableName} (level)`);
+		await this.connection.query(`CREATE INDEX IF NOT EXISTS idx_${tableName}_trace_id ON ${tableName} (trace_id)`);
+	}
+	async createMySQLTable() {
+		const query = `
+      CREATE TABLE IF NOT EXISTS ${this.config.table || "logs"} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        timestamp DATETIME NOT NULL,
+        level VARCHAR(20) NOT NULL,
+        message TEXT NOT NULL,
+        payload JSON,
+        context VARCHAR(255),
+        trace_id VARCHAR(255),
+        app_name VARCHAR(255),
+        environment VARCHAR(50),
+        time_taken INT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        INDEX idx_timestamp (timestamp),
+        INDEX idx_level (level),
+        INDEX idx_trace_id (trace_id)
+      )
+    `;
+		await this.connection.execute(query);
+	}
+	async createSQLiteTable() {
+		const tableName = this.config.table || "logs";
+		const query = `
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        payload TEXT,
+        context TEXT,
+        trace_id TEXT,
+        app_name TEXT,
+        environment TEXT,
+        time_taken INTEGER,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+		await this.connection.exec(query);
+		await this.connection.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName} (timestamp)`);
+		await this.connection.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_level ON ${tableName} (level)`);
+		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);
+			});
+		}, 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) {
+			clearInterval(this.flushTimer);
+			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);
+		}
+		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.connection) switch (this.config.type) {
+			case "mongodb":
+				await this.connection.close();
+				break;
+			case "postgresql":
+				await this.connection.end();
+				break;
+			case "mysql":
+				await this.connection.end();
+				break;
+			case "sqlite":
+				await this.connection.close();
+				break;
+		}
+		this.isConnected = false;
+	}
+	getBatchInfo() {
+		return {
+			batchSize: this.batchSize,
+			currentBatchLength: this.batch.length,
+			flushInterval: this.flushInterval,
+			isConnected: this.isConnected
+		};
+	}
+	async getLogCount() {
+		if (!this.isConnected) return 0;
+		try {
+			switch (this.config.type) {
+				case "mongodb": return await this.connection.db(this.config.database).collection(this.config.collection || "logs").countDocuments();
+				case "postgresql": {
+					var _result$rows;
+					const tableName = this.config.table || "logs";
+					const result = await this.connection.query(`SELECT COUNT(*) as count FROM ${tableName}`);
+					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;
+			}
+		} catch {
+			return 0;
+		}
+	}
+};
+
+//#endregion
+//#region src/transports/file.transport.ts
+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.
+*
+* 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' } }
+*/
+var FileTransport = class {
+	constructor(config) {
+		this.name = "file";
+		this.batch = [];
+		this.lastRotation = /* @__PURE__ */ new Date();
+		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,
+			flushInterval: 5e3,
+			...config
+		};
+		this.level = config.level;
+		this.batchSize = this.config.batchSize || 100;
+		this.flushInterval = this.config.flushInterval || 5e3;
+		if (config.filter) this.filter = config.filter;
+		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) 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)) 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) {
+			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 {
+			while (this.queuePolicy === "block" && this.queueFull()) await this.roomAvailable();
+			if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(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.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;
+		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;
+		});
+	}
+	/**
+	* 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 || this.rotateRequested) {
+			if (this.rotateRequested) {
+				this.rotateRequested = false;
+				const waiting = this.rotationWaiters;
+				this.rotationWaiters = [];
+				try {
+					await this.rotateFile();
+				} catch (error) {
+					internalError("FileTransport rotation failed", error);
+				}
+				for (const resolve of waiting) resolve();
+				continue;
+			}
+			const pending = this.batch;
+			this.batch = [];
+			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) 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 stringifyForLog({
+				timestamp: entry.timestamp.toISOString(),
+				level: entry.level,
+				message: entry.message,
+				...entry.data || {}
+			});
+			case "csv": {
+				const safeMessage = safeToString(entry.message);
+				return [
+					entry.timestamp.toISOString(),
+					entry.level,
+					`"${safeMessage.replace(/"/g, "\"\"")}"`,
+					safeToString(entry.context),
+					safeToString(entry.traceId),
+					stringifyForLog(entry.data || {})
+				].join(",");
+			}
+			case "text":
+			default: return `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${safeToString(entry.message)}${entry.data ? " " + stringifyForLog(entry.data) : ""}`;
+		}
+	}
+	addToBatch(entry) {
+		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.startDrain();
+		} else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
+			this.flush().catch((err) => 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;
+		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);
+	}
+	async append(content, bytes = Buffer.byteLength(content)) {
+		await appendFile(this.currentFilePath, content);
+		this.bytesWritten += bytes;
+	}
+	timeToRotate() {
+		var _this$config$rotation;
+		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) {
+				internalError("FileTransport rotation.shouldRotate threw", error);
+			}
+		}
+		return false;
+	}
+	parseInterval(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()) {
+			case "h": return value * 60 * 60 * 1e3;
+			case "d": return value * 24 * 60 * 60 * 1e3;
+			case "w": return value * 7 * 24 * 60 * 60 * 1e3;
+			case "m": return value * 30 * 24 * 60 * 60 * 1e3;
+			case "y": return value * 365 * 24 * 60 * 60 * 1e3;
+			default: return value * 60 * 60 * 1e3;
+		}
+	}
+	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") {
+					internalError(`FileTransport could not rotate ${this.currentFilePath}`, error);
+					this.bytesWritten = 0;
+					return;
+				}
+				archived = void 0;
+			}
+		}
+		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;
+	}
+	/**
+	* 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:
+	* any failure is logged and leaves the original file intact rather than
+	* throwing out of the rotation path.
+	*/
+	async compressFile(filePath) {
+		const gzPath = `${filePath}.gz`;
+		try {
+			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);
+			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() {
+		if (!this.maxFiles) return;
+		try {
+			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)).mtimeMs
+				};
+			}))).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);
+		}
+	}
+	async close() {
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = void 0;
+		}
+		await this.flush();
+		await this.housekeeping;
+		this.reportDropped(0);
+	}
+};
+
+//#endregion
+//#region src/transports/worker-entry.ts
+const port = node_worker_threads.parentPort;
+if (!port) throw new Error("worker-entry must run inside a worker thread");
+const { transportType, transportConfig } = node_worker_threads.workerData;
+function createTransport() {
+	const config = transportConfig;
+	switch (transportType) {
+		case "file": return new FileTransport(config);
+		case "database": return new DatabaseTransport(config);
+		default: return new ConsoleTransport(config);
+	}
+}
+const errorMessage = (err) => err instanceof Error ? err.message : String(err);
+let transport;
+try {
+	transport = createTransport();
+} catch (err) {
+	port.postMessage({
+		type: "error",
+		error: errorMessage(err)
+	});
+	process.exit(1);
+}
+const flushTransport = async () => {
+	if (typeof transport.flush === "function") await transport.flush();
+};
+async function handle(msg) {
+	if (msg.type === "write") try {
+		await transport.write(msg.entry);
+	} catch (err) {
+		port === null || port === void 0 || port.postMessage({
+			type: "write-error",
+			error: errorMessage(err),
+			entry: msg.entry
+		});
+	}
+	else if (msg.type === "flush") try {
+		await flushTransport();
+		port === null || port === void 0 || port.postMessage({ type: "flushed" });
+	} catch (err) {
+		port === null || port === void 0 || port.postMessage({
+			type: "flush-error",
+			error: errorMessage(err)
+		});
+	}
+	else {
+		try {
+			await flushTransport();
+			if (typeof transport.close === "function") await transport.close();
+		} catch {}
+		process.exit(0);
+	}
+}
+let queue = Promise.resolve();
+port.on("message", (msg) => {
+	queue = queue.then(() => handle(msg));
+});
+port.postMessage({ type: "ready" });
+
+//#endregion