@decaf-ts/logging 0.3.11 → 0.3.13

package/lib/esm/decorators.js

@@ -1,12 +1,15 @@
 import { LogLevel } from "./constants.js";
 import { Logging } from "./logging.js";
+import { now } from "./time.js";
+import { LoggedClass } from "./LoggedClass.js";
 /**
- * @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
@@ -31,93 +34,153 @@ import { Logging } from "./logging.js";
  *   end
  * @category Method Decorators
  */
-export function log(level = LogLevel.info, benchmark = false, verbosity = 0) {
-    return function (target, propertyKey, descriptor) {
-        if (!descriptor)
+export function log(level = 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.for(target).for(target[propertyKey]);
+        const logger = target instanceof LoggedClass
+            ? target["log"].for(target[propertyKey])
+            : 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
+ */
+export 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
+            ? target["log"].for(target[propertyKey])
+            : Logging.for(target).for(target[propertyKey]);
+        const originalMethod = descriptor.value;
+        descriptor.value = new Proxy(originalMethod, {
+            apply(fn, thisArg, args) {
+                const start = 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 ${now() - start}ms`);
                             return r;
                         });
                     }
-                    if (benchmark)
-                        method(`completed in ${Date.now() - start}ms`, verbosity);
+                    logger.benchmark(`completed in ${now() - start}ms`);
                     return result;
                 }
                 catch (err) {
-                    if (benchmark)
-                        method(`failed in ${Date.now() - start}ms`, verbosity);
+                    logger.benchmark(`failed in ${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
  */
-export function debug(benchmark = false) {
-    return log(LogLevel.debug, benchmark);
+export function debug() {
+    return log(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
  */
-export function info(benchmark = false) {
-    return log(LogLevel.info, benchmark);
+export function info() {
+    return log(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
  */
-export function silly(benchmark = false) {
-    return log(LogLevel.silly, benchmark);
+export function silly() {
+    return log(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
  */
-export function verbose(verbosity = 0, benchmark) {
-    if (typeof verbosity === "boolean") {
-        benchmark = verbosity;
+export function verbose(verbosity = 0) {
+    if (!verbosity) {
         verbosity = 0;
     }
-    return log(LogLevel.verbose, benchmark, verbosity);
+    return log(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
  */
@@ -131,4 +194,4 @@ export 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"]}

package/lib/esm/environment.d.ts

@@ -1,21 +1,39 @@
 import { ObjectAccumulator } from "typed-object-accumulator";
 /**
  * @description Factory type for creating Environment instances.
- * @summary Defines a function type that creates and returns Environment instances.
- *
+ * @summary Describes factories that construct {@link Environment} derivatives with custom initialization.
  * @template T - The type of object the Environment will accumulate.
  * @template E - The specific Environment type to be created, extending Environment<T>.
- * @typedef {function(...unknown[]): E} EnvironmentFactory
+ * @typedef {function(unknown[]): E} EnvironmentFactory
  * @memberOf module:Logging
  */
 export type EnvironmentFactory<T extends object, E extends Environment<T>> = (...args: unknown[]) => E;
 /**
- * @class Environment
- * @extends {ObjectAccumulator<T>}
+ * @description Environment accumulator that lazily reads from runtime sources.
+ * @summary Extends {@link ObjectAccumulator} to merge configuration objects while resolving values from Node or browser environment variables on demand.
  * @template T
- * @description A class representing an environment with accumulation capabilities.
- * @summary Manages environment-related data and provides methods for accumulation and key retrieval.
- * @param {T} [initialData] - The initial data to populate the environment with.
+ * @class Environment
+ * @example
+ * const Config = Environment.accumulate({ logging: { level: "info" } });
+ * console.log(Config.logging.level);
+ * console.log(String(Config.logging.level)); // => LOGGING__LEVEL key when serialized
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Env as Environment
+ *   participant Process as process.env
+ *   participant Browser as globalThis.ENV
+ *   Client->>Env: accumulate(partialConfig)
+ *   Env->>Env: expand(values)
+ *   Client->>Env: Config.logging.level
+ *   alt Browser runtime
+ *     Env->>Browser: lookup ENV key
+ *     Browser-->>Env: resolved value
+ *   else Node runtime
+ *     Env->>Process: lookup ENV key
+ *     Process-->>Env: resolved value
+ *   end
+ *   Env-->>Client: merged value
  */
 export declare class Environment<T extends object> extends ObjectAccumulator<T> {
     /**
@@ -35,17 +53,24 @@ export declare class Environment<T extends object> extends ObjectAccumulator<T>
     private static _instance;
     protected constructor();
     /**
-     * @description Retrieves a value from the environment
-     * @summary Gets a value from the environment variables, handling browser and Node.js environments differently
-     * @param {string} k - The key to retrieve from the environment
-     * @return {unknown} The value from the environment, or undefined if not found
+     * @description Retrieves a value from the runtime environment.
+     * @summary Handles browser and Node.js environments by normalizing keys and parsing values.
+     * @param {string} k - Key to resolve from the environment.
+     * @return {unknown} Value resolved from the environment or `undefined` when absent.
      */
     protected fromEnv(k: string): unknown;
     /**
-     * @description Expands an object into the environment
-     * @summary Defines properties on the environment object that can be accessed as getters and setters
-     * @template V - Type of the object being expanded
-     * @param {V} value - The object to expand into the environment
+     * @description Converts stringified environment values into native types.
+     * @summary Interprets booleans and numbers while leaving other types unchanged.
+     * @param {unknown} val - Raw value retrieved from the environment.
+     * @return {unknown} Parsed value converted to boolean, number, or left as-is.
+     */
+    protected parseEnvValue(val: unknown): unknown;
+    /**
+     * @description Expands an object into the environment.
+     * @summary Defines lazy properties that first consult runtime variables before falling back to seeded values.
+     * @template V - Type of the object being expanded.
+     * @param {V} value - Object to expose through environment getters and setters.
      * @return {void}
      */
     protected expand<V extends object>(value: V): void;
@@ -53,22 +78,36 @@ export declare class Environment<T extends object> extends ObjectAccumulator<T>
      * @protected
      * @static
      * @description Retrieves or creates the singleton instance of the Environment class.
-     * @summary Ensures only one instance of the Environment class exists.
+     * @summary Ensures only one {@link Environment} instance is created, wrapping it in a proxy to compose ENV keys on demand.
      * @template E
-     * @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.
-     * @return {E} The singleton instance of the Environment class.
+     * @param {...unknown[]} args - Arguments forwarded to the factory when instantiating the singleton.
+     * @return {E} Singleton environment instance.
      */
     protected static instance<E extends Environment<any>>(...args: unknown[]): E;
     /**
      * @static
      * @description Accumulates the given value into the environment.
-     * @summary Adds new properties to the environment from the provided object.
+     * @summary Adds new properties, hiding raw descriptors to avoid leaking enumeration semantics.
+     * @template T
      * @template V
-     * @param {V} value - The object to accumulate into the environment.
-     * @return {V} The updated environment instance.
+     * @param {V} value - Object to merge into the environment.
+     * @return {Environment} Updated environment reference.
      */
     static accumulate<V extends object>(value: V): typeof Environment._instance & V & ObjectAccumulator<typeof Environment._instance & V>;
+    /**
+     * @description Retrieves a value using a dot-path key from the accumulated environment.
+     * @summary Delegates to the singleton instance to access stored configuration.
+     * @param {string} key - Key to resolve from the environment store.
+     * @return {unknown} Stored value corresponding to the provided key.
+     */
     static get(key: string): any;
+    /**
+     * @description Builds a proxy that composes environment keys for nested properties.
+     * @summary Allows chained property access to emit uppercase ENV identifiers while honoring existing runtime overrides.
+     * @param {any} current - Seed model segment used when projecting nested structures.
+     * @param {string[]} path - Accumulated path segments leading to the proxy.
+     * @return {any} Proxy that resolves environment values or composes additional proxies for deeper paths.
+     */
     private static buildEnvProxy;
     /**
      * @static
@@ -79,6 +118,12 @@ export declare class Environment<T extends object> extends ObjectAccumulator<T>
      */
     static keys(toEnv?: boolean): string[];
 }
+/**
+ * @description Singleton environment instance seeded with default logging configuration.
+ * @summary Combines {@link DefaultLoggingConfig} with runtime environment variables to provide consistent logging defaults across platforms.
+ * @const LoggedEnvironment
+ * @memberOf module:Logging
+ */
 export declare const LoggedEnvironment: Environment<any> & import("./types").LoggingConfig & {
     env: any;
 } & ObjectAccumulator<Environment<any> & import("./types").LoggingConfig & {