logixia 1.12.4 → 1.12.6

package/dist/worker.d.mts

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

package/dist/worker.d.ts

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

package/dist/worker.js

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

package/dist/worker.mjs

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

package/dist/worker.transport-BP8Q28Z2.d.mts

@@ -0,0 +1,76 @@
+import { l as ITransport, p as TransportLogEntry } from "./transport.types-B5vcyv2k.mjs";
+
+//#region src/transports/worker.transport.d.ts
+
+interface WorkerTransportConfig {
+  /**
+   * Which built-in logixia transport to run inside the worker thread.
+   * The worker resolves the correct module automatically.
+   */
+  transportType: 'file' | 'database' | 'console';
+  /** Config forwarded verbatim to the wrapped transport constructor. */
+  transportConfig: Record<string, unknown>;
+  /**
+   * Max log entries to buffer in the main thread while the worker is starting
+   * or restarting. Entries beyond this limit are dropped with a warning.
+   * @default 1000
+   */
+  bufferSize?: number;
+  /**
+   * How many times to restart the worker if it crashes unexpectedly.
+   * @default 3
+   */
+  maxRestarts?: number;
+  /**
+   * Log level filter — only entries at or above this level are forwarded.
+   * Useful for routing only errors to an expensive transport in a worker.
+   */
+  level?: string;
+}
+/**
+ * Transport that runs a wrapped transport inside a dedicated Node.js worker
+ * thread, completely removing JSON serialization and I/O from the main event loop.
+ */
+declare class WorkerTransport implements ITransport {
+  readonly name = "worker";
+  readonly level: string | undefined;
+  readonly batchSize = 1;
+  readonly flushInterval = 0;
+  private worker;
+  private ready;
+  private readonly buffer;
+  private readonly bufferSize;
+  private restarts;
+  private readonly maxRestarts;
+  private readonly config;
+  /** Pending restart-backoff timer, so close() can cancel a queued restart. */
+  private restartTimer;
+  /** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
+  private closing;
+  /** Max time to wait for the worker's 'flushed' ack before giving up. */
+  private readonly FLUSH_TIMEOUT_MS;
+  /** Max time to wait for a graceful worker exit before force-terminating. */
+  private readonly SHUTDOWN_TIMEOUT_MS;
+  constructor(config: WorkerTransportConfig);
+  private startWorker;
+  /** The worker entry is always built as CommonJS, next to this module's output. */
+  protected workerFile(): string;
+  private handleWorkerExit;
+  private drainBuffer;
+  write(entry: TransportLogEntry): void;
+  flush(): Promise<void>;
+  /**
+   * Flush the worker's buffer and terminate the thread on shutdown.
+   *
+   * This MUST be named close() — TransportManager.close() invokes
+   * transport.close(), so a method named only shutdown() was never called on
+   * graceful exit, leaking the worker thread and dropping its buffered logs.
+   */
+  close(): Promise<void>;
+  /** Back-compat alias — prefer close(). */
+  shutdown(): Promise<void>;
+  private drainBufferTo;
+}
+//#endregion
+export { WorkerTransportConfig as n, WorkerTransport as t };
+//# sourceMappingURL=worker.transport-BP8Q28Z2.d.mts.map

package/dist/worker.transport-BP8Q28Z2.d.mts.map

@@ -0,0 +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"}

package/dist/worker.transport-BhMyvqQ2.mjs

@@ -0,0 +1,167 @@
+import { r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+
+//#region node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+
+//#endregion
+//#region src/transports/worker.transport.ts
+/**
+* Transport that runs a wrapped transport inside a dedicated Node.js worker
+* thread, completely removing JSON serialization and I/O from the main event loop.
+*/
+var WorkerTransport = class {
+	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;
+		this.level = config.level;
+		this.startWorker();
+	}
+	startWorker() {
+		try {
+			this.worker = new Worker(this.workerFile(), { workerData: {
+				transportType: this.config.transportType,
+				transportConfig: this.config.transportConfig
+			} });
+			this.worker.on("message", (msg) => {
+				if (msg.type === "ready") {
+					this.ready = true;
+					this.drainBuffer();
+				} else if (msg.type === "error" || msg.type === "write-error") internalError(`WorkerTransport [${this.config.transportType}]: ${msg.error ?? "unknown"}`);
+			});
+			this.worker.on("error", (err) => {
+				internalError("WorkerTransport worker error", err);
+				this.handleWorkerExit();
+			});
+			this.worker.on("exit", (code) => {
+				if (code !== 0) {
+					internalWarn(`WorkerTransport worker exited with code ${code}`);
+					this.handleWorkerExit();
+				}
+			});
+		} catch (err) {
+			internalError("WorkerTransport failed to start", err);
+		}
+	}
+	/** The worker entry is always built as CommonJS, next to this module's output. */
+	workerFile() {
+		return path.join(__dirname, "worker-entry.js");
+	}
+	handleWorkerExit() {
+		this.ready = false;
+		if (this.closing) return;
+		if (this.restarts < this.maxRestarts) {
+			this.restarts++;
+			internalWarn(`WorkerTransport restarting (attempt ${this.restarts}/${this.maxRestarts})`);
+			this.restartTimer = setTimeout(() => {
+				this.restartTimer = null;
+				this.startWorker();
+			}, 500 * this.restarts);
+			if (this.restartTimer.unref) this.restartTimer.unref();
+		} else internalError(`WorkerTransport exhausted ${this.maxRestarts} restart attempts — transport disabled`);
+	}
+	drainBuffer() {
+		while (this.buffer.length > 0 && this.ready && this.worker) {
+			const entry = this.buffer.shift();
+			if (entry) this.worker.postMessage({
+				type: "write",
+				entry
+			});
+		}
+	}
+	write(entry) {
+		if (this.ready && this.worker) this.worker.postMessage({
+			type: "write",
+			entry
+		});
+		else {
+			if (this.buffer.length >= this.bufferSize) {
+				internalWarn("WorkerTransport buffer full — dropping oldest entry");
+				this.buffer.shift();
+			}
+			this.buffer.push(entry);
+		}
+	}
+	async flush() {
+		if (!this.ready || !this.worker) return;
+		const worker = this.worker;
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				worker.off("message", handler);
+				resolve();
+			}, this.FLUSH_TIMEOUT_MS);
+			if (timer.unref) timer.unref();
+			const handler = (msg) => {
+				if (msg.type === "flushed") {
+					clearTimeout(timer);
+					worker.off("message", handler);
+					resolve();
+				}
+			};
+			worker.on("message", handler);
+			worker.postMessage({ type: "flush" });
+		});
+	}
+	/**
+	* Flush the worker's buffer and terminate the thread on shutdown.
+	*
+	* This MUST be named close() — TransportManager.close() invokes
+	* transport.close(), so a method named only shutdown() was never called on
+	* graceful exit, leaking the worker thread and dropping its buffered logs.
+	*/
+	async close() {
+		this.closing = true;
+		if (this.restartTimer) {
+			clearTimeout(this.restartTimer);
+			this.restartTimer = null;
+		}
+		if (!this.worker) return;
+		const worker = this.worker;
+		this.worker = null;
+		this.drainBufferTo(worker);
+		worker.postMessage({ type: "shutdown" });
+		await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				worker.terminate().finally(() => resolve());
+			}, this.SHUTDOWN_TIMEOUT_MS);
+			if (timer.unref) timer.unref();
+			worker.once("exit", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}
+	/** Back-compat alias — prefer close(). */
+	async shutdown() {
+		await this.close();
+	}
+	drainBufferTo(worker) {
+		while (this.buffer.length > 0) {
+			const entry = this.buffer.shift();
+			if (entry) worker.postMessage({
+				type: "write",
+				entry
+			});
+		}
+	}
+};
+
+//#endregion
+export { WorkerTransport as t };
+//# sourceMappingURL=worker.transport-BhMyvqQ2.mjs.map

package/dist/worker.transport-BhMyvqQ2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.transport-BhMyvqQ2.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 *     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"],"x_google_ignoreList":[0],"mappings":";;;;;;AAIA,MAAM,oBAAoB,cAAc,OAAO,KAAK,IAAI;AACxD,MAAM,mBAAmB,KAAK,QAAQ,aAAa,CAAC;AAEpD,MAAa,YAA4B,4BAAY;;;;;;;;AC8DrD,IAAa,kBAAb,MAAmD;CAsBjD,YAAY,QAA+B;cArBpB;mBAEK;uBACI;gBAEA;eAChB;gBAC+B,EAAE;kBAE9B;sBAI2B;iBAE5B;0BAEkB;6BAEG;AAGrC,OAAK,SAAS;AACd,OAAK,aAAa,OAAO,cAAc;AACvC,OAAK,cAAc,OAAO,eAAe;AACzC,OAAK,QAAQ,OAAO;AACpB,OAAK,aAAa;;CAGpB,AAAQ,cAAoB;AAC1B,MAAI;AACF,QAAK,SAAS,IAAI,OAAO,KAAK,YAAY,EAAE,EAC1C,YAAY;IACV,eAAe,KAAK,OAAO;IAC3B,iBAAiB,KAAK,OAAO;IAC9B,EACF,CAAC;AAEF,QAAK,OAAO,GAAG,YAAY,QAA0C;AACnE,QAAI,IAAI,SAAS,SAAS;AACxB,UAAK,QAAQ;AACb,UAAK,aAAa;eACT,IAAI,SAAS,WAAW,IAAI,SAAS,cAC9C,eACE,oBAAoB,KAAK,OAAO,cAAc,KAAK,IAAI,SAAS,YACjE;KAEH;AAEF,QAAK,OAAO,GAAG,UAAU,QAAQ;AAC/B,kBAAc,gCAAgC,IAAI;AAClD,SAAK,kBAAkB;KACvB;AAEF,QAAK,OAAO,GAAG,SAAS,SAAS;AAC/B,QAAI,SAAS,GAAG;AACd,kBAAa,2CAA2C,OAAO;AAC/D,UAAK,kBAAkB;;KAEzB;WACK,KAAK;AACZ,iBAAc,mCAAmC,IAAI;;;;CAKzD,AAAU,aAAqB;AAC7B,SAAO,KAAK,KAAK,WAAW,kBAAkB;;CAGhD,AAAQ,mBAAyB;AAC/B,OAAK,QAAQ;AAIb,MAAI,KAAK,QAAS;AAClB,MAAI,KAAK,WAAW,KAAK,aAAa;AACpC,QAAK;AACL,gBAAa,uCAAuC,KAAK,SAAS,GAAG,KAAK,YAAY,GAAG;AAGzF,QAAK,eAAe,iBAAiB;AACnC,SAAK,eAAe;AACpB,SAAK,aAAa;MACjB,MAAM,KAAK,SAAS;AACvB,OAAI,KAAK,aAAa,MAAO,MAAK,aAAa,OAAO;QAEtD,eACE,6BAA6B,KAAK,YAAY,wCAC/C;;CAIL,AAAQ,cAAoB;AAC1B,SAAO,KAAK,OAAO,SAAS,KAAK,KAAK,SAAS,KAAK,QAAQ;GAC1D,MAAM,QAAQ,KAAK,OAAO,OAAO;AACjC,OAAI,MACF,MAAK,OAAO,YAAY;IAAE,MAAM;IAAS;IAAO,CAAC;;;CAKvD,MAAM,OAAgC;AACpC,MAAI,KAAK,SAAS,KAAK,OACrB,MAAK,OAAO,YAAY;GAAE,MAAM;GAAS;GAAO,CAAC;OAC5C;AACL,OAAI,KAAK,OAAO,UAAU,KAAK,YAAY;AACzC,iBAAa,sDAAsD;AACnE,SAAK,OAAO,OAAO;;AAErB,QAAK,OAAO,KAAK,MAAM;;;CAI3B,MAAM,QAAuB;AAC3B,MAAI,CAAC,KAAK,SAAS,CAAC,KAAK,OAAQ;EACjC,MAAM,SAAS,KAAK;AACpB,SAAO,IAAI,SAAe,YAAY;GAKpC,MAAM,QAAQ,iBAAiB;AAC7B,WAAO,IAAI,WAAW,QAAQ;AAC9B,aAAS;MACR,KAAK,iBAAiB;AACzB,OAAI,MAAM,MAAO,OAAM,OAAO;GAE9B,MAAM,WAAW,QAA0B;AACzC,QAAI,IAAI,SAAS,WAAW;AAC1B,kBAAa,MAAM;AACnB,YAAO,IAAI,WAAW,QAAQ;AAC9B,cAAS;;;AAGb,UAAO,GAAG,WAAW,QAAQ;AAC7B,UAAO,YAAY,EAAE,MAAM,SAAS,CAAC;IACrC;;;;;;;;;CAUJ,MAAM,QAAuB;AAG3B,OAAK,UAAU;AACf,MAAI,KAAK,cAAc;AACrB,gBAAa,KAAK,aAAa;AAC/B,QAAK,eAAe;;AAGtB,MAAI,CAAC,KAAK,OAAQ;EAClB,MAAM,SAAS,KAAK;AACpB,OAAK,SAAS;AAKd,OAAK,cAAc,OAAO;AAC1B,SAAO,YAAY,EAAE,MAAM,YAAY,CAAC;AAExC,QAAM,IAAI,SAAe,YAAY;GAEnC,MAAM,QAAQ,iBAAiB;AAC7B,WAAO,WAAW,CAAC,cAAc,SAAS,CAAC;MAC1C,KAAK,oBAAoB;AAC5B,OAAI,MAAM,MAAO,OAAM,OAAO;AAE9B,UAAO,KAAK,cAAc;AACxB,iBAAa,MAAM;AACnB,aAAS;KACT;IACF;;;CAIJ,MAAM,WAA0B;AAC9B,QAAM,KAAK,OAAO;;CAGpB,AAAQ,cAAc,QAAsB;AAC1C,SAAO,KAAK,OAAO,SAAS,GAAG;GAC7B,MAAM,QAAQ,KAAK,OAAO,OAAO;AACjC,OAAI,MAAO,QAAO,YAAY;IAAE,MAAM;IAAS;IAAO,CAAC"}

package/dist/worker.transport-CfH6z37Z.js

@@ -0,0 +1,168 @@
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_internal_log = require('./internal-log-BUJYMZbE.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_worker_threads = require("node:worker_threads");
+node_worker_threads = require_chunk.__toESM(node_worker_threads);
+
+//#region src/transports/worker.transport.ts
+/**
+* Transport that runs a wrapped transport inside a dedicated Node.js worker
+* thread, completely removing JSON serialization and I/O from the main event loop.
+*/
+var WorkerTransport = class {
+	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;
+		this.level = config.level;
+		this.startWorker();
+	}
+	startWorker() {
+		try {
+			this.worker = new node_worker_threads.Worker(this.workerFile(), { workerData: {
+				transportType: this.config.transportType,
+				transportConfig: this.config.transportConfig
+			} });
+			this.worker.on("message", (msg) => {
+				if (msg.type === "ready") {
+					this.ready = true;
+					this.drainBuffer();
+				} else if (msg.type === "error" || msg.type === "write-error") require_internal_log.internalError(`WorkerTransport [${this.config.transportType}]: ${msg.error ?? "unknown"}`);
+			});
+			this.worker.on("error", (err) => {
+				require_internal_log.internalError("WorkerTransport worker error", err);
+				this.handleWorkerExit();
+			});
+			this.worker.on("exit", (code) => {
+				if (code !== 0) {
+					require_internal_log.internalWarn(`WorkerTransport worker exited with code ${code}`);
+					this.handleWorkerExit();
+				}
+			});
+		} catch (err) {
+			require_internal_log.internalError("WorkerTransport failed to start", err);
+		}
+	}
+	/** The worker entry is always built as CommonJS, next to this module's output. */
+	workerFile() {
+		return node_path.default.join(__dirname, "worker-entry.js");
+	}
+	handleWorkerExit() {
+		this.ready = false;
+		if (this.closing) return;
+		if (this.restarts < this.maxRestarts) {
+			this.restarts++;
+			require_internal_log.internalWarn(`WorkerTransport restarting (attempt ${this.restarts}/${this.maxRestarts})`);
+			this.restartTimer = setTimeout(() => {
+				this.restartTimer = null;
+				this.startWorker();
+			}, 500 * this.restarts);
+			if (this.restartTimer.unref) this.restartTimer.unref();
+		} else require_internal_log.internalError(`WorkerTransport exhausted ${this.maxRestarts} restart attempts — transport disabled`);
+	}
+	drainBuffer() {
+		while (this.buffer.length > 0 && this.ready && this.worker) {
+			const entry = this.buffer.shift();
+			if (entry) this.worker.postMessage({
+				type: "write",
+				entry
+			});
+		}
+	}
+	write(entry) {
+		if (this.ready && this.worker) this.worker.postMessage({
+			type: "write",
+			entry
+		});
+		else {
+			if (this.buffer.length >= this.bufferSize) {
+				require_internal_log.internalWarn("WorkerTransport buffer full — dropping oldest entry");
+				this.buffer.shift();
+			}
+			this.buffer.push(entry);
+		}
+	}
+	async flush() {
+		if (!this.ready || !this.worker) return;
+		const worker = this.worker;
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				worker.off("message", handler);
+				resolve();
+			}, this.FLUSH_TIMEOUT_MS);
+			if (timer.unref) timer.unref();
+			const handler = (msg) => {
+				if (msg.type === "flushed") {
+					clearTimeout(timer);
+					worker.off("message", handler);
+					resolve();
+				}
+			};
+			worker.on("message", handler);
+			worker.postMessage({ type: "flush" });
+		});
+	}
+	/**
+	* Flush the worker's buffer and terminate the thread on shutdown.
+	*
+	* This MUST be named close() — TransportManager.close() invokes
+	* transport.close(), so a method named only shutdown() was never called on
+	* graceful exit, leaking the worker thread and dropping its buffered logs.
+	*/
+	async close() {
+		this.closing = true;
+		if (this.restartTimer) {
+			clearTimeout(this.restartTimer);
+			this.restartTimer = null;
+		}
+		if (!this.worker) return;
+		const worker = this.worker;
+		this.worker = null;
+		this.drainBufferTo(worker);
+		worker.postMessage({ type: "shutdown" });
+		await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				worker.terminate().finally(() => resolve());
+			}, this.SHUTDOWN_TIMEOUT_MS);
+			if (timer.unref) timer.unref();
+			worker.once("exit", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}
+	/** Back-compat alias — prefer close(). */
+	async shutdown() {
+		await this.close();
+	}
+	drainBufferTo(worker) {
+		while (this.buffer.length > 0) {
+			const entry = this.buffer.shift();
+			if (entry) worker.postMessage({
+				type: "write",
+				entry
+			});
+		}
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'WorkerTransport', {
+  enumerable: true,
+  get: function () {
+    return WorkerTransport;
+  }
+});
+//# sourceMappingURL=worker.transport-CfH6z37Z.js.map

package/dist/worker.transport-CfH6z37Z.js.map

@@ -0,0 +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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"}

package/dist/worker.transport-mKXgNK0L.d.ts

@@ -0,0 +1,76 @@
+import { l as ITransport, p as TransportLogEntry } from "./transport.types-BuY84TwO.js";
+
+//#region src/transports/worker.transport.d.ts
+
+interface WorkerTransportConfig {
+  /**
+   * Which built-in logixia transport to run inside the worker thread.
+   * The worker resolves the correct module automatically.
+   */
+  transportType: 'file' | 'database' | 'console';
+  /** Config forwarded verbatim to the wrapped transport constructor. */
+  transportConfig: Record<string, unknown>;
+  /**
+   * Max log entries to buffer in the main thread while the worker is starting
+   * or restarting. Entries beyond this limit are dropped with a warning.
+   * @default 1000
+   */
+  bufferSize?: number;
+  /**
+   * How many times to restart the worker if it crashes unexpectedly.
+   * @default 3
+   */
+  maxRestarts?: number;
+  /**
+   * Log level filter — only entries at or above this level are forwarded.
+   * Useful for routing only errors to an expensive transport in a worker.
+   */
+  level?: string;
+}
+/**
+ * Transport that runs a wrapped transport inside a dedicated Node.js worker
+ * thread, completely removing JSON serialization and I/O from the main event loop.
+ */
+declare class WorkerTransport implements ITransport {
+  readonly name = "worker";
+  readonly level: string | undefined;
+  readonly batchSize = 1;
+  readonly flushInterval = 0;
+  private worker;
+  private ready;
+  private readonly buffer;
+  private readonly bufferSize;
+  private restarts;
+  private readonly maxRestarts;
+  private readonly config;
+  /** Pending restart-backoff timer, so close() can cancel a queued restart. */
+  private restartTimer;
+  /** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
+  private closing;
+  /** Max time to wait for the worker's 'flushed' ack before giving up. */
+  private readonly FLUSH_TIMEOUT_MS;
+  /** Max time to wait for a graceful worker exit before force-terminating. */
+  private readonly SHUTDOWN_TIMEOUT_MS;
+  constructor(config: WorkerTransportConfig);
+  private startWorker;
+  /** The worker entry is always built as CommonJS, next to this module's output. */
+  protected workerFile(): string;
+  private handleWorkerExit;
+  private drainBuffer;
+  write(entry: TransportLogEntry): void;
+  flush(): Promise<void>;
+  /**
+   * Flush the worker's buffer and terminate the thread on shutdown.
+   *
+   * This MUST be named close() — TransportManager.close() invokes
+   * transport.close(), so a method named only shutdown() was never called on
+   * graceful exit, leaking the worker thread and dropping its buffered logs.
+   */
+  close(): Promise<void>;
+  /** Back-compat alias — prefer close(). */
+  shutdown(): Promise<void>;
+  private drainBufferTo;
+}
+//#endregion
+export { WorkerTransportConfig as n, WorkerTransport as t };
+//# sourceMappingURL=worker.transport-mKXgNK0L.d.ts.map

package/dist/worker.transport-mKXgNK0L.d.ts.map

@@ -0,0 +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"}