@warlock.js/logger 4.0.171 → 4.1.1

package/esm/log-channel.mjs

@@ -0,0 +1,75 @@
+//#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
+export { LogChannel };
+//# sourceMappingURL=log-channel.mjs.map

package/esm/log-channel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-channel.mjs","names":[],"sources":["../../../../../@warlock.js/logger/src/log-channel.ts"],"sourcesContent":["import type {\r\n  BasicLogConfigurations,\r\n  LogContract,\r\n  LoggingData,\r\n  RedactConfig,\r\n} from \"./types\";\r\n\r\nexport abstract class LogChannel<\r\n  Options extends BasicLogConfigurations = BasicLogConfigurations,\r\n> implements LogContract\r\n{\r\n  /**\r\n   * Channel name\r\n   */\r\n  public name!: string;\r\n\r\n  /**\r\n   * Channel description\r\n   */\r\n  public description?: string;\r\n\r\n  /**\r\n   * Determine if channel is logging in terminal\r\n   */\r\n  public terminal = false;\r\n\r\n  /**\r\n   * Default Configurations\r\n   */\r\n  protected defaultConfigurations: Options = {} as Options;\r\n\r\n  /**\r\n   * Channel configurations\r\n   */\r\n  protected channelConfigurations: Options = {} as Options; //\r\n\r\n  /**\r\n   * Determine whether the channel is fully initialized\r\n   */\r\n  protected isInitialized = false;\r\n\r\n  /**\r\n   * Constructor\r\n   */\r\n  public constructor(configurations?: Options) {\r\n    if (configurations) {\r\n      this.setConfigurations(configurations);\r\n    }\r\n\r\n    setTimeout(async () => {\r\n      if (this.init) {\r\n        await this.init();\r\n      }\r\n\r\n      this.isInitialized = true;\r\n    }, 0);\r\n  }\r\n\r\n  /**\r\n   * Initialize the channel\r\n   */\r\n  protected init?(): void | Promise<void>;\r\n\r\n  /**\r\n   * Get config value\r\n   */\r\n  protected config<K extends keyof Options>(key: K): Options[K] {\r\n    return (\r\n      this.channelConfigurations[key] ?? (this.defaultConfigurations ?? {})[key]\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Set configurations\r\n   */\r\n  protected setConfigurations(configurations: Options) {\r\n    this.channelConfigurations = {\r\n      ...this.channelConfigurations,\r\n      ...configurations,\r\n    };\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Determine if the message should be logged\r\n   */\r\n  protected shouldBeLogged(data: LoggingData): boolean {\r\n    // check for debug mode\r\n    const allowedLevels = this.config(\"levels\");\r\n\r\n    if (allowedLevels?.length && !allowedLevels.includes(data.type))\r\n      return false;\r\n\r\n    const filter = this.config(\"filter\");\r\n\r\n    if (filter) {\r\n      return filter(data);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Log the given message\r\n   */\r\n  public abstract log(data: LoggingData): void | Promise<void>;\r\n\r\n  /**\r\n   * Synchronously flush messages\r\n   */\r\n  public flushSync?(): void;\r\n\r\n  /**\r\n   * Read the channel's redact config (if any). Used by `Logger` to apply\r\n   * per-channel additive redaction on top of the logger-wide floor.\r\n   * Subclasses normally don't override this — set `redact` in your channel\r\n   * configuration instead.\r\n   */\r\n  public getRedactConfig(): RedactConfig | undefined {\r\n    return this.config(\"redact\" as keyof Options) as\r\n      | RedactConfig\r\n      | undefined;\r\n  }\r\n\r\n  /**\r\n   * Get date and time formats\r\n   */\r\n  protected getDateAndTimeFormat() {\r\n    const dateFormat = this.config(\"dateFormat\");\r\n    const date = dateFormat?.date ?? \"DD-MM-YYYY\";\r\n    const time = dateFormat?.time ?? \"HH:mm:ss\";\r\n\r\n    return { date, time };\r\n  }\r\n\r\n  /**\r\n   * get basic configurations with the given ones\r\n   */\r\n  protected withBasicConfigurations(configurations: Partial<Options>): Options {\r\n    return {\r\n      filter: () => true,\r\n      ...configurations,\r\n    } as any as Options;\r\n  }\r\n}\r\n"],"mappings":";AAOA,IAAsB,aAAtB,MAGA;;;;CAkCE,AAAO,YAAY,gBAA0B;kBApB3B;+BAKyB,CAAC;+BAKD,CAAC;uBAKlB;EAMxB,IAAI,gBACF,KAAK,kBAAkB,cAAc;EAGvC,WAAW,YAAY;GACrB,IAAI,KAAK,MACP,MAAM,KAAK,KAAK;GAGlB,KAAK,gBAAgB;EACvB,GAAG,CAAC;CACN;;;;CAUA,AAAU,OAAgC,KAAoB;EAC5D,OACE,KAAK,sBAAsB,SAAS,KAAK,yBAAyB,CAAC,GAAG;CAE1E;;;;CAKA,AAAU,kBAAkB,gBAAyB;EACnD,KAAK,wBAAwB;GAC3B,GAAG,KAAK;GACR,GAAG;EACL;EAEA,OAAO;CACT;;;;CAKA,AAAU,eAAe,MAA4B;EAEnD,MAAM,gBAAgB,KAAK,OAAO,QAAQ;EAE1C,IAAI,eAAe,UAAU,CAAC,cAAc,SAAS,KAAK,IAAI,GAC5D,OAAO;EAET,MAAM,SAAS,KAAK,OAAO,QAAQ;EAEnC,IAAI,QACF,OAAO,OAAO,IAAI;EAGpB,OAAO;CACT;;;;;;;CAkBA,AAAO,kBAA4C;EACjD,OAAO,KAAK,OAAO,QAAyB;CAG9C;;;;CAKA,AAAU,uBAAuB;EAC/B,MAAM,aAAa,KAAK,OAAO,YAAY;EAI3C,OAAO;GAAE,MAHI,YAAY,QAAQ;GAGlB,MAFF,YAAY,QAAQ;EAEb;CACtB;;;;CAKA,AAAU,wBAAwB,gBAA2C;EAC3E,OAAO;GACL,cAAc;GACd,GAAG;EACL;CACF;AACF"}

package/esm/logger.d.mts

@@ -0,0 +1,184 @@
+import { AutoFlushEvent, BasicLogConfigurations, LogLevel, LoggingData, OmittedLoggingData, RedactConfig } from "./types.mjs";
+import { LogChannel } from "./log-channel.mjs";
+
+//#region ../../@warlock.js/logger/src/logger.d.ts
+declare class Logger {
+  /**
+   * Current channel
+   */
+  channels: LogChannel[];
+  id: string;
+  /**
+   * Registered auto-flush handlers, keyed by event name. Stored so repeated
+   * calls to `enableAutoFlush` replace rather than stack, and so
+   * `disableAutoFlush` can remove them cleanly.
+   */
+  private autoFlushHandlers;
+  /**
+   * Logger-wide minimum severity. When set, entries below this level are
+   * dropped before any channel is invoked — cheaper than per-channel `levels`
+   * filters because the fan-out loop is skipped entirely. `undefined` means
+   * no minimum (every entry reaches every channel that accepts it).
+   */
+  private minLevel?;
+  /**
+   * Logger-wide redaction floor. Applied once before fan-out — every
+   * channel receives an entry with these paths already censored. Channel
+   * configs can extend the path list (additive); they cannot remove paths
+   * set here.
+   */
+  private redactConfig?;
+  /**
+   * Add a new channel
+   */
+  addChannel(channel: LogChannel): this;
+  /**
+   * Set base configurations
+   */
+  configure(config: {
+    channels?: LogChannel[];
+    autoFlushOn?: AutoFlushEvent[];
+    minLevel?: LogLevel;
+    redact?: RedactConfig;
+  }): 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: RedactConfig | undefined): this;
+  /**
+   * Read the active logger-wide redact config (or `undefined`).
+   */
+  getRedact(): RedactConfig | undefined;
+  /**
+   * 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: LogLevel | undefined): this;
+  /**
+   * Read the active minimum severity (or `undefined` when none is set).
+   */
+  getMinLevel(): LogLevel | undefined;
+  /**
+   * Set channels
+   */
+  setChannels(channels: LogChannel[]): this;
+  /**
+   * Normalize log data to a single object
+   */
+  private normalizeLogData;
+  /**
+   * 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).
+   */
+  log(data: LoggingData): Promise<this>;
+  /**
+   * Make debug log
+   */
+  debug(dataOrModule: OmittedLoggingData | string, action?: string, message?: any, context?: Record<string, any>): Promise<this>;
+  /**
+   * Make info log
+   */
+  info(dataOrModule: OmittedLoggingData | string, action?: string, message?: any, context?: Record<string, any>): Promise<this>;
+  /**
+   * Make warn log
+   */
+  warn(dataOrModule: OmittedLoggingData | string, action?: string, message?: any, context?: Record<string, any>): Promise<this>;
+  /**
+   * Make error log
+   */
+  error(dataOrModule: OmittedLoggingData | string, action?: string, message?: any, context?: Record<string, any>): Promise<this>;
+  /**
+   * Make success log
+   */
+  success(dataOrModule: OmittedLoggingData | string, action?: string, message?: any, context?: Record<string, any>): Promise<this>;
+  /**
+   * 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: unknown, module: string, action: string, message: any, context?: Record<string, any>): Promise<Logger> | Logger;
+  /**
+   * 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: string, action: string): (extra?: Record<string, any>) => Promise<Logger>;
+  /**
+   * Get channel by name
+   */
+  channel(name: string): LogChannel<BasicLogConfigurations> | undefined;
+  /**
+   * Synchronously flush logs
+   */
+  flushSync(): void;
+  /**
+   * 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: AutoFlushEvent[]): this;
+  /**
+   * Remove every handler previously registered by `enableAutoFlush`.
+   * Safe to call when no handlers are registered.
+   */
+  disableAutoFlush(): 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.
+ */
+declare const log: Logger;
+//#endregion
+export { Logger, log };
+//# sourceMappingURL=logger.d.mts.map

package/esm/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","names":[],"sources":["../../../../../@warlock.js/logger/src/logger.ts"],"mappings":";;;;cAmCa,MAAA;;AAAb;;EAIS,QAAA,EAAU,UAAA;EAEV,EAAA;EA4BoB;;;;;EAAA,QArBnB,iBAAA;EA0EY;;;;;;EAAA,QAlEZ,QAAA;EAkLI;;;;;;EAAA,QA1KJ,YAAA;EAoMuB;;;EA/LxB,UAAA,CAAW,OAAA,EAAS,UAAA;EAsNX;;;EA7MT,SAAA,CAAU,MAAA;IACf,QAAA,GAAW,UAAA;IACX,WAAA,GAAc,cAAA;IACd,QAAA,GAAW,QAAA;IACX,MAAA,GAAS,YAAA;EAAA;EAoPyB;;;;;;;;;;;EApN7B,SAAA,CAAU,MAAA,EAAQ,YAAA;EA7ClB;;;EAqDA,SAAA,CAAA,GAAa,YAAA;EA3ClB;;;;;;;;;;EAyDK,WAAA,CAAY,KAAA,EAAO,QAAA;EAtBT;;;EA8BV,WAAA,CAAA,GAAe,QAAA;EARI;;;EAenB,WAAA,CAAY,QAAA,EAAU,UAAA;EAAtB;;;EAAA,QASC,gBAAA;EAmCK;;;;;;;;;EAAA,GAAA,CAAI,IAAA,EAAM,WAAA,GAAW,OAAA;EAuChC;;;EAJK,KAAA,CACL,YAAA,EAAc,kBAAA,WACd,MAAA,WACA,OAAA,QACA,OAAA,GAAU,MAAA,gBAAmB,OAAA;EAU7B;;;EADK,IAAA,CACL,YAAA,EAAc,kBAAA,WACd,MAAA,WACA,OAAA,QACA,OAAA,GAAU,MAAA,gBAAmB,OAAA;EAA7B;;;EASK,IAAA,CACL,YAAA,EAAc,kBAAA,WACd,MAAA,WACA,OAAA,QACA,OAAA,GAAU,MAAA,gBAAmB,OAAA;EAH7B;;;EAYK,KAAA,CACL,YAAA,EAAc,kBAAA,WACd,MAAA,WACA,OAAA,QACA,OAAA,GAAU,MAAA,gBAAmB,OAAA;EAb7B;;;EAsBK,OAAA,CACL,YAAA,EAAc,kBAAA,WACd,MAAA,WACA,OAAA,QACA,OAAA,GAAU,MAAA,gBAAmB,OAAA;EAhB7B;;;;;;;;;EAgCK,MAAA,CACL,SAAA,WACA,MAAA,UACA,MAAA,UACA,OAAA,OACA,OAAA,GAAU,MAAA,gBACT,OAAA,CAAQ,MAAA,IAAU,MAAA;EAvBnB;;;;;;;;;;EAsCK,KAAA,CACL,MAAA,UACA,MAAA,YACE,KAAA,GAAQ,MAAA,kBAAwB,OAAA,CAAQ,MAAA;EAlBzC;;;EAgCI,OAAA,CAAQ,IAAA,WAAY,UAAA,CAdgB,sBAAA;EAFzC;;;EAuBK,SAAA,CAAA;EArB6B;;;;;;;;;;;;AAwEb;AAyBzB;;;;AAA+B;EAlDtB,eAAA,CAAgB,MAAA,EAAQ,cAAA;;;;;EAyBxB,gBAAA,CAAA;AAAA;;;;;;;;;;;;;;;cAyBI,GAAA,EAAG,MAAe"}

package/esm/logger.mjs

@@ -0,0 +1,282 @@
+import { applyRedact, mergeRedact } from "./redact/redact.mjs";
+import { clearMessage } from "./utils/clear-message.mjs";
+import { Random } from "@mongez/reinforcements";
+
+//#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-" + 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
+export { Logger, log };
+//# sourceMappingURL=logger.mjs.map

package/esm/logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":[],"sources":["../../../../../@warlock.js/logger/src/logger.ts"],"sourcesContent":["import { Random } from \"@mongez/reinforcements\";\r\nimport type { LogChannel } from \"./log-channel\";\r\nimport { applyRedact, mergeRedact } from \"./redact\";\r\nimport type {\r\n  AutoFlushEvent,\r\n  LoggingData,\r\n  LogLevel,\r\n  OmittedLoggingData,\r\n  RedactConfig,\r\n} from \"./types\";\r\nimport { clearMessage } from \"./utils/clear-message\";\r\n\r\nconst SIGNAL_EVENTS: ReadonlySet<AutoFlushEvent> = new Set([\r\n  \"SIGINT\",\r\n  \"SIGTERM\",\r\n  \"SIGHUP\",\r\n  \"SIGBREAK\",\r\n  \"SIGUSR2\",\r\n]);\r\n\r\n/**\r\n * Severity ranks used by `setMinLevel`. Higher number = more severe. The\r\n * ordering matches conventional log-level hierarchies: `debug` is noisiest\r\n * and easiest to drop; `error` is the loudest and never dropped by the\r\n * minimum-level filter. `success` sits beside `info` — it's an informational\r\n * outcome, not a warning.\r\n */\r\nconst LEVEL_RANK: Record<LogLevel, number> = {\r\n  debug: 0,\r\n  info: 1,\r\n  success: 1,\r\n  warn: 2,\r\n  error: 3,\r\n};\r\n\r\nexport class Logger {\r\n  /**\r\n   * Current channel\r\n   */\r\n  public channels: LogChannel[] = [];\r\n\r\n  public id = \"logger-\" + Random.string(32);\r\n\r\n  /**\r\n   * Registered auto-flush handlers, keyed by event name. Stored so repeated\r\n   * calls to `enableAutoFlush` replace rather than stack, and so\r\n   * `disableAutoFlush` can remove them cleanly.\r\n   */\r\n  private autoFlushHandlers = new Map<AutoFlushEvent, () => void>();\r\n\r\n  /**\r\n   * Logger-wide minimum severity. When set, entries below this level are\r\n   * dropped before any channel is invoked — cheaper than per-channel `levels`\r\n   * filters because the fan-out loop is skipped entirely. `undefined` means\r\n   * no minimum (every entry reaches every channel that accepts it).\r\n   */\r\n  private minLevel?: LogLevel;\r\n\r\n  /**\r\n   * Logger-wide redaction floor. Applied once before fan-out — every\r\n   * channel receives an entry with these paths already censored. Channel\r\n   * configs can extend the path list (additive); they cannot remove paths\r\n   * set here.\r\n   */\r\n  private redactConfig?: RedactConfig;\r\n\r\n  /**\r\n   * Add a new channel\r\n   */\r\n  public addChannel(channel: LogChannel) {\r\n    this.channels.push(channel);\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Set base configurations\r\n   */\r\n  public configure(config: {\r\n    channels?: LogChannel[];\r\n    autoFlushOn?: AutoFlushEvent[];\r\n    minLevel?: LogLevel;\r\n    redact?: RedactConfig;\r\n  }) {\r\n    if (config.channels) {\r\n      this.channels = config.channels;\r\n    }\r\n\r\n    if (config.autoFlushOn) {\r\n      this.enableAutoFlush(config.autoFlushOn);\r\n    }\r\n\r\n    if (config.minLevel !== undefined) {\r\n      this.setMinLevel(config.minLevel);\r\n    }\r\n\r\n    if (config.redact !== undefined) {\r\n      this.setRedact(config.redact);\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Set the logger-wide redaction floor. Applied to every entry before\r\n   * fan-out; channel configs add more paths on top, never fewer. Pass\r\n   * `undefined` to clear.\r\n   *\r\n   * @example\r\n   * log.setRedact({\r\n   *   paths: [\"context.password\", \"context.*.token\"],\r\n   *   censor: \"[REDACTED]\",\r\n   * });\r\n   */\r\n  public setRedact(config: RedactConfig | undefined): this {\r\n    this.redactConfig = config;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Read the active logger-wide redact config (or `undefined`).\r\n   */\r\n  public getRedact(): RedactConfig | undefined {\r\n    return this.redactConfig;\r\n  }\r\n\r\n  /**\r\n   * Drop every entry whose severity is below `level` before fan-out. Cheaper\r\n   * than per-channel `levels` filters because the loop never runs and no\r\n   * channel receives the entry. Pass `undefined` to clear and accept all\r\n   * levels again.\r\n   *\r\n   * @example\r\n   * // production: silence debug noise everywhere at once\r\n   * logger.setMinLevel(\"info\");\r\n   */\r\n  public setMinLevel(level: LogLevel | undefined): this {\r\n    this.minLevel = level;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Read the active minimum severity (or `undefined` when none is set).\r\n   */\r\n  public getMinLevel(): LogLevel | undefined {\r\n    return this.minLevel;\r\n  }\r\n\r\n  /**\r\n   * Set channels\r\n   */\r\n  public setChannels(channels: LogChannel[]) {\r\n    this.channels = channels;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Normalize log data to a single object\r\n   */\r\n  private normalizeLogData(\r\n    dataOrModule: LoggingData | OmittedLoggingData | string,\r\n    action?: string,\r\n    message: any = \"\",\r\n    level?: LogLevel,\r\n    context?: Record<string, any>,\r\n  ): LoggingData {\r\n    if (typeof dataOrModule === \"object\") {\r\n      // If level is provided, override type\r\n      return {\r\n        type: (level || (dataOrModule as any).type || \"info\") as LogLevel,\r\n        module: dataOrModule.module,\r\n        action: dataOrModule.action,\r\n        message: dataOrModule.message,\r\n        ...(context ? { context } : dataOrModule.context ? { context: dataOrModule.context } : {}),\r\n      };\r\n    }\r\n    return {\r\n      type: (level || \"info\") as LogLevel,\r\n      module: dataOrModule,\r\n      action: action as string,\r\n      message,\r\n      ...(context ? { context } : {}),\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Make log\r\n   *\r\n   * Fans out a single log entry to every registered channel. Non-terminal\r\n   * channels receive a copy whose `message` has had ANSI color codes stripped\r\n   * — each channel sees its own shallow clone so one channel cannot observe\r\n   * another's mutations (e.g. a later terminal channel still sees the original\r\n   * colored message).\r\n   */\r\n  public async log(data: LoggingData) {\r\n    if (this.minLevel && LEVEL_RANK[data.type] < LEVEL_RANK[this.minLevel]) {\r\n      return this;\r\n    }\r\n\r\n    // Apply the logger-wide redact floor once. Every channel sees the\r\n    // result; no channel can undo a logger-wide redaction (additive-only\r\n    // semantics).\r\n    const baseEntry = applyRedact(data, this.redactConfig);\r\n\r\n    for (const channel of this.channels) {\r\n      const channelRedact = channel.getRedactConfig?.();\r\n      const effectiveRedact = channelRedact\r\n        ? mergeRedact(this.redactConfig, channelRedact)\r\n        : undefined;\r\n\r\n      // When the channel adds paths, redact again from `data` rather than\r\n      // from `baseEntry` so the merged config (which already contains the\r\n      // logger-wide paths) does the full pass — avoids double-cloning the\r\n      // already-redacted base.\r\n      let payload = effectiveRedact ? applyRedact(data, effectiveRedact) : baseEntry;\r\n\r\n      if (channel.terminal === false) {\r\n        payload = { ...payload, message: clearMessage(payload.message) };\r\n      }\r\n\r\n      channel.log(payload);\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Make debug log\r\n   */\r\n  public debug(\r\n    dataOrModule: OmittedLoggingData | string,\r\n    action?: string,\r\n    message: any = \"\",\r\n    context?: Record<string, any>,\r\n  ) {\r\n    const data = this.normalizeLogData(dataOrModule, action, message, \"debug\", context);\r\n    return this.log(data);\r\n  }\r\n\r\n  /**\r\n   * Make info log\r\n   */\r\n  public info(\r\n    dataOrModule: OmittedLoggingData | string,\r\n    action?: string,\r\n    message: any = \"\",\r\n    context?: Record<string, any>,\r\n  ) {\r\n    const data = this.normalizeLogData(dataOrModule, action, message, \"info\", context);\r\n    return this.log(data);\r\n  }\r\n\r\n  /**\r\n   * Make warn log\r\n   */\r\n  public warn(\r\n    dataOrModule: OmittedLoggingData | string,\r\n    action?: string,\r\n    message: any = \"\",\r\n    context?: Record<string, any>,\r\n  ) {\r\n    const data = this.normalizeLogData(dataOrModule, action, message, \"warn\", context);\r\n    return this.log(data);\r\n  }\r\n\r\n  /**\r\n   * Make error log\r\n   */\r\n  public error(\r\n    dataOrModule: OmittedLoggingData | string,\r\n    action?: string,\r\n    message: any = \"\",\r\n    context?: Record<string, any>,\r\n  ) {\r\n    const data = this.normalizeLogData(dataOrModule, action, message, \"error\", context);\r\n    return this.log(data);\r\n  }\r\n\r\n  /**\r\n   * Make success log\r\n   */\r\n  public success(\r\n    dataOrModule: OmittedLoggingData | string,\r\n    action?: string,\r\n    message: any = \"\",\r\n    context?: Record<string, any>,\r\n  ) {\r\n    const data = this.normalizeLogData(dataOrModule, action, message, \"success\", context);\r\n\r\n    return this.log(data);\r\n  }\r\n\r\n  /**\r\n   * Log an `error` entry when `condition` is falsy. No-op otherwise — the\r\n   * entry is never built and channels are not invoked, so this is genuinely\r\n   * free in the happy path. Mirrors the spirit of `console.assert` but routes\r\n   * through the logger pipeline so persistent channels capture failures.\r\n   *\r\n   * @example\r\n   * log.assert(user !== null, \"auth\", \"session\", \"user vanished mid-flight\", { sessionId });\r\n   */\r\n  public assert(\r\n    condition: unknown,\r\n    module: string,\r\n    action: string,\r\n    message: any,\r\n    context?: Record<string, any>,\r\n  ): Promise<Logger> | Logger {\r\n    if (condition) return this;\r\n    return this.error(module, action, message, context);\r\n  }\r\n\r\n  /**\r\n   * Start a duration timer. The returned function emits an `info` entry\r\n   * with `completed in <ms>ms` and a `durationMs` field in `context` when\r\n   * called. Pass an object to `end()` to merge extra fields into context.\r\n   *\r\n   * @example\r\n   * const end = log.timer(\"db\", \"users.findById\");\r\n   * const user = await usersRepo.findById(id);\r\n   * end({ id, found: !!user });\r\n   */\r\n  public timer(\r\n    module: string,\r\n    action: string,\r\n  ): (extra?: Record<string, any>) => Promise<Logger> {\r\n    const startedAt = Date.now();\r\n    return (extra?: Record<string, any>) => {\r\n      const durationMs = Date.now() - startedAt;\r\n      return this.info(module, action, `completed in ${durationMs}ms`, {\r\n        durationMs,\r\n        ...(extra ?? {}),\r\n      });\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Get channel by name\r\n   */\r\n  public channel(name: string) {\r\n    return this.channels.find((channel) => channel.name === name);\r\n  }\r\n\r\n  /**\r\n   * Synchronously flush logs\r\n   */\r\n  public flushSync() {\r\n    for (const channel of this.channels) {\r\n      if (channel.flushSync) {\r\n        channel.flushSync();\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Register one process-level handler per event that calls `flushSync()`\r\n   * before the process terminates.\r\n   *\r\n   * For signal events (`SIGINT`, `SIGTERM`, `SIGHUP`, `SIGBREAK`, `SIGUSR2`)\r\n   * the handler flushes and then re-raises the signal so Node's default exit\r\n   * behavior runs. For `beforeExit`, the handler flushes in place — Node exits\r\n   * naturally afterwards.\r\n   *\r\n   * Idempotent: calling with the same events replaces the previous handlers.\r\n   * Call `disableAutoFlush()` to unregister.\r\n   *\r\n   * @example\r\n   * log.configure({\r\n   *   channels: [new ConsoleLog(), new FileLog()],\r\n   *   autoFlushOn: [\"SIGINT\", \"SIGTERM\", \"beforeExit\"],\r\n   * });\r\n   */\r\n  public enableAutoFlush(events: AutoFlushEvent[]): this {\r\n    this.disableAutoFlush();\r\n\r\n    for (const event of events) {\r\n      const handler = SIGNAL_EVENTS.has(event)\r\n        ? () => {\r\n            this.flushSync();\r\n            process.off(event, handler);\r\n            process.kill(process.pid, event as NodeJS.Signals);\r\n          }\r\n        : () => {\r\n            this.flushSync();\r\n          };\r\n\r\n      process.on(event, handler);\r\n      this.autoFlushHandlers.set(event, handler);\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Remove every handler previously registered by `enableAutoFlush`.\r\n   * Safe to call when no handlers are registered.\r\n   */\r\n  public disableAutoFlush(): this {\r\n    for (const [event, handler] of this.autoFlushHandlers) {\r\n      process.off(event, handler);\r\n    }\r\n\r\n    this.autoFlushHandlers.clear();\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\n/**\r\n * The package singleton. Use this for everyday logging — `log.info(...)`,\r\n * `log.error(...)`, `log.configure(...)`. Custom logger instances can be\r\n * created by instantiating `Logger` directly.\r\n *\r\n * The name is intentionally short: `log` reads naturally at the call site\r\n * (`log.info(\"auth\", \"login\", \"ok\")`) and matches the convention used in\r\n * pino, bunyan, and most JS logging tutorials.\r\n *\r\n * Note that `log` is a `Logger` instance, **not** a function — the bare\r\n * callable form was removed when the dual `log` / `logger` exports were\r\n * collapsed into a single name. Use `log.info(...)` (or any other level\r\n * shortcut) to emit entries.\r\n */\r\nexport const log = new Logger();\r\n"],"mappings":"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"}

package/esm/redact/redact.d.mts

@@ -0,0 +1,25 @@
+import { LoggingData, RedactConfig } from "../types.mjs";
+
+//#region ../../@warlock.js/logger/src/redact/redact.d.ts
+/**
+ * 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.
+ */
+declare function applyRedact(data: LoggingData, config: RedactConfig | undefined): LoggingData;
+/**
+ * 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]"`.
+ */
+declare function mergeRedact(base: RedactConfig | undefined, extra: RedactConfig | undefined): RedactConfig | undefined;
+//#endregion
+export { applyRedact, mergeRedact };
+//# sourceMappingURL=redact.d.mts.map

package/esm/redact/redact.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.mts","names":[],"sources":["../../../../../../@warlock.js/logger/src/redact/redact.ts"],"mappings":";;;;;AAyIA;;;;;;iBAAgB,WAAA,CACd,IAAA,EAAM,WAAA,EACN,MAAA,EAAQ,YAAA,eACP,WAAA;;;;;;;;AAAW;AA0Bd;iBAAgB,WAAA,CACd,IAAA,EAAM,YAAA,cACN,KAAA,EAAO,YAAA,eACN,YAAA"}