@decaf-ts/logging 0.3.12 → 0.3.13

package/lib/LoggedClass.cjs

@@ -3,12 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggedClass = void 0;
 const logging_1 = require("./logging.cjs");
 /**
- * @description Base class that provides a ready-to-use logger instance
- * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
- * into derived classes through a protected getter. Subclasses can directly access
- * this.log to emit messages without manually creating a logger. This promotes
- * consistent, context-aware logging across the codebase.
- * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+ * @description Base class that provides a ready-to-use logger instance.
+ * @summary Supplies inheriting classes with a lazily created, context-aware {@link Logger} via the protected `log` getter, promoting consistent structured logging without manual wiring.
  * @class LoggedClass
  * @example
  * class UserService extends LoggedClass {
@@ -36,15 +32,16 @@ const logging_1 = require("./logging.cjs");
  */
 class LoggedClass {
     /**
-     * @description Lazily provides a context-aware logger for the current instance
-     * @summary Uses Logging.for(this) to create a logger whose context is the
-     * subclass name, allowing uniform and structured logs from any inheriting class.
-     * @return {Logger} A logger bound to the subclass context
+     * @description Lazily provides a context-aware logger for the current instance.
+     * @summary Calls {@link Logging.for} with the subclass instance to obtain a logger whose context matches the subclass name.
+     * @return {Logger} Logger bound to the subclass context.
      */
     get log() {
-        return logging_1.Logging.for(this);
+        if (!this._log)
+            this._log = logging_1.Logging.for(this);
+        return this._log;
     }
     constructor() { }
 }
 exports.LoggedClass = LoggedClass;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/LoggedClass.d.ts

@@ -1,11 +1,7 @@
 import { Logger } from "./types";
 /**
- * @description Base class that provides a ready-to-use logger instance
- * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
- * into derived classes through a protected getter. Subclasses can directly access
- * this.log to emit messages without manually creating a logger. This promotes
- * consistent, context-aware logging across the codebase.
- * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+ * @description Base class that provides a ready-to-use logger instance.
+ * @summary Supplies inheriting classes with a lazily created, context-aware {@link Logger} via the protected `log` getter, promoting consistent structured logging without manual wiring.
  * @class LoggedClass
  * @example
  * class UserService extends LoggedClass {
@@ -32,11 +28,11 @@ import { Logger } from "./types";
  *   Instance->>Logger: info/debug/error(...)
  */
 export declare abstract class LoggedClass {
+    private _log?;
     /**
-     * @description Lazily provides a context-aware logger for the current instance
-     * @summary Uses Logging.for(this) to create a logger whose context is the
-     * subclass name, allowing uniform and structured logs from any inheriting class.
-     * @return {Logger} A logger bound to the subclass context
+     * @description Lazily provides a context-aware logger for the current instance.
+     * @summary Calls {@link Logging.for} with the subclass instance to obtain a logger whose context matches the subclass name.
+     * @return {Logger} Logger bound to the subclass context.
      */
     protected get log(): Logger;
     protected constructor();

package/lib/constants.cjs

@@ -1,12 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultLoggingConfig = exports.DefaultTheme = exports.LoggingMode = exports.NumericLogLevels = exports.LogLevel = exports.DefaultPlaceholderWrappers = exports.ENV_PATH_DELIMITER = exports.BrowserEnvKey = void 0;
+/**
+ * @description Global key used to store environment variables in browser contexts.
+ * @summary Enables the logging environment helpers to locate serialized environment configuration on `globalThis`.
+ * @const BrowserEnvKey
+ * @type {string}
+ * @memberOf module:Logging
+ */
 exports.BrowserEnvKey = "ENV";
 /**
  * @description Delimiter used for composing nested environment variable names.
  * @summary Joins parent and child keys when mapping object paths to ENV strings.
+ * @const ENV_PATH_DELIMITER
+ * @type {string}
+ * @memberOf module:Logging
  */
 exports.ENV_PATH_DELIMITER = "__";
+/**
+ * @description Default prefix and suffix used for template placeholders.
+ * @summary Provides wrapper strings applied when interpolating messages with {@link patchPlaceholders}.
+ * @const DefaultPlaceholderWrappers
+ * @type {string[]}
+ * @memberOf module:Logging
+ */
 exports.DefaultPlaceholderWrappers = ["${", "}"];
 /**
  * @description Enum for log levels.
@@ -17,21 +34,24 @@ exports.DefaultPlaceholderWrappers = ["${", "}"];
  */
 var LogLevel;
 (function (LogLevel) {
-    /** Error events that are likely to cause problems. */
+    /** @description Benchmark events that capture performance metrics. */
+    LogLevel["benchmark"] = "benchmark";
+    /** @description Error events that indicate failures requiring attention. */
     LogLevel["error"] = "error";
-    /** Routine information, such as ongoing status or performance. */
+    /** @description Informational events describing normal operation. */
     LogLevel["info"] = "info";
-    /** Additional relevant information. */
+    /** @description Verbose diagnostic information for detailed tracing. */
     LogLevel["verbose"] = "verbose";
-    /** Debug or trace information. */
+    /** @description Debug or trace details aimed at developers. */
     LogLevel["debug"] = "debug";
-    /** way too verbose or silly information. */
+    /** @description Extremely chatty or playful log entries. */
     LogLevel["silly"] = "silly";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
 /**
  * @description Numeric values associated with log levels.
  * @summary Provides a numeric representation of log levels for comparison and filtering.
- * @const NumericLogLevels
+ * @typedef {Object} NumericLogLevelsShape
+ * @property {number} benchmark - Numeric value for benchmark level (0).
  * @property {number} error - Numeric value for error level (2).
  * @property {number} info - Numeric value for info level (4).
  * @property {number} verbose - Numeric value for verbose level (6).
@@ -39,7 +59,15 @@ var LogLevel;
  * @property {number} silly - Numeric value for silly level (9).
  * @memberOf module:Logging
  */
+/**
+ * @description Numeric values associated with log levels.
+ * @summary Provides a numeric representation of log levels for comparison and filtering.
+ * @const NumericLogLevels
+ * @type {NumericLogLevelsShape}
+ * @memberOf module:Logging
+ */
 exports.NumericLogLevels = {
+    benchmark: 0,
     error: 2,
     info: 4,
     verbose: 6,
@@ -62,7 +90,6 @@ var LoggingMode;
 /**
  * @description Default theme for styling log output.
  * @summary Defines the default color and style settings for various components of log messages.
- * @const DefaultTheme
  * @typedef {Theme} DefaultTheme
  * @property {Object} class - Styling for class names.
  * @property {number} class.fg - Foreground color code for class names (34).
@@ -82,6 +109,7 @@ var LoggingMode;
  * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).
  * @property {Object} logLevel.debug - Styling for debug level logs.
  * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).
+ * @const DefaultTheme
  * @memberOf module:Logging
  */
 exports.DefaultTheme = {
@@ -102,6 +130,10 @@ exports.DefaultTheme = {
     },
     method: {},
     logLevel: {
+        benchmark: {
+            fg: 32,
+            style: ["bold"],
+        },
         error: {
             fg: 31,
             style: ["bold"],
@@ -152,4 +184,4 @@ exports.DefaultLoggingConfig = {
     pattern: "{level} [{timestamp}] {app} {context} {separator} {message} {stack}",
     theme: exports.DefaultTheme,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAEa,QAAA,aAAa,GAAG,KAAK,CAAC;AAEnC;;;GAGG;AACU,QAAA,kBAAkB,GAAG,IAAI,CAAC;AAE1B,QAAA,0BAA0B,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEtD;;;;;;GAMG;AACH,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,wBAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;GAKG;AACH,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4CAA4C;IAC5C,0BAAW,CAAA;IACX,sCAAsC;IACtC,4BAAa,CAAA;AACf,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,QAAA,YAAY,GAAU;IACjC,GAAG,EAAE,EAAE;IACP,SAAS,EAAE,EAAE;IACb,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,OAAO,EAAE;YACP,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,oBAAoB,GAAkB;IACjD,GAAG,EAAE,aAAa;IAClB,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,KAAK;IACZ,gBAAgB,EAAE,GAAG;IACrB,SAAS,EAAE,GAAG;IACd,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,WAAW,CAAC,GAAG;IACvB,OAAO,EACL,qEAAqE;IACvE,KAAK,EAAE,oBAAY;CACpB,CAAC","sourcesContent":["import { LoggingConfig, Theme } from \"./types\";\n\nexport const BrowserEnvKey = \"ENV\";\n\n/**\n * @description Delimiter used for composing nested environment variable names.\n * @summary Joins parent and child keys when mapping object paths to ENV strings.\n */\nexport const ENV_PATH_DELIMITER = \"__\";\n\nexport const DefaultPlaceholderWrappers = [\"${\", \"}\"];\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @readonly\n * @memberOf module:Logging\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const NumericLogLevels\n * @property {number} error - Numeric value for error level (2).\n * @property {number} info - Numeric value for info level (4).\n * @property {number} verbose - Numeric value for verbose level (6).\n * @property {number} debug - Numeric value for debug level (7).\n * @property {number} silly - Numeric value for silly level (9).\n * @memberOf module:Logging\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Enum for logging output modes.\n * @summary Defines different output formats for log messages.\n * @enum {string}\n * @memberOf module:Logging\n */\nexport enum LoggingMode {\n  /** Raw text format for human readability */\n  RAW = \"raw\",\n  /** JSON format for machine parsing */\n  JSON = \"json\",\n}\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (34).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (31).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (31).\n * @property {string[]} logLevel.error.style - Style attributes for error level logs ([\"bold\"]).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).\n * @memberOf module:Logging\n */\nexport const DefaultTheme: Theme = {\n  app: {},\n  separator: {},\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    verbose: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    debug: {\n      fg: 33,\n      style: [\"bold\"],\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} logLevel - Whether to display log level in output (true).\n * @property {LoggingMode} mode - Output format mode (LoggingMode.RAW).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {string} separator - Separator between log components (\" - \").\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf module:Logging\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  env: \"development\",\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  style: false,\n  contextSeparator: \".\",\n  separator: \"-\",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  format: LoggingMode.RAW,\n  pattern:\n    \"{level} [{timestamp}] {app} {context} {separator} {message} {stack}\",\n  theme: DefaultTheme,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAEA;;;;;;GAMG;AACU,QAAA,aAAa,GAAG,KAAK,CAAC;AAEnC;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG,IAAI,CAAC;AAEvC;;;;;;GAMG;AACU,QAAA,0BAA0B,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEtD;;;;;;GAMG;AACH,IAAY,QAaX;AAbD,WAAY,QAAQ;IAClB,sEAAsE;IACtE,mCAAuB,CAAA;IACvB,4EAA4E;IAC5E,2BAAe,CAAA;IACf,qEAAqE;IACrE,yBAAa,CAAA;IACb,wEAAwE;IACxE,+BAAmB,CAAA;IACnB,+DAA+D;IAC/D,2BAAe,CAAA;IACf,4DAA4D;IAC5D,2BAAe,CAAA;AACjB,CAAC,EAbW,QAAQ,wBAAR,QAAQ,QAanB;AAED;;;;;;;;;;;GAWG;AACH;;;;;;GAMG;AACU,QAAA,gBAAgB,GAAG;IAC9B,SAAS,EAAE,CAAC;IACZ,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;GAKG;AACH,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4CAA4C;IAC5C,0BAAW,CAAA;IACX,sCAAsC;IACtC,4BAAa,CAAA;AACf,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,QAAA,YAAY,GAAU;IACjC,GAAG,EAAE,EAAE;IACP,SAAS,EAAE,EAAE;IACb,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,OAAO,EAAE;YACP,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,oBAAoB,GAAkB;IACjD,GAAG,EAAE,aAAa;IAClB,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,KAAK;IACZ,gBAAgB,EAAE,GAAG;IACrB,SAAS,EAAE,GAAG;IACd,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,WAAW,CAAC,GAAG;IACvB,OAAO,EACL,qEAAqE;IACvE,KAAK,EAAE,oBAAY;CACpB,CAAC","sourcesContent":["import { LoggingConfig, Theme } from \"./types\";\n\n/**\n * @description Global key used to store environment variables in browser contexts.\n * @summary Enables the logging environment helpers to locate serialized environment configuration on `globalThis`.\n * @const BrowserEnvKey\n * @type {string}\n * @memberOf module:Logging\n */\nexport const BrowserEnvKey = \"ENV\";\n\n/**\n * @description Delimiter used for composing nested environment variable names.\n * @summary Joins parent and child keys when mapping object paths to ENV strings.\n * @const ENV_PATH_DELIMITER\n * @type {string}\n * @memberOf module:Logging\n */\nexport const ENV_PATH_DELIMITER = \"__\";\n\n/**\n * @description Default prefix and suffix used for template placeholders.\n * @summary Provides wrapper strings applied when interpolating messages with {@link patchPlaceholders}.\n * @const DefaultPlaceholderWrappers\n * @type {string[]}\n * @memberOf module:Logging\n */\nexport const DefaultPlaceholderWrappers = [\"${\", \"}\"];\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @readonly\n * @memberOf module:Logging\n */\nexport enum LogLevel {\n  /** @description Benchmark events that capture performance metrics. */\n  benchmark = \"benchmark\",\n  /** @description Error events that indicate failures requiring attention. */\n  error = \"error\",\n  /** @description Informational events describing normal operation. */\n  info = \"info\",\n  /** @description Verbose diagnostic information for detailed tracing. */\n  verbose = \"verbose\",\n  /** @description Debug or trace details aimed at developers. */\n  debug = \"debug\",\n  /** @description Extremely chatty or playful log entries. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @typedef {Object} NumericLogLevelsShape\n * @property {number} benchmark - Numeric value for benchmark level (0).\n * @property {number} error - Numeric value for error level (2).\n * @property {number} info - Numeric value for info level (4).\n * @property {number} verbose - Numeric value for verbose level (6).\n * @property {number} debug - Numeric value for debug level (7).\n * @property {number} silly - Numeric value for silly level (9).\n * @memberOf module:Logging\n */\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const NumericLogLevels\n * @type {NumericLogLevelsShape}\n * @memberOf module:Logging\n */\nexport const NumericLogLevels = {\n  benchmark: 0,\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Enum for logging output modes.\n * @summary Defines different output formats for log messages.\n * @enum {string}\n * @memberOf module:Logging\n */\nexport enum LoggingMode {\n  /** Raw text format for human readability */\n  RAW = \"raw\",\n  /** JSON format for machine parsing */\n  JSON = \"json\",\n}\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (34).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (31).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (31).\n * @property {string[]} logLevel.error.style - Style attributes for error level logs ([\"bold\"]).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).\n * @const DefaultTheme\n * @memberOf module:Logging\n */\nexport const DefaultTheme: Theme = {\n  app: {},\n  separator: {},\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    benchmark: {\n      fg: 32,\n      style: [\"bold\"],\n    },\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    verbose: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    debug: {\n      fg: 33,\n      style: [\"bold\"],\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} logLevel - Whether to display log level in output (true).\n * @property {LoggingMode} mode - Output format mode (LoggingMode.RAW).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {string} separator - Separator between log components (\" - \").\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf module:Logging\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  env: \"development\",\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  style: false,\n  contextSeparator: \".\",\n  separator: \"-\",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  format: LoggingMode.RAW,\n  pattern:\n    \"{level} [{timestamp}] {app} {context} {separator} {message} {stack}\",\n  theme: DefaultTheme,\n};\n"]}

package/lib/constants.d.ts

@@ -1,10 +1,27 @@
 import { LoggingConfig, Theme } from "./types";
+/**
+ * @description Global key used to store environment variables in browser contexts.
+ * @summary Enables the logging environment helpers to locate serialized environment configuration on `globalThis`.
+ * @const BrowserEnvKey
+ * @type {string}
+ * @memberOf module:Logging
+ */
 export declare const BrowserEnvKey = "ENV";
 /**
  * @description Delimiter used for composing nested environment variable names.
  * @summary Joins parent and child keys when mapping object paths to ENV strings.
+ * @const ENV_PATH_DELIMITER
+ * @type {string}
+ * @memberOf module:Logging
  */
 export declare const ENV_PATH_DELIMITER = "__";
+/**
+ * @description Default prefix and suffix used for template placeholders.
+ * @summary Provides wrapper strings applied when interpolating messages with {@link patchPlaceholders}.
+ * @const DefaultPlaceholderWrappers
+ * @type {string[]}
+ * @memberOf module:Logging
+ */
 export declare const DefaultPlaceholderWrappers: string[];
 /**
  * @description Enum for log levels.
@@ -14,21 +31,24 @@ export declare const DefaultPlaceholderWrappers: string[];
  * @memberOf module:Logging
  */
 export declare enum LogLevel {
-    /** Error events that are likely to cause problems. */
+    /** @description Benchmark events that capture performance metrics. */
+    benchmark = "benchmark",
+    /** @description Error events that indicate failures requiring attention. */
     error = "error",
-    /** Routine information, such as ongoing status or performance. */
+    /** @description Informational events describing normal operation. */
     info = "info",
-    /** Additional relevant information. */
+    /** @description Verbose diagnostic information for detailed tracing. */
     verbose = "verbose",
-    /** Debug or trace information. */
+    /** @description Debug or trace details aimed at developers. */
     debug = "debug",
-    /** way too verbose or silly information. */
+    /** @description Extremely chatty or playful log entries. */
     silly = "silly"
 }
 /**
  * @description Numeric values associated with log levels.
  * @summary Provides a numeric representation of log levels for comparison and filtering.
- * @const NumericLogLevels
+ * @typedef {Object} NumericLogLevelsShape
+ * @property {number} benchmark - Numeric value for benchmark level (0).
  * @property {number} error - Numeric value for error level (2).
  * @property {number} info - Numeric value for info level (4).
  * @property {number} verbose - Numeric value for verbose level (6).
@@ -36,7 +56,15 @@ export declare enum LogLevel {
  * @property {number} silly - Numeric value for silly level (9).
  * @memberOf module:Logging
  */
+/**
+ * @description Numeric values associated with log levels.
+ * @summary Provides a numeric representation of log levels for comparison and filtering.
+ * @const NumericLogLevels
+ * @type {NumericLogLevelsShape}
+ * @memberOf module:Logging
+ */
 export declare const NumericLogLevels: {
+    benchmark: number;
     error: number;
     info: number;
     verbose: number;
@@ -58,7 +86,6 @@ export declare enum LoggingMode {
 /**
  * @description Default theme for styling log output.
  * @summary Defines the default color and style settings for various components of log messages.
- * @const DefaultTheme
  * @typedef {Theme} DefaultTheme
  * @property {Object} class - Styling for class names.
  * @property {number} class.fg - Foreground color code for class names (34).
@@ -78,6 +105,7 @@ export declare enum LoggingMode {
  * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).
  * @property {Object} logLevel.debug - Styling for debug level logs.
  * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).
+ * @const DefaultTheme
  * @memberOf module:Logging
  */
 export declare const DefaultTheme: Theme;

package/lib/decorators.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.log = log;
+exports.benchmark = benchmark;
 exports.debug = debug;
 exports.info = info;
 exports.silly = silly;
@@ -8,13 +9,16 @@ exports.verbose = verbose;
 exports.final = final;
 const constants_1 = require("./constants.cjs");
 const logging_1 = require("./logging.cjs");
+const time_1 = require("./time.cjs");
+const LoggedClass_1 = require("./LoggedClass.cjs");
 /**
- * @description Method decorator for logging function calls
- * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity
- * @param {LogLevel} level - The log level to use (default: LogLevel.info)
- * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
- * @param {number} [verbosity=0] - The verbosity level for the log messages (default: 0)
- * @return {Function} A method decorator that wraps the original method with logging
+ * @description Method decorator for logging function calls.
+ * @summary Wraps class methods to automatically log entry, exit, timing, and optional custom messages at a configurable {@link LogLevel}.
+ * @param {LogLevel} level - Log level applied to the generated log statements (defaults to `LogLevel.info`).
+ * @param {number} [verbosity=0] - Verbosity threshold required for the entry log to appear.
+ * @param {ArgFormatFunction} [entryMessage] - Formatter invoked with the original method arguments to describe the invocation.
+ * @param {ReturnFormatFunction} [exitMessage] - Optional formatter that describes the outcome or failure of the call.
+ * @return {function(any, any, PropertyDescriptor): void} Method decorator proxy that injects logging behavior.
  * @function log
  * @mermaid
  * sequenceDiagram
@@ -39,93 +43,153 @@ const logging_1 = require("./logging.cjs");
  *   end
  * @category Method Decorators
  */
-function log(level = constants_1.LogLevel.info, benchmark = false, verbosity = 0) {
-    return function (target, propertyKey, descriptor) {
-        if (!descriptor)
+function log(level = constants_1.LogLevel.info, verbosity = 0, entryMessage = (...args) => `called with ${args}`, exitMessage) {
+    return function log(target, propertyKey, descriptor) {
+        if (!descriptor || typeof descriptor === "number")
             throw new Error(`Logging decoration only applies to methods`);
-        const logger = logging_1.Logging.for(target).for(target[propertyKey]);
+        const logger = target instanceof LoggedClass_1.LoggedClass
+            ? target["log"].for(target[propertyKey])
+            : logging_1.Logging.for(target).for(target[propertyKey]);
         const method = logger[level].bind(logger);
         const originalMethod = descriptor.value;
         descriptor.value = new Proxy(originalMethod, {
             apply(fn, thisArg, args) {
-                method(`called with ${args}`, verbosity);
-                const start = Date.now();
+                method(entryMessage(...args), verbosity);
+                try {
+                    const result = Reflect.apply(fn, thisArg, args);
+                    if (result instanceof Promise) {
+                        return result
+                            .then((r) => {
+                            if (exitMessage)
+                                method(exitMessage(undefined, r));
+                            return r;
+                        })
+                            .catch((e) => {
+                            if (exitMessage)
+                                logger.error(exitMessage(e));
+                            throw e;
+                        });
+                    }
+                    if (exitMessage)
+                        method(exitMessage(undefined, result));
+                    return result;
+                }
+                catch (err) {
+                    if (exitMessage)
+                        logger.error(exitMessage(err));
+                    throw err;
+                }
+            },
+        });
+        return descriptor;
+    };
+}
+/**
+ * @description Method decorator that records execution time at the benchmark level.
+ * @summary Wraps the target method to emit {@link Logger.benchmark} entries capturing completion time or failure latency.
+ * @return {function(any, any,  PropertyDescriptor): void} Method decorator proxy that benchmarks the original implementation.
+ * @function benchmark
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant Decorator as benchmark
+ *   participant Method as Original Method
+ *   Caller->>Decorator: invoke()
+ *   Decorator->>Method: Reflect.apply(...)
+ *   alt Promise result
+ *     Method-->>Decorator: Promise
+ *     Decorator->>Decorator: attach then()
+ *     Decorator->>Decorator: log completion duration
+ *   else Synchronous result
+ *     Method-->>Decorator: value
+ *     Decorator->>Decorator: log completion duration
+ *   end
+ *   Decorator-->>Caller: return result
+ * @category Method Decorators
+ */
+function benchmark() {
+    return function benchmark(target, propertyKey, descriptor) {
+        if (!descriptor || typeof descriptor === "number")
+            throw new Error(`benchmark decoration only applies to methods`);
+        const logger = target instanceof LoggedClass_1.LoggedClass
+            ? target["log"].for(target[propertyKey])
+            : logging_1.Logging.for(target).for(target[propertyKey]);
+        const originalMethod = descriptor.value;
+        descriptor.value = new Proxy(originalMethod, {
+            apply(fn, thisArg, args) {
+                const start = (0, time_1.now)();
                 try {
                     const result = Reflect.apply(fn, thisArg, args);
                     if (result instanceof Promise) {
                         return result.then((r) => {
-                            if (benchmark)
-                                method(`completed in ${Date.now() - start}ms`, verbosity);
+                            logger.benchmark(`completed in ${(0, time_1.now)() - start}ms`);
                             return r;
                         });
                     }
-                    if (benchmark)
-                        method(`completed in ${Date.now() - start}ms`, verbosity);
+                    logger.benchmark(`completed in ${(0, time_1.now)() - start}ms`);
                     return result;
                 }
                 catch (err) {
-                    if (benchmark)
-                        method(`failed in ${Date.now() - start}ms`, verbosity);
+                    logger.benchmark(`failed in ${(0, time_1.now)() - start}ms`);
                     throw err;
                 }
             },
         });
+        return descriptor;
     };
 }
 /**
- * @description Method decorator for logging function calls with debug level
- * @summary Convenience wrapper around the log decorator that uses LogLevel.debug
- * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
- * @return {Function} A method decorator that wraps the original method with debug logging
+ * @description Method decorator for logging function calls with debug level.
+ * @summary Convenience wrapper around {@link log} that logs using `LogLevel.debug`.
+ * @return {function(any, any, PropertyDescriptor): void} Debug-level logging decorator.
  * @function debug
  * @category Method Decorators
  */
-function debug(benchmark = false) {
-    return log(constants_1.LogLevel.debug, benchmark);
+function debug() {
+    return log(constants_1.LogLevel.debug, 0, (...args) => `called with ${args}`, (e, result) => e
+        ? `Failed with: ${e}`
+        : result
+            ? `Completed with ${JSON.stringify(result)}`
+            : "completed");
 }
 /**
- * @description Method decorator for logging function calls with info level
- * @summary Convenience wrapper around the log decorator that uses LogLevel.info
- * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
- * @return {Function} A method decorator that wraps the original method with info logging
+ * @description Method decorator for logging function calls with info level.
+ * @summary Convenience wrapper around {@link log} that logs using `LogLevel.info`.
+ * @return {function(any, any, PropertyDescriptor): void} Info-level logging decorator.
  * @function info
  * @category Method Decorators
  */
-function info(benchmark = false) {
-    return log(constants_1.LogLevel.info, benchmark);
+function info() {
+    return log(constants_1.LogLevel.info);
 }
 /**
- * @description Method decorator for logging function calls with silly level
- * @summary Convenience wrapper around the log decorator that uses LogLevel.silly
- * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
- * @return {Function} A method decorator that wraps the original method with silly logging
+ * @description Method decorator for logging function calls with silly level.
+ * @summary Convenience wrapper around {@link log} that logs using `LogLevel.silly`.
+ * @return {function(any, any, PropertyDescriptor): void} Silly-level logging decorator.
  * @function silly
  * @category Method Decorators
  */
-function silly(benchmark = false) {
-    return log(constants_1.LogLevel.silly, benchmark);
+function silly() {
+    return log(constants_1.LogLevel.silly);
 }
 /**
- * @description Method decorator for logging function calls with verbose level
- * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity
- * @param {number} verbosity - The verbosity level for the log messages (default: 0)
- * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
- * @return {Function} A method decorator that wraps the original method with verbose logging
+ * @description Method decorator for logging function calls with verbose level.
+ * @summary Convenience wrapper around {@link log} that logs using `LogLevel.verbose` with configurable verbosity and optional benchmarking.
+ * @param {number|boolean} verbosity - Verbosity level for log filtering or flag to enable benchmarking.
+ * @return {function(any, any,PropertyDescriptor): void} Verbose logging decorator.
  * @function verbose
  * @category Method Decorators
  */
-function verbose(verbosity = 0, benchmark) {
-    if (typeof verbosity === "boolean") {
-        benchmark = verbosity;
+function verbose(verbosity = 0) {
+    if (!verbosity) {
         verbosity = 0;
     }
-    return log(constants_1.LogLevel.verbose, benchmark, verbosity);
+    return log(constants_1.LogLevel.verbose, verbosity);
 }
 /**
- * @description Creates a decorator that makes a method non-configurable
- * @summary This decorator prevents a method from being overridden by making it non-configurable.
- * It throws an error if used on anything other than a method.
- * @return {Function} A decorator function that can be applied to methods
+ * @description Creates a decorator that makes a method non-configurable.
+ * @summary Prevents overriding by marking the method descriptor as non-configurable, throwing if applied to non-method targets.
+ * @return {function(object, any, PropertyDescriptor): PropertyDescriptor|undefined} Decorator that hardens the method descriptor.
  * @function final
  * @category Method Decorators
  */
@@ -139,4 +203,4 @@ function final() {
         return descriptor;
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { LogLevel } from \"./constants\";\nimport { Logging } from \"./logging\";\n\n/**\n * @description Method decorator for logging function calls\n * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity\n * @param {LogLevel} level - The log level to use (default: LogLevel.info)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @param {number} [verbosity=0] - The verbosity level for the log messages (default: 0)\n * @return {Function} A method decorator that wraps the original method with logging\n * @function log\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator as log decorator\n *   participant Method as Original Method\n *   participant Logger as Logging instance\n *\n *   Client->>Decorator: call decorated method\n *   Decorator->>Logger: log method call\n *   Decorator->>Method: call original method\n *   alt result is Promise\n *     Method-->>Decorator: return Promise\n *     Decorator->>Decorator: attach then handler\n *     Note over Decorator: Promise resolves\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   else result is not Promise\n *     Method-->>Decorator: return result\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   end\n * @category Method Decorators\n */\nexport function log(\n  level: LogLevel = LogLevel.info,\n  benchmark: boolean = false,\n  verbosity = 0\n) {\n  return function (\n    target: any,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) {\n    if (!descriptor)\n      throw new Error(`Logging decoration only applies to methods`);\n    const logger = Logging.for(target).for(target[propertyKey]);\n    const method = logger[level].bind(logger) as any;\n    const originalMethod = descriptor.value;\n\n    descriptor.value = new Proxy(originalMethod, {\n      apply(fn, thisArg, args: any[]) {\n        method(`called with ${args}`, verbosity);\n        const start = Date.now();\n        try {\n          const result = Reflect.apply(fn, thisArg, args);\n          if (result instanceof Promise) {\n            return result.then((r: any) => {\n              if (benchmark)\n                method(`completed in ${Date.now() - start}ms`, verbosity);\n              return r;\n            });\n          }\n          if (benchmark)\n            method(`completed in ${Date.now() - start}ms`, verbosity);\n          return result;\n        } catch (err) {\n          if (benchmark) method(`failed in ${Date.now() - start}ms`, verbosity);\n          throw err;\n        }\n      },\n    });\n  };\n}\n\n/**\n * @description Method decorator for logging function calls with debug level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.debug\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with debug logging\n * @function debug\n * @category Method Decorators\n */\nexport function debug(benchmark: boolean = false) {\n  return log(LogLevel.debug, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with info level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.info\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with info logging\n * @function info\n * @category Method Decorators\n */\nexport function info(benchmark: boolean = false) {\n  return log(LogLevel.info, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with silly level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.silly\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with silly logging\n * @function silly\n * @category Method Decorators\n */\nexport function silly(benchmark: boolean = false) {\n  return log(LogLevel.silly, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(): (\n  target: any,\n  propertyKey?: any,\n  descriptor?: any\n) => void;\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {boolean} benchmark - Whether to log execution time\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(\n  benchmark: boolean\n): (target: any, propertyKey?: any, descriptor?: any) => void;\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {number} verbosity - The verbosity level for the log messages (default: 0)\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(\n  verbosity: number | boolean\n): (target: any, propertyKey?: any, descriptor?: any) => void;\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {number} verbosity - The verbosity level for the log messages (default: 0)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(verbosity: number | boolean = 0, benchmark?: boolean) {\n  if (typeof verbosity === \"boolean\") {\n    benchmark = verbosity;\n    verbosity = 0;\n  }\n  return log(LogLevel.verbose, benchmark, verbosity);\n}\n\n/**\n * @description Creates a decorator that makes a method non-configurable\n * @summary This decorator prevents a method from being overridden by making it non-configurable.\n * It throws an error if used on anything other than a method.\n * @return {Function} A decorator function that can be applied to methods\n * @function final\n * @category Method Decorators\n */\nexport function final() {\n  return (\n    target: object,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) => {\n    if (!descriptor)\n      throw new Error(\"final decorator can only be used on methods\");\n    if (descriptor?.configurable) {\n      descriptor.configurable = false;\n    }\n    return descriptor;\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { LogLevel } from \"./constants\";\nimport { Logging } from \"./logging\";\nimport { now } from \"./time\";\nimport { LoggedClass } from \"./LoggedClass\";\nimport { Logger } from \"./types\";\n\nexport type ArgFormatFunction = (...args: any[]) => string;\nexport type ReturnFormatFunction = (e?: Error, result?: any) => string;\n\n/**\n * @description Method decorator for logging function calls.\n * @summary Wraps class methods to automatically log entry, exit, timing, and optional custom messages at a configurable {@link LogLevel}.\n * @param {LogLevel} level - Log level applied to the generated log statements (defaults to `LogLevel.info`).\n * @param {number} [verbosity=0] - Verbosity threshold required for the entry log to appear.\n * @param {ArgFormatFunction} [entryMessage] - Formatter invoked with the original method arguments to describe the invocation.\n * @param {ReturnFormatFunction} [exitMessage] - Optional formatter that describes the outcome or failure of the call.\n * @return {function(any, any, PropertyDescriptor): void} Method decorator proxy that injects logging behavior.\n * @function log\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator as log decorator\n *   participant Method as Original Method\n *   participant Logger as Logging instance\n *\n *   Client->>Decorator: call decorated method\n *   Decorator->>Logger: log method call\n *   Decorator->>Method: call original method\n *   alt result is Promise\n *     Method-->>Decorator: return Promise\n *     Decorator->>Decorator: attach then handler\n *     Note over Decorator: Promise resolves\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   else result is not Promise\n *     Method-->>Decorator: return result\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   end\n * @category Method Decorators\n */\nexport function log(\n  level: LogLevel = LogLevel.info,\n  verbosity = 0,\n  entryMessage: ArgFormatFunction = (...args: any[]) => `called with ${args}`,\n  exitMessage?: ReturnFormatFunction\n) {\n  return function log(target: any, propertyKey?: any, descriptor?: any) {\n    if (!descriptor || typeof descriptor === \"number\")\n      throw new Error(`Logging decoration only applies to methods`);\n    const logger: Logger =\n      target instanceof LoggedClass\n        ? target[\"log\"].for(target[propertyKey as keyof typeof target])\n        : Logging.for(target).for(target[propertyKey]);\n    const method = logger[level].bind(logger) as any;\n    const originalMethod = descriptor.value;\n\n    descriptor.value = new Proxy(originalMethod, {\n      apply(fn, thisArg, args: any[]) {\n        method(entryMessage(...args), verbosity);\n        try {\n          const result = Reflect.apply(fn, thisArg, args);\n          if (result instanceof Promise) {\n            return result\n              .then((r: any) => {\n                if (exitMessage) method(exitMessage(undefined, r));\n                return r;\n              })\n              .catch((e) => {\n                if (exitMessage) logger.error(exitMessage(e as Error));\n                throw e;\n              });\n          }\n          if (exitMessage) method(exitMessage(undefined, result));\n          return result;\n        } catch (err: unknown) {\n          if (exitMessage) logger.error(exitMessage(err as Error));\n          throw err;\n        }\n      },\n    });\n    return descriptor;\n  };\n}\n\n/**\n * @description Method decorator that records execution time at the benchmark level.\n * @summary Wraps the target method to emit {@link Logger.benchmark} entries capturing completion time or failure latency.\n * @return {function(any, any,  PropertyDescriptor): void} Method decorator proxy that benchmarks the original implementation.\n * @function benchmark\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant Decorator as benchmark\n *   participant Method as Original Method\n *   Caller->>Decorator: invoke()\n *   Decorator->>Method: Reflect.apply(...)\n *   alt Promise result\n *     Method-->>Decorator: Promise\n *     Decorator->>Decorator: attach then()\n *     Decorator->>Decorator: log completion duration\n *   else Synchronous result\n *     Method-->>Decorator: value\n *     Decorator->>Decorator: log completion duration\n *   end\n *   Decorator-->>Caller: return result\n * @category Method Decorators\n */\nexport function benchmark() {\n  return function benchmark(target: any, propertyKey?: any, descriptor?: any) {\n    if (!descriptor || typeof descriptor === \"number\")\n      throw new Error(`benchmark decoration only applies to methods`);\n    const logger: Logger =\n      target instanceof LoggedClass\n        ? target[\"log\"].for(target[propertyKey as keyof typeof target])\n        : Logging.for(target).for(target[propertyKey]);\n    const originalMethod = descriptor.value;\n\n    descriptor.value = new Proxy(originalMethod, {\n      apply(fn, thisArg, args: any[]) {\n        const start = now();\n        try {\n          const result = Reflect.apply(fn, thisArg, args);\n          if (result instanceof Promise) {\n            return result.then((r: any) => {\n              logger.benchmark(`completed in ${now() - start}ms`);\n              return r;\n            });\n          }\n          logger.benchmark(`completed in ${now() - start}ms`);\n          return result;\n        } catch (err: unknown) {\n          logger.benchmark(`failed in ${now() - start}ms`);\n          throw err;\n        }\n      },\n    });\n\n    return descriptor;\n  };\n}\n\n/**\n * @description Method decorator for logging function calls with debug level.\n * @summary Convenience wrapper around {@link log} that logs using `LogLevel.debug`.\n * @return {function(any, any, PropertyDescriptor): void} Debug-level logging decorator.\n * @function debug\n * @category Method Decorators\n */\nexport function debug() {\n  return log(\n    LogLevel.debug,\n    0,\n    (...args: any[]) => `called with ${args}`,\n    (e?: Error, result?: any) =>\n      e\n        ? `Failed with: ${e}`\n        : result\n          ? `Completed with ${JSON.stringify(result)}`\n          : \"completed\"\n  );\n}\n\n/**\n * @description Method decorator for logging function calls with info level.\n * @summary Convenience wrapper around {@link log} that logs using `LogLevel.info`.\n * @return {function(any, any, PropertyDescriptor): void} Info-level logging decorator.\n * @function info\n * @category Method Decorators\n */\nexport function info() {\n  return log(LogLevel.info);\n}\n\n/**\n * @description Method decorator for logging function calls with silly level.\n * @summary Convenience wrapper around {@link log} that logs using `LogLevel.silly`.\n * @return {function(any, any, PropertyDescriptor): void} Silly-level logging decorator.\n * @function silly\n * @category Method Decorators\n */\nexport function silly() {\n  return log(LogLevel.silly);\n}\n\n/**\n * @description Method decorator for logging function calls with verbose level.\n * @summary Convenience wrapper around {@link log} that logs using `LogLevel.verbose` with configurable verbosity.\n * @return {function(any, any, PropertyDescriptor): void} Verbose logging decorator.\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(): (\n  target: any,\n  propertyKey?: any,\n  descriptor?: any\n) => void;\n\n/**\n * @description Method decorator for logging function calls with verbose level.\n * @summary Convenience wrapper around {@link log} that logs using `LogLevel.verbose` while toggling benchmarking.\n * @return {function(any, PropertyDescriptor): void} Verbose logging decorator.\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(): (\n  target: any,\n  propertyKey?: any,\n  descriptor?: any\n) => void;\n\n/**\n * @description Method decorator for logging function calls with verbose level.\n * @summary Convenience wrapper around {@link log} that logs using `LogLevel.verbose` with configurable verbosity and optional benchmarking.\n * @param {number|boolean} verbosity - Verbosity level for log filtering or flag to enable benchmarking.\n * @return {function(any, any,PropertyDescriptor): void} Verbose logging decorator.\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(verbosity: number | boolean = 0) {\n  if (!verbosity) {\n    verbosity = 0;\n  }\n  return log(LogLevel.verbose, verbosity as number);\n}\n\n/**\n * @description Creates a decorator that makes a method non-configurable.\n * @summary Prevents overriding by marking the method descriptor as non-configurable, throwing if applied to non-method targets.\n * @return {function(object, any, PropertyDescriptor): PropertyDescriptor|undefined} Decorator that hardens the method descriptor.\n * @function final\n * @category Method Decorators\n */\nexport function final() {\n  return (target: object, propertyKey?: any, descriptor?: any) => {\n    if (!descriptor)\n      throw new Error(\"final decorator can only be used on methods\");\n    if (descriptor?.configurable) {\n      descriptor.configurable = false;\n    }\n    return descriptor;\n  };\n}\n"]}