logixia 1.12.6 → 1.13.3

package/dist/worker-entry.js

@@ -155,6 +155,52 @@ function stringifyForLog(value) {
 	}
 }
 
+//#endregion
+//#region src/utils/sanitize.utils.ts
+/**
+* Control-character stripping for text-mode log output.
+*
+* Line breaks become the visible escapes `\\n` / `\\r`; other C0 characters
+* (except tab), DEL and C1 characters are removed, so user-supplied text cannot
+* inject ANSI escapes, overwrite lines, or forge extra log entries.
+*/
+const CONTROL_CHARS_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]/g;
+const VISIBLE_ESCAPES = {
+	"\n": "\\n",
+	"\r": "\\r"
+};
+function stripControlChars(value) {
+	return value.replace(CONTROL_CHARS_RE, (ch) => VISIBLE_ESCAPES[ch] ?? "");
+}
+
+//#endregion
+//#region src/transports/entry-fields.ts
+const PAYLOAD_PREFIX = "data_";
+const UNSAFE_KEYS = new Set(["__proto__"]);
+/**
+* Copies `core` and then the user payload into one object. The core fields stay
+* authoritative: a payload key that matches a core key (even one whose value is
+* undefined) or a reserved name is kept under a `data_` prefix instead. The
+* prefix is repeated until the name is free of core keys and of every other
+* payload key, so the result does not depend on key order and a payload's own
+* `data_level` stays where it is.
+*/
+function mergeCoreFields(core, data, extraReserved = []) {
+	const merged = { ...core };
+	if (!data) return merged;
+	const reserved = new Set([...Object.keys(core), ...extraReserved]);
+	const payloadKeys = new Set(Object.keys(data));
+	for (const key of payloadKeys) {
+		if (UNSAFE_KEYS.has(key)) continue;
+		let target = key;
+		if (reserved.has(target)) do
+			target = `${PAYLOAD_PREFIX}${target}`;
+		while (reserved.has(target) || payloadKeys.has(target));
+		merged[target] = data[key];
+	}
+	return merged;
+}
+
 //#endregion
 //#region src/transports/console.transport.ts
 /**
@@ -186,9 +232,8 @@ var ConsoleTransport = class ConsoleTransport {
 		["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, "");
+		return stripControlChars(safeToString(value));
 	}
 	constructor(config = {}) {
 		this.config = config;
@@ -201,16 +246,15 @@ var ConsoleTransport = class ConsoleTransport {
 		(lvl === "error" || lvl === "warn" ? process.stderr : process.stdout).write(formatted);
 	}
 	formatEntry(entry) {
-		if (this.config.format === "json") return stringifyForLog({
+		if (this.config.format === "json") return stringifyForLog(mergeCoreFields({
 			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
-		});
+		}, entry.data));
 		const parts = [];
 		if (this.config.timestamp !== false) {
 			const timestamp = entry.timestamp.toISOString();
@@ -300,6 +344,47 @@ function internalError(message, error) {
 	}
 }
 
+//#endregion
+//#region src/transports/buffer-cap.ts
+const DEFAULT_BUFFER_CAP = 1e4;
+const DROP_WARN_INTERVAL_MS$1 = 5e3;
+/**
+* Keeps an in-memory retry buffer bounded. Past `max` the oldest items are
+* dropped, counted, and reported through internalWarn at most every few seconds.
+*
+* `requested` must be an integer of at least 1, otherwise the default is used.
+* A cap below `batchSize` is raised to `batchSize` so one batch always fits.
+*/
+var BufferCap = class {
+	constructor(name, requested, batchSize, fallback = DEFAULT_BUFFER_CAP) {
+		this.name = name;
+		this.dropped = 0;
+		this.lastWarning = 0;
+		let max = fallback;
+		if (requested !== void 0) if (Number.isInteger(requested) && requested >= 1) max = requested;
+		else internalWarn(`${name}: maxBufferSize ${String(requested)} is not a positive integer; using ${fallback}`);
+		this.max = Math.max(max, batchSize);
+	}
+	/** Drops the oldest items beyond the cap, in place. */
+	enforce(items) {
+		const excess = items.length - this.max;
+		if (excess <= 0) return;
+		items.splice(0, excess);
+		this.note(excess);
+	}
+	note(count) {
+		this.dropped += count;
+		this.report(DROP_WARN_INTERVAL_MS$1);
+	}
+	report(minGapMs) {
+		const now = Date.now();
+		if (this.dropped === 0 || now - this.lastWarning < minGapMs) return;
+		internalWarn(`${this.name}: buffer full (${this.max}), dropped ${this.dropped} oldest entr${this.dropped === 1 ? "y" : "ies"}`);
+		this.dropped = 0;
+		this.lastWarning = now;
+	}
+};
+
 //#endregion
 //#region src/transports/database.transport.ts
 /**
@@ -310,6 +395,80 @@ 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;
+/** Postgres rejects NUL in TEXT and JSONB. */
+function stripNul(value) {
+	return typeof value === "string" ? value.split("\0").join("") : value;
+}
+/** JSONB also rejects the \u0000 escape, which JSON.stringify writes for a NUL. */
+function stripJsonNulEscape(value) {
+	if (typeof value !== "string") return value;
+	return value.replace(/(?<!\\)((?:\\\\)*)\\u0000/g, "$1");
+}
+const PG_DATA_CLASSES = [
+	"22",
+	"23",
+	"54"
+];
+const MYSQL_DATA_CODES = new Set([
+	"ER_DATA_TOO_LONG",
+	"ER_TRUNCATED_WRONG_VALUE",
+	"ER_TRUNCATED_WRONG_VALUE_FOR_FIELD",
+	"ER_BAD_NULL_ERROR",
+	"ER_WARN_DATA_OUT_OF_RANGE",
+	"ER_DUP_ENTRY",
+	"ER_INVALID_JSON_TEXT",
+	"ER_INVALID_CHARACTER_STRING"
+]);
+const MYSQL_DATA_ERRNOS = new Set([
+	1048,
+	1062,
+	1264,
+	1292,
+	1366,
+	1406,
+	3140
+]);
+const SQLITE_DATA_CODES = new Set([
+	"SQLITE_CONSTRAINT",
+	"SQLITE_TOOBIG",
+	"SQLITE_MISMATCH"
+]);
+const MONGO_DATA_CODES = new Set([
+	2,
+	121,
+	10334,
+	11e3
+]);
+function isDataErrorLayer(type, e) {
+	const code = e.code;
+	switch (type) {
+		case "postgresql": return typeof code === "string" && PG_DATA_CLASSES.includes(code.slice(0, 2));
+		case "mysql": return typeof code === "string" && MYSQL_DATA_CODES.has(code) || typeof e.errno === "number" && MYSQL_DATA_ERRNOS.has(e.errno);
+		case "sqlite": return typeof code === "string" && (SQLITE_DATA_CODES.has(code) || code.startsWith("SQLITE_CONSTRAINT_"));
+		case "mongodb": return e.name === "BSONObjectTooLarge" || typeof code === "number" && MONGO_DATA_CODES.has(code);
+		default: return false;
+	}
+}
+/**
+* True when the database refused the data itself (bad value, constraint, size),
+* which retrying cannot fix. Connection, timeout, auth and unknown errors are
+* not data errors and must be retried, never dropped.
+*/
+function isDataError(type, error) {
+	let current = error;
+	for (let depth = 0; depth < 3 && current && typeof current === "object"; depth += 1) {
+		if (isDataErrorLayer(type, current)) return true;
+		current = current.cause;
+	}
+	return false;
+}
+/** A write that stored part of a batch: only `remaining` still needs to be written. */
+var PartialWriteError = class extends Error {
+	constructor(message, remaining, cause) {
+		super(message, { cause });
+		this.remaining = remaining;
+	}
+};
 function chunk(items, size) {
 	const chunks = [];
 	for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
@@ -338,6 +497,7 @@ var DatabaseTransport = class {
 		this.isConnected = false;
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
+		this.cap = new BufferCap("DatabaseTransport", config.maxBufferSize, this.batchSize);
 		if (config.filter) this.filter = config.filter;
 		if (config.table) validateSqlIdentifier(config.table, "table");
 		this.setupFlushTimer();
@@ -349,6 +509,7 @@ var DatabaseTransport = class {
 	}
 	addToBatch(entry) {
 		this.batch.push(entry);
+		this.cap.enforce(this.batch);
 	}
 	async flush() {
 		if (!this.flushPromise) this.flushPromise = this.drain().finally(() => {
@@ -357,37 +518,97 @@ var DatabaseTransport = class {
 		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.
+	* Drains the buffer to the database one batch at a time. A 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.
+	*
+	* A failure that is not a data error (connection, timeout, auth, unknown) puts
+	* the batch back at the front of the buffer, bounded by `maxBufferSize`, and
+	* stops the loop so a down database is not hammered. A data error means the
+	* database refused some entry itself, so that batch alone is split to find and
+	* drop the refused entries; see isolate().
 	*/
 	async drain() {
 		while (this.batch.length > 0) {
-			const entriesToFlush = this.batch;
-			this.batch = [];
+			const entries = this.batch.splice(0, this.batchSize);
 			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}`);
-				}
+				await this.writeEntries(entries);
 			} catch (error) {
 				internalError("Database flush error", error);
-				this.batch.unshift(...entriesToFlush);
-				throw error;
+				if (error instanceof PartialWriteError) {
+					this.requeue(error.remaining);
+					throw error.cause;
+				}
+				if (!isDataError(this.config.type, error)) {
+					this.requeue(entries);
+					throw error;
+				}
+				const state = {
+					budget: 2 * this.batchSize,
+					rejected: 0,
+					requeue: [],
+					stopped: false
+				};
+				await this.isolate(entries, state);
+				if (state.rejected > 0) internalWarn(`DatabaseTransport: dropped ${state.rejected} log entr${state.rejected === 1 ? "y" : "ies"} the database rejected`);
+				this.requeue(state.requeue);
+				if (state.stopped) throw state.error;
+			}
+		}
+	}
+	requeue(entries) {
+		if (entries.length === 0) return;
+		this.batch = entries.concat(this.batch);
+		this.cap.enforce(this.batch);
+	}
+	async writeEntries(entries) {
+		switch (this.config.type) {
+			case "mongodb":
+				await this.flushToMongoDB(entries);
+				break;
+			case "postgresql":
+				await this.flushToPostgreSQL(entries);
+				break;
+			case "mysql":
+				await this.flushToMySQL(entries);
+				break;
+			case "sqlite":
+				await this.flushToSQLite(entries);
+				break;
+			default: throw new Error(`Unsupported database type: ${this.config.type}`);
+		}
+	}
+	/**
+	* `entries` failed with a data error. Splits them in half until the refused
+	* entries are alone and drops those. A write that fails with anything but a
+	* data error, or running out of the per-flush write budget, stops the search:
+	* the entries not yet written go back to the buffer.
+	*/
+	async isolate(entries, state) {
+		if (entries.length === 1) {
+			state.rejected += 1;
+			return;
+		}
+		const mid = Math.ceil(entries.length / 2);
+		for (const half of [entries.slice(0, mid), entries.slice(mid)]) {
+			if (state.stopped || state.budget <= 0) {
+				state.requeue.push(...half);
+				continue;
+			}
+			state.budget -= 1;
+			try {
+				await this.writeEntries(half);
+			} catch (error) {
+				if (error instanceof PartialWriteError) {
+					state.requeue.push(...error.remaining);
+					state.stopped = true;
+					state.error = error.cause;
+				} else if (isDataError(this.config.type, error)) await this.isolate(half, state);
+				else {
+					state.requeue.push(...half);
+					state.stopped = true;
+					state.error = error;
+				}
 			}
 		}
 	}
@@ -512,7 +733,26 @@ var DatabaseTransport = class {
 			appName: entry.appName,
 			environment: entry.environment
 		}));
-		await collection.insertMany(documents);
+		try {
+			await collection.insertMany(documents, { ordered: false });
+		} catch (error) {
+			const raw = error.writeErrors;
+			let list = [];
+			if (Array.isArray(raw)) list = raw;
+			else if (raw) list = [raw];
+			const writeErrors = list;
+			if (writeErrors.length === 0) throw error;
+			const remaining = [];
+			let rejected = 0;
+			for (const writeError of writeErrors) {
+				const entry = typeof writeError.index === "number" ? entries[writeError.index] : void 0;
+				if (!entry) throw error;
+				if (isDataError("mongodb", writeError)) rejected += 1;
+				else remaining.push(entry);
+			}
+			if (rejected > 0) internalWarn(`DatabaseTransport: dropped ${rejected} log entr${rejected === 1 ? "y" : "ies"} the database rejected`);
+			if (remaining.length > 0) throw new PartialWriteError("MongoDB insert partially failed", remaining, error);
+		}
 	}
 	async flushToPostgreSQL(entries) {
 		const tableName = this.config.table || "logs";
@@ -525,7 +765,7 @@ var DatabaseTransport = class {
 			entry.traceId,
 			entry.appName,
 			entry.environment
-		]), POSTGRES_ROWS_PER_INSERT);
+		].map((value, column) => stripNul(column === 3 ? stripJsonNulEscape(value) : value))), POSTGRES_ROWS_PER_INSERT);
 		const insertChunk = async (rows) => {
 			const query = `
       INSERT INTO ${tableName} 
@@ -685,6 +925,7 @@ var DatabaseTransport = class {
 			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`);
+		this.cap.report(0);
 		if (this.connection) switch (this.config.type) {
 			case "mongodb":
 				await this.connection.close();
@@ -747,6 +988,12 @@ 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 DEFAULT_MAX_QUEUE = 1e4;
+const DEFAULT_FILE_MODE = 384;
+const DEFAULT_DIR_MODE = 448;
+function csvField(value) {
+	return `"${stripControlChars(safeToString(value)).replace(/"/g, "\"\"")}"`;
+}
 const SIZE_UNITS = {
 	"": 1,
 	k: 1024,
@@ -782,6 +1029,10 @@ function formatDatePattern(date, pattern) {
 * 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.
 *
+* Files are created with mode 0o600 and directories with 0o700; override with
+* `fileMode` and `dirMode`. At most `maxQueue` (default 10000) entries wait in
+* memory; the rest are dropped per `queuePolicy` and counted in a warning.
+*
 * @example
 * transports: { file: { filename: 'app.log', dirname: './logs', maxSize: '50MB' } }
 */
@@ -816,8 +1067,10 @@ var FileTransport = class {
 		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;
+		if (maxQueue !== void 0 && !(Number.isInteger(maxQueue) && maxQueue > 0)) internalWarn(`FileTransport: maxQueue ${String(maxQueue)} is not a positive integer; using ${DEFAULT_MAX_QUEUE}`);
+		this.maxQueue = maxQueue !== void 0 && Number.isInteger(maxQueue) && maxQueue > 0 ? maxQueue : DEFAULT_MAX_QUEUE;
+		this.fileMode = config.fileMode ?? DEFAULT_FILE_MODE;
+		this.dirMode = config.dirMode ?? DEFAULT_DIR_MODE;
 		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;
@@ -827,7 +1080,10 @@ var FileTransport = class {
 		this.ext = node_path.extname(config.filename);
 		this.base = node_path.basename(config.filename, this.ext);
 		try {
-			node_fs.mkdirSync(this.dir, { recursive: true });
+			node_fs.mkdirSync(this.dir, {
+				recursive: true,
+				mode: this.dirMode
+			});
 		} catch (error) {
 			internalError(`FileTransport could not create ${this.dir}`, error);
 		}
@@ -895,7 +1151,7 @@ var FileTransport = class {
 		this.enqueued += 1;
 	}
 	queueFull() {
-		return this.maxQueue !== void 0 && this.batch.length + this.inFlight >= this.maxQueue;
+		return this.batch.length + this.inFlight >= this.maxQueue;
 	}
 	roomAvailable() {
 		const room = new Promise((resolve) => this.spaceWaiters.push(resolve));
@@ -975,30 +1231,26 @@ var FileTransport = class {
 	}
 	formatEntry(entry) {
 		switch (this.config.format) {
-			case "json": return stringifyForLog({
+			case "json": return stringifyForLog(mergeCoreFields({
 				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(",");
-			}
+				message: entry.message
+			}, entry.data));
+			case "csv": return [
+				entry.timestamp.toISOString(),
+				csvField(entry.level),
+				csvField(entry.message),
+				csvField(entry.context),
+				csvField(entry.traceId),
+				csvField(stringifyForLog(entry.data || {}))
+			].join(",");
 			case "text":
-			default: return `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${safeToString(entry.message)}${entry.data ? " " + stringifyForLog(entry.data) : ""}`;
+			default: return `${entry.timestamp.toISOString()} [${stripControlChars(safeToString(entry.level)).toUpperCase()}] ${stripControlChars(safeToString(entry.message))}${entry.data ? " " + stringifyForLog(entry.data) : ""}`;
 		}
 	}
 	addToBatch(entry) {
 		this.enqueue(entry);
-		const threshold = Math.min(this.config.batchSize || 100, this.maxQueue ?? Infinity);
+		const threshold = Math.min(this.config.batchSize || 100, this.maxQueue);
 		if (this.batch.length >= threshold && !this.draining) {
 			if (this.batchTimer) {
 				clearTimeout(this.batchTimer);
@@ -1036,7 +1288,7 @@ var FileTransport = class {
 		if (chunk$1) await this.append(chunk$1, chunkBytes);
 	}
 	async append(content, bytes = Buffer.byteLength(content)) {
-		await appendFile(this.currentFilePath, content);
+		await appendFile(this.currentFilePath, content, { mode: this.fileMode });
 		this.bytesWritten += bytes;
 	}
 	timeToRotate() {
@@ -1130,7 +1382,7 @@ var FileTransport = class {
 	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 (0, node_stream_promises.pipeline)(node_fs.createReadStream(filePath), (0, node_zlib.createGzip)(), node_fs.createWriteStream(gzPath, { mode: this.fileMode }));
 			await unlink(filePath);
 		} catch (error) {
 			internalError("Failed to compress rotated log file", error);

package/dist/worker.d.mts

@@ -1,3 +1,3 @@
-import "./transport.types-B5vcyv2k.mjs";
-import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-BP8Q28Z2.mjs";
+import "./transport.types-CtNr3D7S.mjs";
+import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-Bgv9heDI.mjs";
 export { WorkerTransport, WorkerTransportConfig };

package/dist/worker.d.ts

@@ -1,3 +1,3 @@
-import "./transport.types-BuY84TwO.js";
-import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-mKXgNK0L.js";
+import "./transport.types-DqVLZTyf.js";
+import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-Bj-i0P9V.js";
 export { WorkerTransport, WorkerTransportConfig };

package/dist/worker.js

@@ -1,4 +1,4 @@
 require('./internal-log-BUJYMZbE.js');
-const require_worker_transport = require('./worker.transport-CfH6z37Z.js');
+const require_worker_transport = require('./worker.transport-JP8YHBuU.js');
 
 exports.WorkerTransport = require_worker_transport.WorkerTransport;

package/dist/worker.mjs

@@ -1,4 +1,4 @@
 import "./internal-log-Cm8SOWSV.mjs";
-import { t as WorkerTransport } from "./worker.transport-BhMyvqQ2.mjs";
+import { t as WorkerTransport } from "./worker.transport-otwhJ_Et.mjs";
 
 export { WorkerTransport };

package/dist/{worker.transport-BP8Q28Z2.d.mts → worker.transport-Bgv9heDI.d.mts}

@@ -1,4 +1,4 @@
-import { l as ITransport, p as TransportLogEntry } from "./transport.types-B5vcyv2k.mjs";
+import { l as ITransport, p as TransportLogEntry } from "./transport.types-CtNr3D7S.mjs";
 
 //#region src/transports/worker.transport.d.ts
 
@@ -73,4 +73,4 @@ declare class WorkerTransport implements ITransport {
 }
 //#endregion
 export { WorkerTransportConfig as n, WorkerTransport as t };
-//# sourceMappingURL=worker.transport-BP8Q28Z2.d.mts.map
+//# sourceMappingURL=worker.transport-Bgv9heDI.d.mts.map

package/dist/{worker.transport-BP8Q28Z2.d.mts.map → worker.transport-Bgv9heDI.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"worker.transport-BP8Q28Z2.d.mts","names":[],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":[],"mappings":";;;;UAuCiB,qBAAA;;;;;;;mBAOE;;;;;;;;;;;;;;;;;;;;;;cAuBN,eAAA,YAA2B;;;;;;;;;;;;;;;;;;;;sBAsBlB;;;;;;eAiFP;WAYE;;;;;;;;WAiCA;;cAkCG"}
+{"version":3,"file":"worker.transport-Bgv9heDI.d.mts","names":[],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":[],"mappings":";;;;UAuCiB,qBAAA;;;;;;;mBAOE;;;;;;;;;;;;;;;;;;;;;;cAuBN,eAAA,YAA2B;;;;;;;;;;;;;;;;;;;;sBAsBlB;;;;;;eAiFP;WAYE;;;;;;;;WAiCA;;cAkCG"}

package/dist/{worker.transport-mKXgNK0L.d.ts → worker.transport-Bj-i0P9V.d.ts}

@@ -1,4 +1,4 @@
-import { l as ITransport, p as TransportLogEntry } from "./transport.types-BuY84TwO.js";
+import { l as ITransport, p as TransportLogEntry } from "./transport.types-DqVLZTyf.js";
 
 //#region src/transports/worker.transport.d.ts
 
@@ -73,4 +73,4 @@ declare class WorkerTransport implements ITransport {
 }
 //#endregion
 export { WorkerTransportConfig as n, WorkerTransport as t };
-//# sourceMappingURL=worker.transport-mKXgNK0L.d.ts.map
+//# sourceMappingURL=worker.transport-Bj-i0P9V.d.ts.map

package/dist/{worker.transport-mKXgNK0L.d.ts.map → worker.transport-Bj-i0P9V.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"worker.transport-mKXgNK0L.d.ts","names":[],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":[],"mappings":";;;;UAuCiB,qBAAA;;;;;;;mBAOE;;;;;;;;;;;;;;;;;;;;;;cAuBN,eAAA,YAA2B;;;;;;;;;;;;;;;;;;;;sBAsBlB;;;;;;eAiFP;WAYE;;;;;;;;WAiCA;;cAkCG"}
+{"version":3,"file":"worker.transport-Bj-i0P9V.d.ts","names":[],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":[],"mappings":";;;;UAuCiB,qBAAA;;;;;;;mBAOE;;;;;;;;;;;;;;;;;;;;;;cAuBN,eAAA,YAA2B;;;;;;;;;;;;;;;;;;;;sBAsBlB;;;;;;eAiFP;WAYE;;;;;;;;WAiCA;;cAkCG"}

package/dist/{worker.transport-CfH6z37Z.js → worker.transport-JP8YHBuU.js}

@@ -165,4 +165,4 @@ Object.defineProperty(exports, 'WorkerTransport', {
     return WorkerTransport;
   }
 });
-//# sourceMappingURL=worker.transport-CfH6z37Z.js.map
+//# sourceMappingURL=worker.transport-JP8YHBuU.js.map

package/dist/{worker.transport-CfH6z37Z.js.map → worker.transport-JP8YHBuU.js.map}

@@ -1 +1 @@
-{"version":3,"file":"worker.transport-CfH6z37Z.js","names":["Worker","path"],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":["/**\n * logixia — Worker Thread Transport\n *\n * Offloads JSON serialization and all I/O to a Node.js worker thread,\n * completely eliminating any event-loop impact from logging. The main thread\n * only posts a raw message to the worker — it never calls JSON.stringify or\n * any I/O syscalls on the hot path.\n *\n * Architecture:\n *   Main thread  →  MessageChannel  →  Worker thread  →  Wrapped transport\n *\n * The worker runs an ordinary logixia transport (file, database, console…)\n * inside its own event loop. If the worker crashes it is restarted automatically\n * (up to `maxRestarts` times) and buffered messages are replayed.\n *\n * @example\n * ```ts\n * import { WorkerTransport } from 'logixia/worker';\n *\n * const logger = createLogger({\n *   transports: {\n *     // Run file transport inside a worker thread — zero event-loop impact\n *     worker: new WorkerTransport({\n *       transportType: 'file',\n *       transportConfig: { filename: 'app.log', dirname: './logs' },\n *       bufferSize: 500,\n *       maxRestarts: 3,\n *     }),\n *   },\n * });\n * ```\n */\n\nimport path from 'node:path';\nimport { Worker } from 'node:worker_threads';\n\nimport type { ITransport, TransportLogEntry } from '../types/transport.types';\nimport { internalError, internalWarn } from '../utils/internal-log';\n\nexport interface WorkerTransportConfig {\n  /**\n   * Which built-in logixia transport to run inside the worker thread.\n   * The worker resolves the correct module automatically.\n   */\n  transportType: 'file' | 'database' | 'console';\n  /** Config forwarded verbatim to the wrapped transport constructor. */\n  transportConfig: Record<string, unknown>;\n  /**\n   * Max log entries to buffer in the main thread while the worker is starting\n   * or restarting. Entries beyond this limit are dropped with a warning.\n   * @default 1000\n   */\n  bufferSize?: number;\n  /**\n   * How many times to restart the worker if it crashes unexpectedly.\n   * @default 3\n   */\n  maxRestarts?: number;\n  /**\n   * Log level filter — only entries at or above this level are forwarded.\n   * Useful for routing only errors to an expensive transport in a worker.\n   */\n  level?: string;\n}\n\n/**\n * Transport that runs a wrapped transport inside a dedicated Node.js worker\n * thread, completely removing JSON serialization and I/O from the main event loop.\n */\nexport class WorkerTransport implements ITransport {\n  public readonly name = 'worker';\n  public readonly level: string | undefined;\n  public readonly batchSize = 1;\n  public readonly flushInterval = 0;\n\n  private worker: Worker | null = null;\n  private ready = false;\n  private readonly buffer: TransportLogEntry[] = [];\n  private readonly bufferSize: number;\n  private restarts = 0;\n  private readonly maxRestarts: number;\n  private readonly config: WorkerTransportConfig;\n  /** Pending restart-backoff timer, so close() can cancel a queued restart. */\n  private restartTimer: NodeJS.Timeout | null = null;\n  /** Set once close() begins, so a worker 'exit' no longer triggers a restart. */\n  private closing = false;\n  /** Max time to wait for the worker's 'flushed' ack before giving up. */\n  private readonly FLUSH_TIMEOUT_MS = 5000;\n  /** Max time to wait for a graceful worker exit before force-terminating. */\n  private readonly SHUTDOWN_TIMEOUT_MS = 5000;\n\n  constructor(config: WorkerTransportConfig) {\n    this.config = config;\n    this.bufferSize = config.bufferSize ?? 1000;\n    this.maxRestarts = config.maxRestarts ?? 3;\n    this.level = config.level;\n    this.startWorker();\n  }\n\n  private startWorker(): void {\n    try {\n      this.worker = new Worker(this.workerFile(), {\n        workerData: {\n          transportType: this.config.transportType,\n          transportConfig: this.config.transportConfig,\n        },\n      });\n\n      this.worker.on('message', (msg: { type: string; error?: string }) => {\n        if (msg.type === 'ready') {\n          this.ready = true;\n          this.drainBuffer();\n        } else if (msg.type === 'error' || msg.type === 'write-error') {\n          internalError(\n            `WorkerTransport [${this.config.transportType}]: ${msg.error ?? 'unknown'}`\n          );\n        }\n      });\n\n      this.worker.on('error', (err) => {\n        internalError('WorkerTransport worker error', err);\n        this.handleWorkerExit();\n      });\n\n      this.worker.on('exit', (code) => {\n        if (code !== 0) {\n          internalWarn(`WorkerTransport worker exited with code ${code}`);\n          this.handleWorkerExit();\n        }\n      });\n    } catch (err) {\n      internalError('WorkerTransport failed to start', err);\n    }\n  }\n\n  /** The worker entry is always built as CommonJS, next to this module's output. */\n  protected workerFile(): string {\n    return path.join(__dirname, 'worker-entry.js');\n  }\n\n  private handleWorkerExit(): void {\n    this.ready = false;\n    // Don't resurrect a worker we're intentionally shutting down — close() sets\n    // `closing` and nulls the worker, so a late 'exit'/'error' event must not\n    // queue a restart (which would spawn a fresh leaked thread post-shutdown).\n    if (this.closing) return;\n    if (this.restarts < this.maxRestarts) {\n      this.restarts++;\n      internalWarn(`WorkerTransport restarting (attempt ${this.restarts}/${this.maxRestarts})`);\n      // Small backoff before restart. unref() so a perpetually-failing worker's\n      // pending restart never keeps the process alive on its own.\n      this.restartTimer = setTimeout(() => {\n        this.restartTimer = null;\n        this.startWorker();\n      }, 500 * this.restarts);\n      if (this.restartTimer.unref) this.restartTimer.unref();\n    } else {\n      internalError(\n        `WorkerTransport exhausted ${this.maxRestarts} restart attempts — transport disabled`\n      );\n    }\n  }\n\n  private drainBuffer(): void {\n    while (this.buffer.length > 0 && this.ready && this.worker) {\n      const entry = this.buffer.shift();\n      if (entry) {\n        this.worker.postMessage({ type: 'write', entry });\n      }\n    }\n  }\n\n  write(entry: TransportLogEntry): void {\n    if (this.ready && this.worker) {\n      this.worker.postMessage({ type: 'write', entry });\n    } else {\n      if (this.buffer.length >= this.bufferSize) {\n        internalWarn('WorkerTransport buffer full — dropping oldest entry');\n        this.buffer.shift();\n      }\n      this.buffer.push(entry);\n    }\n  }\n\n  async flush(): Promise<void> {\n    if (!this.ready || !this.worker) return;\n    const worker = this.worker;\n    return new Promise<void>((resolve) => {\n      // Time-box the flush: if the worker dies or restarts before answering,\n      // the 'flushed' message would never arrive and this promise would hang\n      // forever, blocking shutdown until the force-exit timer kills the process\n      // (losing everything). Resolve on timeout so close() can still terminate.\n      const timer = setTimeout(() => {\n        worker.off('message', handler);\n        resolve();\n      }, this.FLUSH_TIMEOUT_MS);\n      if (timer.unref) timer.unref();\n\n      const handler = (msg: { type: string }) => {\n        if (msg.type === 'flushed') {\n          clearTimeout(timer);\n          worker.off('message', handler);\n          resolve();\n        }\n      };\n      worker.on('message', handler);\n      worker.postMessage({ type: 'flush' });\n    });\n  }\n\n  /**\n   * Flush the worker's buffer and terminate the thread on shutdown.\n   *\n   * This MUST be named close() — TransportManager.close() invokes\n   * transport.close(), so a method named only shutdown() was never called on\n   * graceful exit, leaking the worker thread and dropping its buffered logs.\n   */\n  async close(): Promise<void> {\n    // Stop the restart loop first: cancel any queued backoff restart and flag\n    // that further worker exits are expected (so handleWorkerExit no-ops).\n    this.closing = true;\n    if (this.restartTimer) {\n      clearTimeout(this.restartTimer);\n      this.restartTimer = null;\n    }\n\n    if (!this.worker) return;\n    const worker = this.worker;\n    this.worker = null;\n\n    // Push any locally-buffered (pre-ready) entries first: the worker's port\n    // queues them until its listener attaches, so they are handled before the\n    // shutdown message, which flushes the wrapped transport and exits.\n    this.drainBufferTo(worker);\n    worker.postMessage({ type: 'shutdown' });\n\n    await new Promise<void>((resolve) => {\n      // Don't wait forever for a wedged worker — terminate() it after a timeout.\n      const timer = setTimeout(() => {\n        worker.terminate().finally(() => resolve());\n      }, this.SHUTDOWN_TIMEOUT_MS);\n      if (timer.unref) timer.unref();\n\n      worker.once('exit', () => {\n        clearTimeout(timer);\n        resolve();\n      });\n    });\n  }\n\n  /** Back-compat alias — prefer close(). */\n  async shutdown(): Promise<void> {\n    await this.close();\n  }\n\n  private drainBufferTo(worker: Worker): void {\n    while (this.buffer.length > 0) {\n      const entry = this.buffer.shift();\n      if (entry) worker.postMessage({ type: 'write', entry });\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"worker.transport-JP8YHBuU.js","names":["Worker","path"],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":["/**\n * logixia — Worker Thread Transport\n *\n * Offloads JSON serialization and all I/O to a Node.js worker thread,\n * completely eliminating any event-loop impact from logging. The main thread\n * only posts a raw message to the worker — it never calls JSON.stringify or\n * any I/O syscalls on the hot path.\n *\n * Architecture:\n *   Main thread  →  MessageChannel  →  Worker thread  →  Wrapped transport\n *\n * The worker runs an ordinary logixia transport (file, database, console…)\n * inside its own event loop. If the worker crashes it is restarted automatically\n * (up to `maxRestarts` times) and buffered messages are replayed.\n *\n * @example\n * ```ts\n * import { WorkerTransport } from 'logixia/worker';\n *\n * const logger = createLogger({\n *   transports: {\n *     // Run file transport inside a worker thread — zero event-loop impact\n *     worker: new WorkerTransport({\n *       transportType: 'file',\n *       transportConfig: { filename: 'app.log', dirname: './logs' },\n *       bufferSize: 500,\n *       maxRestarts: 3,\n *     }),\n *   },\n * });\n * ```\n */\n\nimport path from 'node:path';\nimport { Worker } from 'node:worker_threads';\n\nimport type { ITransport, TransportLogEntry } from '../types/transport.types';\nimport { internalError, internalWarn } from '../utils/internal-log';\n\nexport interface WorkerTransportConfig {\n  /**\n   * Which built-in logixia transport to run inside the worker thread.\n   * The worker resolves the correct module automatically.\n   */\n  transportType: 'file' | 'database' | 'console';\n  /** Config forwarded verbatim to the wrapped transport constructor. */\n  transportConfig: Record<string, unknown>;\n  /**\n   * Max log entries to buffer in the main thread while the worker is starting\n   * or restarting. Entries beyond this limit are dropped with a warning.\n   * @default 1000\n   */\n  bufferSize?: number;\n  /**\n   * How many times to restart the worker if it crashes unexpectedly.\n   * @default 3\n   */\n  maxRestarts?: number;\n  /**\n   * Log level filter — only entries at or above this level are forwarded.\n   * Useful for routing only errors to an expensive transport in a worker.\n   */\n  level?: string;\n}\n\n/**\n * Transport that runs a wrapped transport inside a dedicated Node.js worker\n * thread, completely removing JSON serialization and I/O from the main event loop.\n */\nexport class WorkerTransport implements ITransport {\n  public readonly name = 'worker';\n  public readonly level: string | undefined;\n  public readonly batchSize = 1;\n  public readonly flushInterval = 0;\n\n  private worker: Worker | null = null;\n  private ready = false;\n  private readonly buffer: TransportLogEntry[] = [];\n  private readonly bufferSize: number;\n  private restarts = 0;\n  private readonly maxRestarts: number;\n  private readonly config: WorkerTransportConfig;\n  /** Pending restart-backoff timer, so close() can cancel a queued restart. */\n  private restartTimer: NodeJS.Timeout | null = null;\n  /** Set once close() begins, so a worker 'exit' no longer triggers a restart. */\n  private closing = false;\n  /** Max time to wait for the worker's 'flushed' ack before giving up. */\n  private readonly FLUSH_TIMEOUT_MS = 5000;\n  /** Max time to wait for a graceful worker exit before force-terminating. */\n  private readonly SHUTDOWN_TIMEOUT_MS = 5000;\n\n  constructor(config: WorkerTransportConfig) {\n    this.config = config;\n    this.bufferSize = config.bufferSize ?? 1000;\n    this.maxRestarts = config.maxRestarts ?? 3;\n    this.level = config.level;\n    this.startWorker();\n  }\n\n  private startWorker(): void {\n    try {\n      this.worker = new Worker(this.workerFile(), {\n        workerData: {\n          transportType: this.config.transportType,\n          transportConfig: this.config.transportConfig,\n        },\n      });\n\n      this.worker.on('message', (msg: { type: string; error?: string }) => {\n        if (msg.type === 'ready') {\n          this.ready = true;\n          this.drainBuffer();\n        } else if (msg.type === 'error' || msg.type === 'write-error') {\n          internalError(\n            `WorkerTransport [${this.config.transportType}]: ${msg.error ?? 'unknown'}`\n          );\n        }\n      });\n\n      this.worker.on('error', (err) => {\n        internalError('WorkerTransport worker error', err);\n        this.handleWorkerExit();\n      });\n\n      this.worker.on('exit', (code) => {\n        if (code !== 0) {\n          internalWarn(`WorkerTransport worker exited with code ${code}`);\n          this.handleWorkerExit();\n        }\n      });\n    } catch (err) {\n      internalError('WorkerTransport failed to start', err);\n    }\n  }\n\n  /** The worker entry is always built as CommonJS, next to this module's output. */\n  protected workerFile(): string {\n    return path.join(__dirname, 'worker-entry.js');\n  }\n\n  private handleWorkerExit(): void {\n    this.ready = false;\n    // Don't resurrect a worker we're intentionally shutting down — close() sets\n    // `closing` and nulls the worker, so a late 'exit'/'error' event must not\n    // queue a restart (which would spawn a fresh leaked thread post-shutdown).\n    if (this.closing) return;\n    if (this.restarts < this.maxRestarts) {\n      this.restarts++;\n      internalWarn(`WorkerTransport restarting (attempt ${this.restarts}/${this.maxRestarts})`);\n      // Small backoff before restart. unref() so a perpetually-failing worker's\n      // pending restart never keeps the process alive on its own.\n      this.restartTimer = setTimeout(() => {\n        this.restartTimer = null;\n        this.startWorker();\n      }, 500 * this.restarts);\n      if (this.restartTimer.unref) this.restartTimer.unref();\n    } else {\n      internalError(\n        `WorkerTransport exhausted ${this.maxRestarts} restart attempts — transport disabled`\n      );\n    }\n  }\n\n  private drainBuffer(): void {\n    while (this.buffer.length > 0 && this.ready && this.worker) {\n      const entry = this.buffer.shift();\n      if (entry) {\n        this.worker.postMessage({ type: 'write', entry });\n      }\n    }\n  }\n\n  write(entry: TransportLogEntry): void {\n    if (this.ready && this.worker) {\n      this.worker.postMessage({ type: 'write', entry });\n    } else {\n      if (this.buffer.length >= this.bufferSize) {\n        internalWarn('WorkerTransport buffer full — dropping oldest entry');\n        this.buffer.shift();\n      }\n      this.buffer.push(entry);\n    }\n  }\n\n  async flush(): Promise<void> {\n    if (!this.ready || !this.worker) return;\n    const worker = this.worker;\n    return new Promise<void>((resolve) => {\n      // Time-box the flush: if the worker dies or restarts before answering,\n      // the 'flushed' message would never arrive and this promise would hang\n      // forever, blocking shutdown until the force-exit timer kills the process\n      // (losing everything). Resolve on timeout so close() can still terminate.\n      const timer = setTimeout(() => {\n        worker.off('message', handler);\n        resolve();\n      }, this.FLUSH_TIMEOUT_MS);\n      if (timer.unref) timer.unref();\n\n      const handler = (msg: { type: string }) => {\n        if (msg.type === 'flushed') {\n          clearTimeout(timer);\n          worker.off('message', handler);\n          resolve();\n        }\n      };\n      worker.on('message', handler);\n      worker.postMessage({ type: 'flush' });\n    });\n  }\n\n  /**\n   * Flush the worker's buffer and terminate the thread on shutdown.\n   *\n   * This MUST be named close() — TransportManager.close() invokes\n   * transport.close(), so a method named only shutdown() was never called on\n   * graceful exit, leaking the worker thread and dropping its buffered logs.\n   */\n  async close(): Promise<void> {\n    // Stop the restart loop first: cancel any queued backoff restart and flag\n    // that further worker exits are expected (so handleWorkerExit no-ops).\n    this.closing = true;\n    if (this.restartTimer) {\n      clearTimeout(this.restartTimer);\n      this.restartTimer = null;\n    }\n\n    if (!this.worker) return;\n    const worker = this.worker;\n    this.worker = null;\n\n    // Push any locally-buffered (pre-ready) entries first: the worker's port\n    // queues them until its listener attaches, so they are handled before the\n    // shutdown message, which flushes the wrapped transport and exits.\n    this.drainBufferTo(worker);\n    worker.postMessage({ type: 'shutdown' });\n\n    await new Promise<void>((resolve) => {\n      // Don't wait forever for a wedged worker — terminate() it after a timeout.\n      const timer = setTimeout(() => {\n        worker.terminate().finally(() => resolve());\n      }, this.SHUTDOWN_TIMEOUT_MS);\n      if (timer.unref) timer.unref();\n\n      worker.once('exit', () => {\n        clearTimeout(timer);\n        resolve();\n      });\n    });\n  }\n\n  /** Back-compat alias — prefer close(). */\n  async shutdown(): Promise<void> {\n    await this.close();\n  }\n\n  private drainBufferTo(worker: Worker): void {\n    while (this.buffer.length > 0) {\n      const entry = this.buffer.shift();\n      if (entry) worker.postMessage({ type: 'write', entry });\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/{worker.transport-BhMyvqQ2.mjs → worker.transport-otwhJ_Et.mjs}

@@ -164,4 +164,4 @@ var WorkerTransport = class {
 
 //#endregion
 export { WorkerTransport as t };
-//# sourceMappingURL=worker.transport-BhMyvqQ2.mjs.map
+//# sourceMappingURL=worker.transport-otwhJ_Et.mjs.map