logixia 2.0.10 → 2.0.11

package/dist/worker-entry.js

@@ -243,12 +243,35 @@ function mergeCoreFields(core, data, extraReserved = []) {
 * transports: { console: { format: 'json' } }
 */
 var ConsoleTransport = class ConsoleTransport {
+	config;
+	name = "console";
+	level;
+	filter;
+	static COLORS = /* @__PURE__ */ 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 sanitize(value) {
 		return stripControlChars(safeToString(value));
 	}
 	constructor(config = {}) {
 		this.config = config;
-		this.name = "console";
 		this.level = config.level;
 		if (config.filter) this.filter = config.filter;
 	}
@@ -312,26 +335,6 @@ var ConsoleTransport = class ConsoleTransport {
 	close() {
 		return Promise.resolve();
 	}
-	static #_ = () => this.COLORS = /* @__PURE__ */ 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"]
-	]);
 };
 // src/utils/internal-log.ts
 /**
@@ -396,10 +399,12 @@ const DROP_WARN_INTERVAL_MS$1 = 5e3;
 * A cap below `batchSize` is raised to `batchSize` so one batch always fits.
 */
 var BufferCap = class {
+	name;
+	max;
+	dropped = 0;
+	lastWarning = 0;
 	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;
@@ -777,6 +782,7 @@ function isDataError(type, error) {
 }
 /** A write that stored part of a batch: only `remaining` still needs to be written. */
 var PartialWriteError = class extends Error {
+	remaining;
 	constructor(message, remaining, cause) {
 		super(message, { cause });
 		this.remaining = remaining;
@@ -803,11 +809,28 @@ function validateSqlIdentifier(name, label = "table") {
 * }
 */
 var DatabaseTransport = class {
+	config;
+	name = "database";
+	batchSize;
+	flushInterval;
+	level;
+	filter;
+	batch = [];
+	flushTimer;
+	/**
+	* The in-flight drain promise, or undefined when idle. Concurrent flush()
+	* calls (the un-awaited threshold flush write() fires, plus the interval
+	* timer) all await this single promise instead of starting their own drain,
+	* so a batch is never snapshotted and written twice. Mirrors the FileTransport
+	* fix for the overlapping-batch-flush duplication bug.
+	*/
+	flushPromise;
+	connection;
+	isConnected = false;
+	connectionPromise;
+	cap;
 	constructor(config) {
 		this.config = config;
-		this.name = "database";
-		this.batch = [];
-		this.isConnected = false;
 		protectSecrets(this, ["config", "connection"]);
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
@@ -1308,6 +1331,23 @@ var DatabaseTransport = class {
 		}
 	}
 };
+// src/utils/csv.utils.ts
+const CSV_FORMULA_PREFIX = /^[=+\-@\t\r]/;
+/**
+* Render one CSV field. String values that a spreadsheet would treat as a
+* formula (leading `=`, `+`, `-`, `@`, tab or CR) are prefixed with `'`.
+* Objects are JSON-encoded. Fields containing a comma, quote, CR or LF are quoted;
+* `alwaysQuote` quotes every field. `null` / `undefined` render as empty.
+*/
+function csvField$1(value, alwaysQuote = false) {
+	if (value === void 0 || value === null) return alwaysQuote ? "\"\"" : "";
+	let str;
+	if (typeof value === "string") str = CSV_FORMULA_PREFIX.test(value) ? `'${value}` : value;
+	else if (typeof value === "object") str = JSON.stringify(value);
+	else str = String(value);
+	if (alwaysQuote || /[",\r\n]/.test(str)) return `"${str.replace(/"/g, "\"\"")}"`;
+	return str;
+}
 // src/transports/file.transport.ts
 const appendFile = (0, node_util.promisify)(node_fs.appendFile);
 const rename = (0, node_util.promisify)(node_fs.rename);
@@ -1319,7 +1359,7 @@ const DEFAULT_MAX_QUEUE = 1e4;
 const DEFAULT_FILE_MODE = 384;
 const DEFAULT_DIR_MODE = 448;
 function csvField(value) {
-	return `"${stripControlChars(safeToString(value)).replace(/"/g, "\"\"")}"`;
+	return csvField$1(stripControlChars(safeToString(value)), true);
 }
 const SIZE_UNITS = {
 	"": 1,
@@ -1364,21 +1404,49 @@ function formatDatePattern(date, pattern) {
 * transports: { file: { filename: 'app.log', dirname: './logs', maxSize: '50MB' } }
 */
 var FileTransport = class {
+	name = "file";
+	level;
+	batchSize;
+	flushInterval;
+	filter;
+	config;
+	maxBytes;
+	maxFiles;
+	compress;
+	intervalMs;
+	timestampedActive;
+	dir;
+	base;
+	ext;
+	batch = [];
+	batchTimer;
+	lastRotation = /* @__PURE__ */ new Date();
+	currentFilePath;
+	bytesWritten = 0;
+	period;
+	rotateRequested = false;
+	rotationWaiters = [];
+	/**
+	* The one drain loop, or undefined when idle. Only one ever runs, so the batch
+	* is never snapshotted and written twice, and rotation (which runs inside it)
+	* never races a write.
+	*/
+	draining;
+	/** Entries queued and entries written (or failed) so far; flush() waits on these. */
+	enqueued = 0;
+	settled = 0;
+	flushWaiters = [];
+	maxQueue;
+	fileMode;
+	dirMode;
+	queuePolicy;
+	spaceWaiters = [];
+	inFlight = 0;
+	dropped = 0;
+	lastDropWarning = 0;
+	/** Gzip and pruning of rotated files run off the write path, one at a time. */
+	housekeeping = Promise.resolve();
 	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,

package/dist/worker.js

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_worker_transport = require("./worker.transport-DQDv1nAJ.js");
+const require_worker_transport = require("./worker.transport-CwNpH98o.js");
 exports.WorkerTransport = require_worker_transport.WorkerTransport;

package/dist/worker.mjs

@@ -1 +1 @@
-export { t as WorkerTransport } from "./worker.transport-D78xhNhB.mjs";
+export { t as WorkerTransport } from "./worker.transport-DgK_ZXlB.mjs";

package/dist/{worker.transport-DQDv1nAJ.js → worker.transport-CwNpH98o.js}

@@ -1,4 +1,4 @@
-const require_secret_config = require("./secret-config-BvFl2dC8.js");
+const require_secret_config = require("./secret-config-6hdODxBb.js");
 const require_internal_log = require("./internal-log-DwqTjhpb.js");
 let node_path = require("node:path");
 node_path = require_secret_config.__toESM(node_path);
@@ -43,18 +43,26 @@ let node_worker_threads = require("node:worker_threads");
 * thread, completely removing JSON serialization and I/O from the main event loop.
 */
 var WorkerTransport = class {
+	name = "worker";
+	level;
+	batchSize = 1;
+	flushInterval = 0;
+	worker = null;
+	ready = false;
+	buffer = [];
+	bufferSize;
+	restarts = 0;
+	maxRestarts;
+	config;
+	/** Pending restart-backoff timer, so close() can cancel a queued restart. */
+	restartTimer = null;
+	/** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
+	closing = false;
+	/** Max time to wait for the worker's 'flushed' ack before giving up. */
+	FLUSH_TIMEOUT_MS = 5e3;
+	/** Max time to wait for a graceful worker exit before force-terminating. */
+	SHUTDOWN_TIMEOUT_MS = 5e3;
 	constructor(config) {
-		this.name = "worker";
-		this.batchSize = 1;
-		this.flushInterval = 0;
-		this.worker = null;
-		this.ready = false;
-		this.buffer = [];
-		this.restarts = 0;
-		this.restartTimer = null;
-		this.closing = false;
-		this.FLUSH_TIMEOUT_MS = 5e3;
-		this.SHUTDOWN_TIMEOUT_MS = 5e3;
 		this.config = config;
 		this.bufferSize = config.bufferSize ?? 1e3;
 		this.maxRestarts = config.maxRestarts ?? 3;
@@ -198,4 +206,4 @@ Object.defineProperty(exports, "WorkerTransport", {
 	}
 });
 
-//# sourceMappingURL=worker.transport-DQDv1nAJ.js.map
+//# sourceMappingURL=worker.transport-CwNpH98o.js.map

package/dist/{worker.transport-DQDv1nAJ.js.map → worker.transport-CwNpH98o.js.map}

@@ -1 +1 @@
-{"version":3,"file":"worker.transport-DQDv1nAJ.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 *     custom: [\n *       new WorkerTransport({\n *         transportType: 'file',\n *         transportConfig: { filename: 'app.log', dirname: './logs' },\n *         bufferSize: 500,\n *         maxRestarts: 3,\n *       }),\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';\nimport { protectSecrets } from './secret-config';\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   * Custom level severities (`levelOptions.levels`) the wrapped transport's own\n   * `level` is compared against inside the worker. Built-in levels need no entry.\n   */\n  levels?: Record<string, 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    protectSecrets(this, ['config']);\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          levels: this.config.levels,\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-CwNpH98o.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 *     custom: [\n *       new WorkerTransport({\n *         transportType: 'file',\n *         transportConfig: { filename: 'app.log', dirname: './logs' },\n *         bufferSize: 500,\n *         maxRestarts: 3,\n *       }),\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';\nimport { protectSecrets } from './secret-config';\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   * Custom level severities (`levelOptions.levels`) the wrapped transport's own\n   * `level` is compared against inside the worker. Built-in levels need no entry.\n   */\n  levels?: Record<string, 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    protectSecrets(this, ['config']);\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          levels: this.config.levels,\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-D78xhNhB.mjs → worker.transport-DgK_ZXlB.mjs}

@@ -1,4 +1,4 @@
-import { n as protectSecrets } from "./secret-config-ByGq7kJd.mjs";
+import { n as protectSecrets } from "./secret-config-D1F4MW69.mjs";
 import { r as internalWarn, t as internalError } from "./internal-log-Cy5nF1ZL.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -47,18 +47,26 @@ const __dirname = /* @__PURE__ */ getDirname();
 * thread, completely removing JSON serialization and I/O from the main event loop.
 */
 var WorkerTransport = class {
+	name = "worker";
+	level;
+	batchSize = 1;
+	flushInterval = 0;
+	worker = null;
+	ready = false;
+	buffer = [];
+	bufferSize;
+	restarts = 0;
+	maxRestarts;
+	config;
+	/** Pending restart-backoff timer, so close() can cancel a queued restart. */
+	restartTimer = null;
+	/** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
+	closing = false;
+	/** Max time to wait for the worker's 'flushed' ack before giving up. */
+	FLUSH_TIMEOUT_MS = 5e3;
+	/** Max time to wait for a graceful worker exit before force-terminating. */
+	SHUTDOWN_TIMEOUT_MS = 5e3;
 	constructor(config) {
-		this.name = "worker";
-		this.batchSize = 1;
-		this.flushInterval = 0;
-		this.worker = null;
-		this.ready = false;
-		this.buffer = [];
-		this.restarts = 0;
-		this.restartTimer = null;
-		this.closing = false;
-		this.FLUSH_TIMEOUT_MS = 5e3;
-		this.SHUTDOWN_TIMEOUT_MS = 5e3;
 		this.config = config;
 		this.bufferSize = config.bufferSize ?? 1e3;
 		this.maxRestarts = config.maxRestarts ?? 3;
@@ -197,4 +205,4 @@ var WorkerTransport = class {
 };
 export { WorkerTransport as t };
 
-//# sourceMappingURL=worker.transport-D78xhNhB.mjs.map
+//# sourceMappingURL=worker.transport-DgK_ZXlB.mjs.map

package/dist/{worker.transport-D78xhNhB.mjs.map → worker.transport-DgK_ZXlB.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"worker.transport-D78xhNhB.mjs","names":[],"sources":["../node_modules/tsdown/esm-shims.js","../src/transports/worker.transport.ts"],"sourcesContent":["// Shim globals in esm bundle\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst getFilename = () => fileURLToPath(import.meta.url)\nconst getDirname = () => path.dirname(getFilename())\n\nexport const __dirname = /* @__PURE__ */ getDirname()\nexport const __filename = /* @__PURE__ */ getFilename()\n","/**\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 *     custom: [\n *       new WorkerTransport({\n *         transportType: 'file',\n *         transportConfig: { filename: 'app.log', dirname: './logs' },\n *         bufferSize: 500,\n *         maxRestarts: 3,\n *       }),\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';\nimport { protectSecrets } from './secret-config';\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   * Custom level severities (`levelOptions.levels`) the wrapped transport's own\n   * `level` is compared against inside the worker. Built-in levels need no entry.\n   */\n  levels?: Record<string, 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    protectSecrets(this, ['config']);\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          levels: this.config.levels,\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"],"ignoreList":[0],"mappings":";;;;;;AAIA,MAAM,oBAAoB,cAAc,YAAY,GAAG;AACvD,MAAM,mBAAmB,KAAK,QAAQ,YAAY,CAAC;AAEnD,MAAa,YAA4B,2BAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsEpD,IAAa,kBAAb,MAAmD;CAsBjD,YAAY,QAA+B;EArBpB,KAAA,OAAA;EAEK,KAAA,YAAA;EACI,KAAA,gBAAA;EAEA,KAAA,SAAA;EAChB,KAAA,QAAA;EAC+B,KAAA,SAAA,CAAC;EAE7B,KAAA,WAAA;EAI2B,KAAA,eAAA;EAE5B,KAAA,UAAA;EAEkB,KAAA,mBAAA;EAEG,KAAA,sBAAA;EAGrC,KAAK,SAAS;EACd,KAAK,aAAa,OAAO,cAAc;EACvC,KAAK,cAAc,OAAO,eAAe;EACzC,KAAK,QAAQ,OAAO;EACpB,eAAe,MAAM,CAAC,QAAQ,CAAC;EAC/B,KAAK,YAAY;CACnB;CAEA,cAA4B;EAC1B,IAAI;GACF,KAAK,SAAS,IAAI,OAAO,KAAK,WAAW,GAAG,EAC1C,YAAY;IACV,eAAe,KAAK,OAAO;IAC3B,iBAAiB,KAAK,OAAO;IAC7B,QAAQ,KAAK,OAAO;GACtB,EACF,CAAC;GAED,KAAK,OAAO,GAAG,YAAY,QAA0C;IACnE,IAAI,IAAI,SAAS,SAAS;KACxB,KAAK,QAAQ;KACb,KAAK,YAAY;IACnB,OAAO,IAAI,IAAI,SAAS,WAAW,IAAI,SAAS,eAC9C,cACE,oBAAoB,KAAK,OAAO,cAAc,KAAK,IAAI,SAAS,WAClE;GAEJ,CAAC;GAED,KAAK,OAAO,GAAG,UAAU,QAAQ;IAC/B,cAAc,gCAAgC,GAAG;IACjD,KAAK,iBAAiB;GACxB,CAAC;GAED,KAAK,OAAO,GAAG,SAAS,SAAS;IAC/B,IAAI,SAAS,GAAG;KACd,aAAa,2CAA2C,MAAM;KAC9D,KAAK,iBAAiB;IACxB;GACF,CAAC;EACH,SAAS,KAAK;GACZ,cAAc,mCAAmC,GAAG;EACtD;CACF;;CAGA,aAA+B;EAC7B,OAAO,KAAK,KAAK,WAAW,iBAAiB;CAC/C;CAEA,mBAAiC;EAC/B,KAAK,QAAQ;EAIb,IAAI,KAAK,SAAS;EAClB,IAAI,KAAK,WAAW,KAAK,aAAa;GACpC,KAAK;GACL,aAAa,uCAAuC,KAAK,SAAS,GAAG,KAAK,YAAY,EAAE;GAGxF,KAAK,eAAe,iBAAiB;IACnC,KAAK,eAAe;IACpB,KAAK,YAAY;GACnB,GAAG,MAAM,KAAK,QAAQ;GACtB,IAAI,KAAK,aAAa,OAAO,KAAK,aAAa,MAAM;EACvD,OACE,cACE,6BAA6B,KAAK,YAAY,uCAChD;CAEJ;CAEA,cAA4B;EAC1B,OAAO,KAAK,OAAO,SAAS,KAAK,KAAK,SAAS,KAAK,QAAQ;GAC1D,MAAM,QAAQ,KAAK,OAAO,MAAM;GAChC,IAAI,OACF,KAAK,OAAO,YAAY;IAAE,MAAM;IAAS;GAAM,CAAC;EAEpD;CACF;CAEA,MAAM,OAAgC;EACpC,IAAI,KAAK,SAAS,KAAK,QACrB,KAAK,OAAO,YAAY;GAAE,MAAM;GAAS;EAAM,CAAC;OAC3C;GACL,IAAI,KAAK,OAAO,UAAU,KAAK,YAAY;IACzC,aAAa,qDAAqD;IAClE,KAAK,OAAO,MAAM;GACpB;GACA,KAAK,OAAO,KAAK,KAAK;EACxB;CACF;CAEA,MAAM,QAAuB;EAC3B,IAAI,CAAC,KAAK,SAAS,CAAC,KAAK,QAAQ;EACjC,MAAM,SAAS,KAAK;EACpB,OAAO,IAAI,SAAe,YAAY;GAKpC,MAAM,QAAQ,iBAAiB;IAC7B,OAAO,IAAI,WAAW,OAAO;IAC7B,QAAQ;GACV,GAAG,KAAK,gBAAgB;GACxB,IAAI,MAAM,OAAO,MAAM,MAAM;GAE7B,MAAM,WAAW,QAA0B;IACzC,IAAI,IAAI,SAAS,WAAW;KAC1B,aAAa,KAAK;KAClB,OAAO,IAAI,WAAW,OAAO;KAC7B,QAAQ;IACV;GACF;GACA,OAAO,GAAG,WAAW,OAAO;GAC5B,OAAO,YAAY,EAAE,MAAM,QAAQ,CAAC;EACtC,CAAC;CACH;;;;;;;;CASA,MAAM,QAAuB;EAG3B,KAAK,UAAU;EACf,IAAI,KAAK,cAAc;GACrB,aAAa,KAAK,YAAY;GAC9B,KAAK,eAAe;EACtB;EAEA,IAAI,CAAC,KAAK,QAAQ;EAClB,MAAM,SAAS,KAAK;EACpB,KAAK,SAAS;EAKd,KAAK,cAAc,MAAM;EACzB,OAAO,YAAY,EAAE,MAAM,WAAW,CAAC;EAEvC,MAAM,IAAI,SAAe,YAAY;GAEnC,MAAM,QAAQ,iBAAiB;IAC7B,OAAO,UAAU,CAAC,CAAC,cAAc,QAAQ,CAAC;GAC5C,GAAG,KAAK,mBAAmB;GAC3B,IAAI,MAAM,OAAO,MAAM,MAAM;GAE7B,OAAO,KAAK,cAAc;IACxB,aAAa,KAAK;IAClB,QAAQ;GACV,CAAC;EACH,CAAC;CACH;;CAGA,MAAM,WAA0B;EAC9B,MAAM,KAAK,MAAM;CACnB;CAEA,cAAsB,QAAsB;EAC1C,OAAO,KAAK,OAAO,SAAS,GAAG;GAC7B,MAAM,QAAQ,KAAK,OAAO,MAAM;GAChC,IAAI,OAAO,OAAO,YAAY;IAAE,MAAM;IAAS;GAAM,CAAC;EACxD;CACF;AACF"}
+{"version":3,"file":"worker.transport-DgK_ZXlB.mjs","names":[],"sources":["../node_modules/tsdown/esm-shims.js","../src/transports/worker.transport.ts"],"sourcesContent":["// Shim globals in esm bundle\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst getFilename = () => fileURLToPath(import.meta.url)\nconst getDirname = () => path.dirname(getFilename())\n\nexport const __dirname = /* @__PURE__ */ getDirname()\nexport const __filename = /* @__PURE__ */ getFilename()\n","/**\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 *     custom: [\n *       new WorkerTransport({\n *         transportType: 'file',\n *         transportConfig: { filename: 'app.log', dirname: './logs' },\n *         bufferSize: 500,\n *         maxRestarts: 3,\n *       }),\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';\nimport { protectSecrets } from './secret-config';\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   * Custom level severities (`levelOptions.levels`) the wrapped transport's own\n   * `level` is compared against inside the worker. Built-in levels need no entry.\n   */\n  levels?: Record<string, 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    protectSecrets(this, ['config']);\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          levels: this.config.levels,\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"],"ignoreList":[0],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "logixia",
-  "version": "2.0.10",
-  "description": "Async-first TypeScript logger for Node, NestJS and the edge: request tracing, redaction, OpenTelemetry/OTLP export, file/database/cloud transports, sampling and log search. Winston/Pino alternative.",
+  "version": "2.0.11",
+  "description": "TypeScript logger for Node.js, NestJS and edge runtimes: structured JSON logs, request trace IDs, redaction, OpenTelemetry/OTLP and cloud transports. Pino/Winston alternative.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -171,6 +171,7 @@
     "dev:intelligent-search": "ts-node -P tsconfig.examples.json --transpile-only -r ./examples/register.js examples/intelligent-search.ts",
     "benchmark": "npm run build && node benchmarks/run.mjs",
     "check:browser": "node --experimental-vm-modules --no-warnings scripts/check-browser-entry.mjs",
+    "check:dist": "node scripts/check-dist-runtime.mjs",
     "check:exports": "node scripts/check-exports.mjs",
     "check:optional-peers": "node scripts/check-optional-peers.mjs",
     "size": "size-limit",
@@ -216,7 +217,13 @@
     "log-rotation",
     "log-search",
     "prometheus",
-    "observability"
+    "observability",
+    "nodejs-logger",
+    "json-logger",
+    "log-redaction",
+    "pii",
+    "bun",
+    "nodejs"
   ],
   "author": {
     "name": "Sanjeev Sharma",