@warlock.js/logger 4.0.174 → 4.1.1

package/cjs/index.cjs

@@ -0,0 +1,1003 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _mongez_copper = require("@mongez/copper");
+let util = require("util");
+let _warlock_js_fs = require("@warlock.js/fs");
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs, 1);
+let fs = require("fs");
+fs = __toESM(fs, 1);
+let os = require("os");
+let path = require("path");
+path = __toESM(path, 1);
+let safe_stable_stringify = require("safe-stable-stringify");
+let _mongez_reinforcements = require("@mongez/reinforcements");
+
+//#region ../../@warlock.js/logger/src/log-channel.ts
+var LogChannel = class {
+	/**
+	* Constructor
+	*/
+	constructor(configurations) {
+		this.terminal = false;
+		this.defaultConfigurations = {};
+		this.channelConfigurations = {};
+		this.isInitialized = false;
+		if (configurations) this.setConfigurations(configurations);
+		setTimeout(async () => {
+			if (this.init) await this.init();
+			this.isInitialized = true;
+		}, 0);
+	}
+	/**
+	* Get config value
+	*/
+	config(key) {
+		return this.channelConfigurations[key] ?? (this.defaultConfigurations ?? {})[key];
+	}
+	/**
+	* Set configurations
+	*/
+	setConfigurations(configurations) {
+		this.channelConfigurations = {
+			...this.channelConfigurations,
+			...configurations
+		};
+		return this;
+	}
+	/**
+	* Determine if the message should be logged
+	*/
+	shouldBeLogged(data) {
+		const allowedLevels = this.config("levels");
+		if (allowedLevels?.length && !allowedLevels.includes(data.type)) return false;
+		const filter = this.config("filter");
+		if (filter) return filter(data);
+		return true;
+	}
+	/**
+	* Read the channel's redact config (if any). Used by `Logger` to apply
+	* per-channel additive redaction on top of the logger-wide floor.
+	* Subclasses normally don't override this — set `redact` in your channel
+	* configuration instead.
+	*/
+	getRedactConfig() {
+		return this.config("redact");
+	}
+	/**
+	* Get date and time formats
+	*/
+	getDateAndTimeFormat() {
+		const dateFormat = this.config("dateFormat");
+		return {
+			date: dateFormat?.date ?? "DD-MM-YYYY",
+			time: dateFormat?.time ?? "HH:mm:ss"
+		};
+	}
+	/**
+	* get basic configurations with the given ones
+	*/
+	withBasicConfigurations(configurations) {
+		return {
+			filter: () => true,
+			...configurations
+		};
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/logger/src/channels/console-log.ts
+var ConsoleLog = class extends LogChannel {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "console";
+		this.terminal = true;
+	}
+	/**
+	* {@inheritdoc}
+	*/
+	log(data) {
+		const { module, action, message, type: level } = data;
+		if (!this.shouldBeLogged(data)) return;
+		const date = (/* @__PURE__ */ new Date()).toISOString();
+		switch (level) {
+			case "debug":
+				console.log(_mongez_copper.colors.magentaBright("⚙"), _mongez_copper.colors.yellow(`(${date})`), _mongez_copper.colors.cyan(`[${module}]`), _mongez_copper.colors.magenta(`[${action}]`), _mongez_copper.colors.magentaBright(message));
+				break;
+			case "info":
+				console.log(_mongez_copper.colors.blueBright("ℹ"), _mongez_copper.colors.yellow(`(${date})`), _mongez_copper.colors.cyan(`[${module}]`), _mongez_copper.colors.magenta(`[${action}]`), _mongez_copper.colors.blueBright(message));
+				break;
+			case "warn":
+				console.log(_mongez_copper.colors.yellow("⚠"), _mongez_copper.colors.yellow(`(${date})`), _mongez_copper.colors.cyan(`[${module}]`), _mongez_copper.colors.magenta(`[${action}]`), _mongez_copper.colors.yellowBright(message));
+				break;
+			case "error":
+				console.log(_mongez_copper.colors.red("✗"), _mongez_copper.colors.yellow(`(${date})`), _mongez_copper.colors.cyan(`[${module}]`), _mongez_copper.colors.magenta(`[${action}]`), _mongez_copper.colors.redBright(message));
+				break;
+			case "success":
+				console.log(_mongez_copper.colors.green("✓"), _mongez_copper.colors.yellow(`(${date})`), _mongez_copper.colors.cyan(`[${module}]`), _mongez_copper.colors.magenta(`[${action}]`), _mongez_copper.colors.greenBright(message));
+				break;
+			default: console.log("[log]", _mongez_copper.colors.yellow(`(${date})`), _mongez_copper.colors.cyan(`[${module}]`), _mongez_copper.colors.magenta(`[${action}]`), message);
+		}
+		if (typeof message === "object") console.log(message);
+		if (this.config("showContext") && data.context && Object.keys(data.context).length > 0) {
+			const depth = this.config("contextDepth") ?? 4;
+			console.log(_mongez_copper.colors.gray("  ↳"), (0, util.inspect)(data.context, {
+				colors: true,
+				depth,
+				breakLength: 80
+			}));
+		}
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/logger/src/channels/file-log.ts
+var FileLog = class extends LogChannel {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "file";
+		this.messages = [];
+		this.groupedMessages = {};
+		this.defaultConfigurations = {
+			storagePath: process.cwd() + "/storage/logs",
+			rotate: true,
+			name: "app",
+			extension: "log",
+			chunk: "single",
+			maxMessagesToWrite: 100,
+			filter: () => true,
+			maxFileSize: 10 * 1024 * 1024,
+			get rotateFileName() {
+				return (0, dayjs.default)().format("DD-MM-YYYY");
+			},
+			dateFormat: {
+				date: "DD-MM-YYYY",
+				time: "HH:mm:ss"
+			}
+		};
+		this.lastWriteTime = Date.now();
+		this.isWriting = false;
+	}
+	/**
+	* Check file size for file rotation
+	*/
+	async checkAndRotateFile(filePath = this.filePath) {
+		if (!this.config("rotate")) return;
+		try {
+			if ((await fs.default.promises.stat(filePath)).size >= this.config("maxFileSize")) await this.rotateLogFile();
+		} catch (error) {
+			if (error.code !== "ENOENT") console.error("Error checking log file:", error);
+		}
+	}
+	/**
+	* Rotate log file
+	*/
+	async rotateLogFile() {
+		const fileName = `${this.fileName}-${this.config("rotateFileName")}-${Date.now()}`;
+		const extension = this.extension;
+		const rotatedFilePath = path.default.join(this.storagePath, `${fileName}.${extension}`);
+		await fs.default.promises.rename(this.filePath, rotatedFilePath).catch((error) => {
+			console.error("Error rotating file:", error);
+		});
+	}
+	/**
+	* Flush messages
+	*
+	* Starts a periodic re-check so low-traffic channels don't sit on buffered
+	* entries indefinitely. The handle is stored on the instance so `dispose()`
+	* can stop it — without this, every channel leaks a timer for the lifetime
+	* of the process.
+	*/
+	initMessageFlush() {
+		this.flushIntervalHandle = setInterval(() => {
+			if (this.messages.length > 0 && (this.messages.length >= this.maxMessagesToWrite || Date.now() - this.lastWriteTime > 5e3)) this.writeMessagesToFile();
+		}, 5e3);
+	}
+	/**
+	* Stop the background flush interval and drain any buffered entries.
+	*
+	* Call this when discarding a channel (e.g. reconfiguring the logger at
+	* runtime) so the 5-second timer doesn't keep the event loop alive. Safe to
+	* call more than once.
+	*/
+	dispose() {
+		if (this.flushIntervalHandle) {
+			clearInterval(this.flushIntervalHandle);
+			this.flushIntervalHandle = void 0;
+		}
+		this.flushSync();
+	}
+	/**
+	* Get file path
+	*/
+	get filePath() {
+		const fileName = this.fileName;
+		const extension = this.extension;
+		return path.default.join(this.storagePath, `${fileName}.${extension}`);
+	}
+	/**
+	* Get max messages
+	*/
+	get maxMessagesToWrite() {
+		return this.config("maxMessagesToWrite");
+	}
+	/**
+	* Get file name
+	*/
+	get fileName() {
+		switch (this.config("chunk")) {
+			case "single":
+			default: return this.config("name");
+			case "daily": return (0, dayjs.default)().format("DD-MM-YYYY");
+			case "hourly": return (0, dayjs.default)().format("DD-MM-YYYY-HH-00-00-a");
+		}
+	}
+	/**
+	* Get file extension
+	*/
+	get extension() {
+		return this.config("extension");
+	}
+	/**
+	* Get content
+	*/
+	get content() {
+		return this.messages.map((message) => message.content).join(os.EOL) + os.EOL;
+	}
+	/**
+	* Get storage path
+	*/
+	get storagePath() {
+		return this.config("storagePath");
+	}
+	/**
+	* {@inheritdoc}
+	*/
+	async init() {
+		const logsDirectory = this.storagePath;
+		await (0, _warlock_js_fs.ensureDirectoryAsync)(logsDirectory);
+		this.initMessageFlush();
+	}
+	/**
+	* Synchronously flush messages
+	*/
+	flushSync() {
+		if (this.messages.length === 0 && Object.keys(this.groupedMessages).length === 0) return;
+		if (this.messagedShouldBeGrouped) {
+			this.prepareGroupedMessages();
+			for (const key in this.groupedMessages) {
+				const directoryPath = path.default.join(this.storagePath, key);
+				fs.default.mkdirSync(directoryPath, { recursive: true });
+				const filePath = path.default.join(directoryPath, `${this.fileName}.${this.extension}`);
+				const content = this.groupedMessages[key].map((message) => message.content).join(os.EOL) + os.EOL;
+				fs.default.appendFileSync(filePath, content);
+			}
+		} else {
+			fs.default.mkdirSync(this.storagePath, { recursive: true });
+			fs.default.appendFileSync(this.filePath, this.content);
+		}
+		this.onSave();
+	}
+	/**
+	* {@inheritdoc}
+	*/
+	async log(data) {
+		const { module, action, message, type: level, context } = data;
+		if (!this.shouldBeLogged(data)) return;
+		const { date: dateFormat, time } = this.getDateAndTimeFormat();
+		const date = (0, dayjs.default)().format(dateFormat + " " + time);
+		let content = `[${date}] [${level}] [${module}][${action}]: `;
+		let stack;
+		if (message instanceof Error) {
+			content += message.message + os.EOL;
+			content += `[trace]` + os.EOL;
+			content += message.stack;
+			stack = message.stack;
+		} else content += message;
+		this.messages.push({
+			content,
+			level,
+			date,
+			module,
+			action,
+			stack,
+			context,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		await this.checkIfMessagesShouldBeWritten();
+	}
+	/**
+	* Check if messages should be written
+	*/
+	async checkIfMessagesShouldBeWritten() {
+		if (this.messages.length >= this.maxMessagesToWrite || Date.now() - this.lastWriteTime > 5e3) await this.writeMessagesToFile();
+	}
+	/**
+	* Should be called after messages are saved
+	*/
+	onSave() {
+		this.messages = [];
+		this.groupedMessages = {};
+		this.isWriting = false;
+		this.lastWriteTime = Date.now();
+	}
+	/**
+	* Check if messages should be grouped
+	*/
+	get messagedShouldBeGrouped() {
+		return Number(this.config("groupBy")?.length) > 0;
+	}
+	/**
+	* Write messages to the file
+	*/
+	async writeMessagesToFile() {
+		if (this.messages.length === 0 || this.isWriting || !this.isInitialized) return;
+		this.isWriting = true;
+		if (this.messagedShouldBeGrouped) return await this.writeGroupedMessagesToFile();
+		await this.checkAndRotateFile();
+		try {
+			await this.write(this.filePath, this.content);
+			this.onSave();
+		} catch (error) {
+			console.error("Failed to write log:", error);
+			this.isWriting = false;
+		}
+	}
+	/**
+	* Write grouped messages to the file
+	*/
+	async writeGroupedMessagesToFile() {
+		this.prepareGroupedMessages();
+		for (const key in this.groupedMessages) {
+			const directoryPath = path.default.join(this.storagePath, key);
+			await (0, _warlock_js_fs.ensureDirectoryAsync)(directoryPath);
+			const filePath = path.default.join(directoryPath, `${this.fileName}.${this.extension}`);
+			await this.checkAndRotateFile(filePath);
+			const content = this.groupedMessages[key].map((message) => message.content).join(os.EOL) + os.EOL;
+			try {
+				await this.write(filePath, content);
+			} catch (error) {
+				console.error("Failed to write log:", error);
+			}
+		}
+		this.onSave();
+		this.isWriting = false;
+	}
+	/**
+	* Prepare grouped messages
+	*/
+	prepareGroupedMessages() {
+		this.messages.forEach((message) => {
+			const key = this.config("groupBy").map((groupKey) => encodeURIComponent(message[groupKey])).join("/");
+			this.groupedMessages[key] = this.groupedMessages[key] || [];
+			this.groupedMessages[key].push(message);
+		});
+	}
+	/**
+	* Start writing to the file
+	*/
+	async write(filePath, content) {
+		return new Promise((resolve, reject) => {
+			const writer = fs.default.createWriteStream(filePath, { flags: "a" });
+			writer.write(content, (error) => {
+				writer.end();
+				if (error) reject(error);
+				else resolve(true);
+			});
+		});
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/logger/src/utils/safe-json-stringify.ts
+/**
+* Replacer that surfaces Error data — `name`, `message`, and `stack` are
+* non-enumerable on `Error`, so neither default JSON serialization nor an
+* object spread captures them (both produce `{}`). They are copied explicitly;
+* the trailing spread then captures any additional enumerable props the caller
+* (or a subclass) attached, such as a `code` field.
+*/
+function errorReplacer(_key, value) {
+	if (value instanceof Error) return {
+		...value,
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	return value;
+}
+/**
+* JSON-serialize log payloads safely. Circular refs, BigInt, and repeated
+* non-tree references are handled by `safe-stable-stringify`; functions and
+* symbols are dropped (standard JSON behavior); Errors are expanded via
+* `errorReplacer`. Class instances serialize as their enumerable props.
+*
+* @example
+* await fs.promises.writeFile(filePath, safeJsonStringify(payload, 2));
+*/
+function safeJsonStringify(value, space) {
+	return (0, safe_stable_stringify.stringify)(value, errorReplacer, space) ?? "";
+}
+
+//#endregion
+//#region ../../@warlock.js/logger/src/channels/json-file-log.ts
+var JSONFileLog = class extends FileLog {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "fileJson";
+	}
+	/**
+	* Get file extension
+	*/
+	get extension() {
+		return "json";
+	}
+	/**
+	* Synchronously flush messages
+	*/
+	flushSync() {
+		if (this.messages.length === 0 && Object.keys(this.groupedMessages).length === 0) return;
+		if (this.messagedShouldBeGrouped) {
+			this.prepareGroupedMessages();
+			for (const key in this.groupedMessages) {
+				const directoryPath = path.default.join(this.storagePath, key);
+				fs.default.mkdirSync(directoryPath, { recursive: true });
+				const filePath = path.default.join(directoryPath, `${this.fileName}.${this.extension}`);
+				let fileContents = { messages: [] };
+				if (fs.default.existsSync(filePath)) try {
+					fileContents = JSON.parse(fs.default.readFileSync(filePath, "utf-8"));
+					if (!Array.isArray(fileContents.messages)) fileContents.messages = [];
+				} catch (e) {
+					fileContents = { messages: [] };
+				}
+				fileContents.messages.push(...this.groupedMessages[key]);
+				fs.default.writeFileSync(filePath, safeJsonStringify(fileContents, 2));
+			}
+		} else {
+			fs.default.mkdirSync(this.storagePath, { recursive: true });
+			let fileContents = { messages: [] };
+			if (fs.default.existsSync(this.filePath)) try {
+				fileContents = JSON.parse(fs.default.readFileSync(this.filePath, "utf-8"));
+				if (!Array.isArray(fileContents.messages)) fileContents.messages = [];
+			} catch (e) {
+				fileContents = { messages: [] };
+			}
+			fileContents.messages.push(...this.messages);
+			fs.default.writeFileSync(this.filePath, safeJsonStringify(fileContents, 2));
+		}
+		this.onSave();
+	}
+	/**
+	* {@inheritdoc}
+	*/
+	async log(data) {
+		let stack;
+		if (data.message instanceof Error) {
+			stack = data.message.stack?.split("\n");
+			data.message = data.message.message;
+		}
+		const { module, action, message, type: level, context } = data;
+		if (!this.shouldBeLogged(data)) return;
+		const { date: dateFormat, time } = this.getDateAndTimeFormat();
+		const date = (0, dayjs.default)().format(dateFormat + " " + time);
+		this.messages.push({
+			content: message,
+			level,
+			date,
+			module,
+			action,
+			stack,
+			context,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		await this.checkIfMessagesShouldBeWritten();
+	}
+	/**
+	* Write messages to the file
+	*/
+	async writeMessagesToFile() {
+		if (this.messages.length === 0 || this.isWriting || !this.isInitialized) return;
+		this.isWriting = true;
+		if (this.messagedShouldBeGrouped) return await this.writeGroupedMessagesToFile();
+		await this.checkAndRotateFile();
+		let fileContents = { messages: [] };
+		if (await (0, _warlock_js_fs.fileExistsAsync)(this.filePath)) try {
+			fileContents = await (0, _warlock_js_fs.getJsonFileAsync)(this.filePath);
+		} catch (error) {
+			console.error("Error reading log file, reinitializing:", error);
+			fileContents = { messages: [] };
+		}
+		else fileContents = { messages: [] };
+		fileContents.messages.push(...this.messages);
+		try {
+			await fs.default.promises.writeFile(this.filePath, safeJsonStringify(fileContents, 2));
+			this.onSave();
+		} catch (error) {
+			console.error("Failed to write log:", error);
+			this.isWriting = false;
+		}
+	}
+	/**
+	* Write grouped messages to the file
+	*/
+	async writeGroupedMessagesToFile() {
+		this.prepareGroupedMessages();
+		for (const key in this.groupedMessages) {
+			const directoryPath = path.default.join(this.storagePath, key);
+			await (0, _warlock_js_fs.ensureDirectoryAsync)(directoryPath);
+			const filePath = path.default.join(directoryPath, `${this.fileName}.${this.extension}`);
+			await this.checkAndRotateFile(filePath);
+			let fileContents = { messages: [] };
+			if (await (0, _warlock_js_fs.fileExistsAsync)(filePath)) try {
+				fileContents = await (0, _warlock_js_fs.getJsonFileAsync)(filePath);
+			} catch (error) {
+				console.error("Error reading log file, reinitializing:", error);
+				fileContents = { messages: [] };
+			}
+			else fileContents = { messages: [] };
+			fileContents.messages.push(...this.groupedMessages[key]);
+			try {
+				await fs.default.promises.writeFile(filePath, safeJsonStringify(fileContents, 2));
+			} catch (error) {
+				console.error("Failed to write log:", error);
+				this.isWriting = false;
+			}
+		}
+		this.onSave();
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/logger/src/redact/redact.ts
+/**
+* Deep-clone a value with structural fidelity for log entries — handles plain
+* objects, arrays, `Date`, `Error`, and primitives. Anything else is copied
+* by reference (we only redact paths through plain objects/arrays anyway,
+* and rebuilding e.g. a `Buffer` would change semantics).
+*
+* Purpose-built rather than reaching for `structuredClone`: `Error` instances
+* lose their `message`/`stack` under `structuredClone` in some Node versions,
+* and the logger pipeline carries them often.
+*/
+function cloneEntry(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return seen.get(value);
+	if (value instanceof Date) return new Date(value.getTime());
+	if (value instanceof Error) {
+		const copy = new value.constructor(value.message);
+		copy.stack = value.stack;
+		copy.name = value.name;
+		return copy;
+	}
+	if (Array.isArray(value)) {
+		const arr = [];
+		seen.set(value, arr);
+		for (const item of value) arr.push(cloneEntry(item, seen));
+		return arr;
+	}
+	const out = {};
+	seen.set(value, out);
+	for (const key of Object.keys(value)) out[key] = cloneEntry(value[key], seen);
+	return out;
+}
+/**
+* Apply a single censor decision to a value. String censors are returned
+* verbatim; function censors receive the original value plus the dotted
+* path so callers can implement value-aware redaction (mask all but the
+* last 4 chars, hash, etc.).
+*/
+function applyCensor(value, censor, path) {
+	if (typeof censor === "function") return censor(value, path.join("."));
+	return censor;
+}
+/**
+* Walk `target` following the remaining `segments` of a path pattern,
+* replacing matched leaves via `censor`. Operates in place — the caller
+* is responsible for cloning before calling.
+*
+* Wildcards:
+* - `*` matches exactly one segment (any key on a plain object, any index
+*   on an array — stringified for the path that's passed to a function
+*   censor).
+* - `**` matches zero or more segments greedily; the rest of the pattern
+*   is then attempted at the current level and at every descendant.
+*/
+function redactAtPath(target, segments, censor, pathTrail) {
+	if (target === null || typeof target !== "object") return;
+	if (segments.length === 0) return;
+	const [head, ...rest] = segments;
+	if (head === "**") {
+		if (rest.length > 0) redactAtPath(target, rest, censor, pathTrail);
+		const keys = Array.isArray(target) ? target.map((_, index) => String(index)) : Object.keys(target);
+		for (const key of keys) redactAtPath(target[key], segments, censor, [...pathTrail, key]);
+		return;
+	}
+	const keysToVisit = head === "*" ? Array.isArray(target) ? target.map((_, index) => String(index)) : Object.keys(target) : Array.isArray(target) ? /^\d+$/.test(head) && Number(head) < target.length ? [head] : [] : Object.prototype.hasOwnProperty.call(target, head) ? [head] : [];
+	for (const key of keysToVisit) if (rest.length === 0) target[key] = applyCensor(target[key], censor, [...pathTrail, key]);
+	else redactAtPath(target[key], rest, censor, [...pathTrail, key]);
+}
+/**
+* Produce a new `LoggingData` with every path in `config.paths` replaced
+* by `config.censor`. The original entry is never mutated — channels and
+* other call sites can hold references to the input safely.
+*
+* No-op (returns the input by reference) when `config` is `undefined` or
+* its `paths` array is empty, so the fast path stays fast.
+*/
+function applyRedact(data, config) {
+	if (!config || config.paths.length === 0) return data;
+	const censor = config.censor ?? "[REDACTED]";
+	const cloned = cloneEntry(data);
+	for (const pattern of config.paths) {
+		const segments = pattern.split(".").filter((segment) => segment.length > 0);
+		if (segments.length === 0) continue;
+		redactAtPath(cloned, segments, censor, []);
+	}
+	return cloned;
+}
+/**
+* Combine two redact configs into one effective config. Used to merge a
+* channel's additive paths on top of the logger-wide floor.
+*
+* - `paths` are concatenated; duplicates are kept (the matcher tolerates
+*   them, and de-duping cross-config would mask a developer typo).
+* - `censor` from the channel wins; falls back to the logger's; falls back
+*   to the default `"[REDACTED]"`.
+*/
+function mergeRedact(base, extra) {
+	if (!base && !extra) return void 0;
+	if (!base) return extra;
+	if (!extra) return base;
+	return {
+		paths: [...base.paths, ...extra.paths],
+		censor: extra.censor ?? base.censor
+	};
+}
+
+//#endregion
+//#region ../../@warlock.js/logger/src/utils/clear-message.ts
+/**
+* Clear message from any terminal codes
+*/
+function clearMessage(message) {
+	if (typeof message !== "string") return message;
+	return message.replace(/\u001b[^m]*?m/g, "");
+}
+
+//#endregion
+//#region ../../@warlock.js/logger/src/logger.ts
+const SIGNAL_EVENTS = new Set([
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP",
+	"SIGBREAK",
+	"SIGUSR2"
+]);
+/**
+* Severity ranks used by `setMinLevel`. Higher number = more severe. The
+* ordering matches conventional log-level hierarchies: `debug` is noisiest
+* and easiest to drop; `error` is the loudest and never dropped by the
+* minimum-level filter. `success` sits beside `info` — it's an informational
+* outcome, not a warning.
+*/
+const LEVEL_RANK = {
+	debug: 0,
+	info: 1,
+	success: 1,
+	warn: 2,
+	error: 3
+};
+var Logger = class {
+	constructor() {
+		this.channels = [];
+		this.id = "logger-" + _mongez_reinforcements.Random.string(32);
+		this.autoFlushHandlers = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Add a new channel
+	*/
+	addChannel(channel) {
+		this.channels.push(channel);
+		return this;
+	}
+	/**
+	* Set base configurations
+	*/
+	configure(config) {
+		if (config.channels) this.channels = config.channels;
+		if (config.autoFlushOn) this.enableAutoFlush(config.autoFlushOn);
+		if (config.minLevel !== void 0) this.setMinLevel(config.minLevel);
+		if (config.redact !== void 0) this.setRedact(config.redact);
+		return this;
+	}
+	/**
+	* Set the logger-wide redaction floor. Applied to every entry before
+	* fan-out; channel configs add more paths on top, never fewer. Pass
+	* `undefined` to clear.
+	*
+	* @example
+	* log.setRedact({
+	*   paths: ["context.password", "context.*.token"],
+	*   censor: "[REDACTED]",
+	* });
+	*/
+	setRedact(config) {
+		this.redactConfig = config;
+		return this;
+	}
+	/**
+	* Read the active logger-wide redact config (or `undefined`).
+	*/
+	getRedact() {
+		return this.redactConfig;
+	}
+	/**
+	* Drop every entry whose severity is below `level` before fan-out. Cheaper
+	* than per-channel `levels` filters because the loop never runs and no
+	* channel receives the entry. Pass `undefined` to clear and accept all
+	* levels again.
+	*
+	* @example
+	* // production: silence debug noise everywhere at once
+	* logger.setMinLevel("info");
+	*/
+	setMinLevel(level) {
+		this.minLevel = level;
+		return this;
+	}
+	/**
+	* Read the active minimum severity (or `undefined` when none is set).
+	*/
+	getMinLevel() {
+		return this.minLevel;
+	}
+	/**
+	* Set channels
+	*/
+	setChannels(channels) {
+		this.channels = channels;
+		return this;
+	}
+	/**
+	* Normalize log data to a single object
+	*/
+	normalizeLogData(dataOrModule, action, message = "", level, context) {
+		if (typeof dataOrModule === "object") return {
+			type: level || dataOrModule.type || "info",
+			module: dataOrModule.module,
+			action: dataOrModule.action,
+			message: dataOrModule.message,
+			...context ? { context } : dataOrModule.context ? { context: dataOrModule.context } : {}
+		};
+		return {
+			type: level || "info",
+			module: dataOrModule,
+			action,
+			message,
+			...context ? { context } : {}
+		};
+	}
+	/**
+	* Make log
+	*
+	* Fans out a single log entry to every registered channel. Non-terminal
+	* channels receive a copy whose `message` has had ANSI color codes stripped
+	* — each channel sees its own shallow clone so one channel cannot observe
+	* another's mutations (e.g. a later terminal channel still sees the original
+	* colored message).
+	*/
+	async log(data) {
+		if (this.minLevel && LEVEL_RANK[data.type] < LEVEL_RANK[this.minLevel]) return this;
+		const baseEntry = applyRedact(data, this.redactConfig);
+		for (const channel of this.channels) {
+			const channelRedact = channel.getRedactConfig?.();
+			const effectiveRedact = channelRedact ? mergeRedact(this.redactConfig, channelRedact) : void 0;
+			let payload = effectiveRedact ? applyRedact(data, effectiveRedact) : baseEntry;
+			if (channel.terminal === false) payload = {
+				...payload,
+				message: clearMessage(payload.message)
+			};
+			channel.log(payload);
+		}
+		return this;
+	}
+	/**
+	* Make debug log
+	*/
+	debug(dataOrModule, action, message = "", context) {
+		const data = this.normalizeLogData(dataOrModule, action, message, "debug", context);
+		return this.log(data);
+	}
+	/**
+	* Make info log
+	*/
+	info(dataOrModule, action, message = "", context) {
+		const data = this.normalizeLogData(dataOrModule, action, message, "info", context);
+		return this.log(data);
+	}
+	/**
+	* Make warn log
+	*/
+	warn(dataOrModule, action, message = "", context) {
+		const data = this.normalizeLogData(dataOrModule, action, message, "warn", context);
+		return this.log(data);
+	}
+	/**
+	* Make error log
+	*/
+	error(dataOrModule, action, message = "", context) {
+		const data = this.normalizeLogData(dataOrModule, action, message, "error", context);
+		return this.log(data);
+	}
+	/**
+	* Make success log
+	*/
+	success(dataOrModule, action, message = "", context) {
+		const data = this.normalizeLogData(dataOrModule, action, message, "success", context);
+		return this.log(data);
+	}
+	/**
+	* Log an `error` entry when `condition` is falsy. No-op otherwise — the
+	* entry is never built and channels are not invoked, so this is genuinely
+	* free in the happy path. Mirrors the spirit of `console.assert` but routes
+	* through the logger pipeline so persistent channels capture failures.
+	*
+	* @example
+	* log.assert(user !== null, "auth", "session", "user vanished mid-flight", { sessionId });
+	*/
+	assert(condition, module, action, message, context) {
+		if (condition) return this;
+		return this.error(module, action, message, context);
+	}
+	/**
+	* Start a duration timer. The returned function emits an `info` entry
+	* with `completed in <ms>ms` and a `durationMs` field in `context` when
+	* called. Pass an object to `end()` to merge extra fields into context.
+	*
+	* @example
+	* const end = log.timer("db", "users.findById");
+	* const user = await usersRepo.findById(id);
+	* end({ id, found: !!user });
+	*/
+	timer(module, action) {
+		const startedAt = Date.now();
+		return (extra) => {
+			const durationMs = Date.now() - startedAt;
+			return this.info(module, action, `completed in ${durationMs}ms`, {
+				durationMs,
+				...extra ?? {}
+			});
+		};
+	}
+	/**
+	* Get channel by name
+	*/
+	channel(name) {
+		return this.channels.find((channel) => channel.name === name);
+	}
+	/**
+	* Synchronously flush logs
+	*/
+	flushSync() {
+		for (const channel of this.channels) if (channel.flushSync) channel.flushSync();
+	}
+	/**
+	* Register one process-level handler per event that calls `flushSync()`
+	* before the process terminates.
+	*
+	* For signal events (`SIGINT`, `SIGTERM`, `SIGHUP`, `SIGBREAK`, `SIGUSR2`)
+	* the handler flushes and then re-raises the signal so Node's default exit
+	* behavior runs. For `beforeExit`, the handler flushes in place — Node exits
+	* naturally afterwards.
+	*
+	* Idempotent: calling with the same events replaces the previous handlers.
+	* Call `disableAutoFlush()` to unregister.
+	*
+	* @example
+	* log.configure({
+	*   channels: [new ConsoleLog(), new FileLog()],
+	*   autoFlushOn: ["SIGINT", "SIGTERM", "beforeExit"],
+	* });
+	*/
+	enableAutoFlush(events) {
+		this.disableAutoFlush();
+		for (const event of events) {
+			const handler = SIGNAL_EVENTS.has(event) ? () => {
+				this.flushSync();
+				process.off(event, handler);
+				process.kill(process.pid, event);
+			} : () => {
+				this.flushSync();
+			};
+			process.on(event, handler);
+			this.autoFlushHandlers.set(event, handler);
+		}
+		return this;
+	}
+	/**
+	* Remove every handler previously registered by `enableAutoFlush`.
+	* Safe to call when no handlers are registered.
+	*/
+	disableAutoFlush() {
+		for (const [event, handler] of this.autoFlushHandlers) process.off(event, handler);
+		this.autoFlushHandlers.clear();
+		return this;
+	}
+};
+/**
+* The package singleton. Use this for everyday logging — `log.info(...)`,
+* `log.error(...)`, `log.configure(...)`. Custom logger instances can be
+* created by instantiating `Logger` directly.
+*
+* The name is intentionally short: `log` reads naturally at the call site
+* (`log.info("auth", "login", "ok")`) and matches the convention used in
+* pino, bunyan, and most JS logging tutorials.
+*
+* Note that `log` is a `Logger` instance, **not** a function — the bare
+* callable form was removed when the dual `log` / `logger` exports were
+* collapsed into a single name. Use `log.info(...)` (or any other level
+* shortcut) to emit entries.
+*/
+const log = new Logger();
+
+//#endregion
+//#region ../../@warlock.js/logger/src/utils/capture-unhandled-errors.ts
+/**
+* Route Node's process-level failure events through the logger so they land in
+* every configured channel with full stack context. Registers one listener for
+* `unhandledRejection` and one for `uncaughtException`; call once at startup
+* after channels are configured. Pair with `autoFlushOn: ["beforeExit"]` so the
+* final entry survives the process exit that follows an uncaught exception.
+*
+* @example
+* log.configure({ channels: [new ConsoleLog(), new FileLog()] });
+* captureAnyUnhandledRejection();
+*/
+function captureAnyUnhandledRejection() {
+	process.on("unhandledRejection", (reason) => {
+		log.error("app", "unhandledRejection", reason);
+	});
+	process.on("uncaughtException", (error) => {
+		log.error("app", "uncaughtException", error);
+	});
+}
+
+//#endregion
+exports.ConsoleLog = ConsoleLog;
+exports.FileLog = FileLog;
+exports.JSONFileLog = JSONFileLog;
+exports.LogChannel = LogChannel;
+exports.Logger = Logger;
+exports.applyRedact = applyRedact;
+exports.captureAnyUnhandledRejection = captureAnyUnhandledRejection;
+exports.clearMessage = clearMessage;
+exports.log = log;
+exports.mergeRedact = mergeRedact;
+exports.safeJsonStringify = safeJsonStringify;
+//# sourceMappingURL=index.cjs.map