@decaf-ts/logging 0.3.11 → 0.3.13

package/lib/decorators.d.ts

@@ -1,11 +1,14 @@
 import { LogLevel } from "./constants";
+export type ArgFormatFunction = (...args: any[]) => string;
+export type ReturnFormatFunction = (e?: Error, result?: any) => string;
 /**
- * @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
@@ -30,64 +33,76 @@ import { LogLevel } from "./constants";
  *   end
  * @category Method Decorators
  */
-export declare function log(level?: LogLevel, benchmark?: boolean, verbosity?: number): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
+export declare function log(level?: LogLevel, verbosity?: number, entryMessage?: ArgFormatFunction, exitMessage?: ReturnFormatFunction): (target: any, propertyKey?: any, descriptor?: any) => any;
 /**
- * @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 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 declare function benchmark(): (target: any, propertyKey?: any, descriptor?: any) => any;
+/**
+ * @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 declare function debug(benchmark?: boolean): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
+export declare function debug(): (target: any, propertyKey?: any, descriptor?: any) => any;
 /**
- * @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 declare function info(benchmark?: boolean): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
+export declare function info(): (target: any, propertyKey?: any, descriptor?: any) => any;
 /**
- * @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 declare function silly(benchmark?: boolean): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
+export declare function silly(): (target: any, propertyKey?: any, descriptor?: any) => any;
 /**
- * @description Method decorator for logging function calls with verbose level
- * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity
- * @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.
+ * @return {function(any, any, PropertyDescriptor): void} Verbose logging decorator.
  * @function verbose
+ * @category Method Decorators
  */
 export declare function verbose(): (target: any, propertyKey?: any, descriptor?: any) => void;
 /**
- * @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 {boolean} benchmark - Whether to log execution time
- * @return {Function} A method decorator that wraps the original method with verbose logging
- * @function verbose
- */
-export declare function verbose(benchmark: boolean): (target: any, propertyKey?: any, descriptor?: any) => void;
-/**
- * @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)
- * @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` while toggling benchmarking.
+ * @return {function(any, PropertyDescriptor): void} Verbose logging decorator.
  * @function verbose
  * @category Method Decorators
  */
-export declare function verbose(verbosity: number | boolean): (target: any, propertyKey?: any, descriptor?: any) => void;
+export declare function verbose(): (target: any, propertyKey?: any, descriptor?: any) => void;
 /**
- * @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
  */
-export declare function final(): (target: object, propertyKey?: any, descriptor?: PropertyDescriptor) => PropertyDescriptor;
+export declare function final(): (target: object, propertyKey?: any, descriptor?: any) => any;

package/lib/environment.cjs

@@ -6,12 +6,31 @@ const text_1 = require("./text.cjs");
 const web_1 = require("./web.cjs");
 const constants_1 = require("./constants.cjs");
 /**
- * @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
  */
 class Environment extends typed_object_accumulator_1.ObjectAccumulator {
     /**
@@ -26,10 +45,10 @@ class Environment extends typed_object_accumulator_1.ObjectAccumulator {
         super();
     }
     /**
-     * @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.
      */
     fromEnv(k) {
         let env;
@@ -41,13 +60,31 @@ class Environment extends typed_object_accumulator_1.ObjectAccumulator {
             env = globalThis.process.env;
             k = (0, text_1.toENVFormat)(k);
         }
-        return env[k];
+        return this.parseEnvValue(env[k]);
+    }
+    /**
+     * @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.
+     */
+    parseEnvValue(val) {
+        if (typeof val !== "string")
+            return val;
+        if (val === "true")
+            return true;
+        if (val === "false")
+            return false;
+        const result = parseFloat(val);
+        if (!isNaN(result))
+            return result;
+        return val;
     }
     /**
-     * @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 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}
      */
     expand(value) {
@@ -78,10 +115,10 @@ class Environment extends typed_object_accumulator_1.ObjectAccumulator {
      * @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.
      */
     static instance(...args) {
         if (!Environment._instance) {
@@ -107,10 +144,11 @@ class Environment extends typed_object_accumulator_1.ObjectAccumulator {
     /**
      * @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(value) {
         const instance = Environment.instance();
@@ -125,9 +163,22 @@ class Environment extends typed_object_accumulator_1.ObjectAccumulator {
         });
         return instance.accumulate(value);
     }
+    /**
+     * @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) {
         return Environment._instance.get(key);
     }
+    /**
+     * @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.
+     */
     static buildEnvProxy(current, path) {
         const buildKey = (p) => p.map((seg) => (0, text_1.toENVFormat)(seg)).join(constants_1.ENV_PATH_DELIMITER);
         // Helper to read from the active environment given a composed key
@@ -197,9 +248,15 @@ class Environment extends typed_object_accumulator_1.ObjectAccumulator {
     }
 }
 exports.Environment = Environment;
+/**
+ * @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
+ */
 exports.LoggedEnvironment = Environment.accumulate(Object.assign({}, constants_1.DefaultLoggingConfig, {
     env: ((0, web_1.isBrowser)() && globalThis[constants_1.BrowserEnvKey]
         ? globalThis[constants_1.BrowserEnvKey]["NODE_ENV"]
         : globalThis.process.env["NODE_ENV"]) || "development",
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"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","sourcesContent":["import { ObjectAccumulator } from \"typed-object-accumulator\";\nimport { toENVFormat } from \"./text\";\nimport { isBrowser } from \"./web\";\nimport {\n  BrowserEnvKey,\n  DefaultLoggingConfig,\n  ENV_PATH_DELIMITER,\n} from \"./constants\";\n\n/**\n * @description Factory type for creating Environment instances.\n * @summary Defines a function type that creates and returns Environment instances.\n *\n * @template T - The type of object the Environment will accumulate.\n * @template E - The specific Environment type to be created, extending Environment<T>.\n * @typedef {function(...unknown[]): E} EnvironmentFactory\n * @memberOf module:Logging\n */\nexport type EnvironmentFactory<T extends object, E extends Environment<T>> = (\n  ...args: unknown[]\n) => E;\n\n/**\n * @class Environment\n * @extends {ObjectAccumulator<T>}\n * @template T\n * @description A class representing an environment with accumulation capabilities.\n * @summary Manages environment-related data and provides methods for accumulation and key retrieval.\n * @param {T} [initialData] - The initial data to populate the environment with.\n */\nexport class Environment<T extends object> extends ObjectAccumulator<T> {\n  /**\n   * @static\n   * @protected\n   * @description A factory function for creating Environment instances.\n   * @summary Defines how new instances of the Environment class should be created.\n   * @return {Environment<any>} A new instance of the Environment class.\n   */\n  protected static factory: EnvironmentFactory<any, any> =\n    (): Environment<any> => new Environment();\n\n  /**\n   * @static\n   * @private\n   * @description The singleton instance of the Environment class.\n   * @type {Environment<any>}\n   */\n  private static _instance: Environment<any>;\n\n  protected constructor() {\n    super();\n  }\n\n  /**\n   * @description Retrieves a value from the environment\n   * @summary Gets a value from the environment variables, handling browser and Node.js environments differently\n   * @param {string} k - The key to retrieve from the environment\n   * @return {unknown} The value from the environment, or undefined if not found\n   */\n  protected fromEnv(k: string) {\n    let env: Record<string, unknown>;\n    if (isBrowser()) {\n      env =\n        (\n          globalThis as typeof globalThis & {\n            [BrowserEnvKey]: Record<string, any>;\n          }\n        )[BrowserEnvKey] || {};\n    } else {\n      env = globalThis.process.env;\n      k = toENVFormat(k);\n    }\n    return env[k];\n  }\n\n  /**\n   * @description Expands an object into the environment\n   * @summary Defines properties on the environment object that can be accessed as getters and setters\n   * @template V - Type of the object being expanded\n   * @param {V} value - The object to expand into the environment\n   * @return {void}\n   */\n  protected override expand<V extends object>(value: V): void {\n    Object.entries(value).forEach(([k, v]) => {\n      Object.defineProperty(this, k, {\n        get: () => {\n          const fromEnv = this.fromEnv(k);\n          if (typeof fromEnv !== \"undefined\") return fromEnv;\n          if (v && typeof v === \"object\") {\n            return Environment.buildEnvProxy(v as any, [k]);\n          }\n          // If the model provides an empty string, expose a proxy that composes ENV keys\n          if (v === \"\") {\n            return Environment.buildEnvProxy(undefined, [k]);\n          }\n          return v;\n        },\n        set: (val: V[keyof V]) => {\n          v = val;\n        },\n        configurable: true,\n        enumerable: true,\n      });\n    });\n  }\n\n  /**\n   * @protected\n   * @static\n   * @description Retrieves or creates the singleton instance of the Environment class.\n   * @summary Ensures only one instance of the Environment class exists.\n   * @template E\n   * @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.\n   * @return {E} The singleton instance of the Environment class.\n   */\n  protected static instance<E extends Environment<any>>(...args: unknown[]): E {\n    if (!Environment._instance) {\n      const base = Environment.factory(...args) as E;\n      const proxied = new Proxy(base as any, {\n        get(target, prop, receiver) {\n          const value = Reflect.get(target, prop, receiver);\n          if (typeof value !== \"undefined\") return value;\n          if (typeof prop === \"string\") {\n            // Avoid interfering with logging config lookups for optional fields like 'app'\n            if (prop === \"app\") return undefined;\n            return Environment.buildEnvProxy(undefined, [prop]);\n          }\n          return value;\n        },\n      });\n      Environment._instance = proxied as any;\n    }\n    return Environment._instance as E;\n  }\n\n  /**\n   * @static\n   * @description Accumulates the given value into the environment.\n   * @summary Adds new properties to the environment from the provided object.\n   * @template V\n   * @param {V} value - The object to accumulate into the environment.\n   * @return {V} The updated environment instance.\n   */\n  static accumulate<V extends object>(\n    value: V\n  ): typeof Environment._instance &\n    V &\n    ObjectAccumulator<typeof Environment._instance & V> {\n    const instance = Environment.instance();\n    Object.keys(instance as any).forEach((key) => {\n      const desc = Object.getOwnPropertyDescriptor(instance as any, key);\n      if (desc && desc.configurable && desc.enumerable) {\n        Object.defineProperty(instance as any, key, {\n          ...desc,\n          enumerable: false,\n        });\n      }\n    });\n    return instance.accumulate(value);\n  }\n\n  static get(key: string) {\n    return Environment._instance.get(key);\n  }\n\n  private static buildEnvProxy(current: any, path: string[]): any {\n    const buildKey = (p: string[]) =>\n      p.map((seg) => toENVFormat(seg)).join(ENV_PATH_DELIMITER);\n\n    // Helper to read from the active environment given a composed key\n    const readEnv = (key: string): unknown => {\n      if (isBrowser()) {\n        const env = (\n          globalThis as typeof globalThis & {\n            [BrowserEnvKey]?: Record<string, unknown>;\n          }\n        )[BrowserEnvKey];\n        return env ? env[key] : undefined;\n      }\n      return (globalThis as any)?.process?.env?.[key];\n    };\n\n    const handler: ProxyHandler<any> = {\n      get(_target, prop: string | symbol) {\n        if (prop === Symbol.toPrimitive) {\n          return () => buildKey(path);\n        }\n        if (prop === \"toString\") {\n          return () => buildKey(path);\n        }\n        if (prop === \"valueOf\") {\n          return () => buildKey(path);\n        }\n        if (typeof prop === \"symbol\") return undefined;\n\n        const nextModel =\n          current && Object.prototype.hasOwnProperty.call(current, prop)\n            ? (current as any)[prop]\n            : undefined;\n        const nextPath = [...path, prop];\n        const composedKey = buildKey(nextPath);\n\n        // If an ENV value exists for this path, return it directly\n        const envValue = readEnv(composedKey);\n        if (typeof envValue !== \"undefined\") return envValue;\n\n        // Otherwise, if the model has an object at this path, keep drilling with a proxy\n        const isNextObject = nextModel && typeof nextModel === \"object\";\n        if (isNextObject) return Environment.buildEnvProxy(nextModel, nextPath);\n\n        // Always return a proxy for further path composition when no ENV value;\n        // do not surface primitive model defaults here (this API is for key composition).\n        return Environment.buildEnvProxy(undefined, nextPath);\n      },\n      ownKeys() {\n        return current ? Reflect.ownKeys(current) : [];\n      },\n      getOwnPropertyDescriptor(_t, p) {\n        if (!current) return undefined as any;\n        if (Object.prototype.hasOwnProperty.call(current, p)) {\n          return { enumerable: true, configurable: true } as PropertyDescriptor;\n        }\n        return undefined as any;\n      },\n    };\n\n    const target = {} as any;\n    return new Proxy(target, handler);\n  }\n\n  /**\n   * @static\n   * @description Retrieves the keys of the environment, optionally converting them to ENV format.\n   * @summary Gets all keys in the environment, with an option to format them for environment variables.\n   * @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.\n   * @return {string[]} An array of keys from the environment.\n   */\n  static keys(toEnv: boolean = true): string[] {\n    return Environment.instance()\n      .keys()\n      .map((k) => (toEnv ? toENVFormat(k) : k));\n  }\n}\n\nexport const LoggedEnvironment = Environment.accumulate(\n  Object.assign({}, DefaultLoggingConfig, {\n    env:\n      (isBrowser() && (globalThis as any)[BrowserEnvKey]\n        ? (globalThis as any)[BrowserEnvKey][\"NODE_ENV\"]\n        : (globalThis as any).process.env[\"NODE_ENV\"]) || \"development\",\n  })\n);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"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","sourcesContent":["import { ObjectAccumulator } from \"typed-object-accumulator\";\nimport { toENVFormat } from \"./text\";\nimport { isBrowser } from \"./web\";\nimport {\n  BrowserEnvKey,\n  DefaultLoggingConfig,\n  ENV_PATH_DELIMITER,\n} from \"./constants\";\n\n/**\n * @description Factory type for creating Environment instances.\n * @summary Describes factories that construct {@link Environment} derivatives with custom initialization.\n * @template T - The type of object the Environment will accumulate.\n * @template E - The specific Environment type to be created, extending Environment<T>.\n * @typedef {function(unknown[]): E} EnvironmentFactory\n * @memberOf module:Logging\n */\nexport type EnvironmentFactory<T extends object, E extends Environment<T>> = (\n  ...args: unknown[]\n) => E;\n\n/**\n * @description Environment accumulator that lazily reads from runtime sources.\n * @summary Extends {@link ObjectAccumulator} to merge configuration objects while resolving values from Node or browser environment variables on demand.\n * @template T\n * @class Environment\n * @example\n * const Config = Environment.accumulate({ logging: { level: \"info\" } });\n * console.log(Config.logging.level);\n * console.log(String(Config.logging.level)); // => LOGGING__LEVEL key when serialized\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Env as Environment\n *   participant Process as process.env\n *   participant Browser as globalThis.ENV\n *   Client->>Env: accumulate(partialConfig)\n *   Env->>Env: expand(values)\n *   Client->>Env: Config.logging.level\n *   alt Browser runtime\n *     Env->>Browser: lookup ENV key\n *     Browser-->>Env: resolved value\n *   else Node runtime\n *     Env->>Process: lookup ENV key\n *     Process-->>Env: resolved value\n *   end\n *   Env-->>Client: merged value\n */\nexport class Environment<T extends object> extends ObjectAccumulator<T> {\n  /**\n   * @static\n   * @protected\n   * @description A factory function for creating Environment instances.\n   * @summary Defines how new instances of the Environment class should be created.\n   * @return {Environment<any>} A new instance of the Environment class.\n   */\n  protected static factory: EnvironmentFactory<any, any> =\n    (): Environment<any> => new Environment();\n\n  /**\n   * @static\n   * @private\n   * @description The singleton instance of the Environment class.\n   * @type {Environment<any>}\n   */\n  private static _instance: Environment<any>;\n\n  protected constructor() {\n    super();\n  }\n\n  /**\n   * @description Retrieves a value from the runtime environment.\n   * @summary Handles browser and Node.js environments by normalizing keys and parsing values.\n   * @param {string} k - Key to resolve from the environment.\n   * @return {unknown} Value resolved from the environment or `undefined` when absent.\n   */\n  protected fromEnv(k: string) {\n    let env: Record<string, unknown>;\n    if (isBrowser()) {\n      env =\n        (\n          globalThis as typeof globalThis & {\n            [BrowserEnvKey]: Record<string, any>;\n          }\n        )[BrowserEnvKey] || {};\n    } else {\n      env = globalThis.process.env;\n      k = toENVFormat(k);\n    }\n    return this.parseEnvValue(env[k]);\n  }\n\n  /**\n   * @description Converts stringified environment values into native types.\n   * @summary Interprets booleans and numbers while leaving other types unchanged.\n   * @param {unknown} val - Raw value retrieved from the environment.\n   * @return {unknown} Parsed value converted to boolean, number, or left as-is.\n   */\n  protected parseEnvValue(val: unknown) {\n    if (typeof val !== \"string\") return val;\n    if (val === \"true\") return true;\n    if (val === \"false\") return false;\n    const result = parseFloat(val);\n    if (!isNaN(result)) return result;\n    return val;\n  }\n\n  /**\n   * @description Expands an object into the environment.\n   * @summary Defines lazy properties that first consult runtime variables before falling back to seeded values.\n   * @template V - Type of the object being expanded.\n   * @param {V} value - Object to expose through environment getters and setters.\n   * @return {void}\n   */\n  protected override expand<V extends object>(value: V): void {\n    Object.entries(value).forEach(([k, v]) => {\n      Object.defineProperty(this, k, {\n        get: () => {\n          const fromEnv = this.fromEnv(k);\n          if (typeof fromEnv !== \"undefined\") return fromEnv;\n          if (v && typeof v === \"object\") {\n            return Environment.buildEnvProxy(v as any, [k]);\n          }\n          // If the model provides an empty string, expose a proxy that composes ENV keys\n          if (v === \"\") {\n            return Environment.buildEnvProxy(undefined, [k]);\n          }\n          return v;\n        },\n        set: (val: V[keyof V]) => {\n          v = val;\n        },\n        configurable: true,\n        enumerable: true,\n      });\n    });\n  }\n\n  /**\n   * @protected\n   * @static\n   * @description Retrieves or creates the singleton instance of the Environment class.\n   * @summary Ensures only one {@link Environment} instance is created, wrapping it in a proxy to compose ENV keys on demand.\n   * @template E\n   * @param {...unknown[]} args - Arguments forwarded to the factory when instantiating the singleton.\n   * @return {E} Singleton environment instance.\n   */\n  protected static instance<E extends Environment<any>>(...args: unknown[]): E {\n    if (!Environment._instance) {\n      const base = Environment.factory(...args) as E;\n      const proxied = new Proxy(base as any, {\n        get(target, prop, receiver) {\n          const value = Reflect.get(target, prop, receiver);\n          if (typeof value !== \"undefined\") return value;\n          if (typeof prop === \"string\") {\n            // Avoid interfering with logging config lookups for optional fields like 'app'\n            if (prop === \"app\") return undefined;\n            return Environment.buildEnvProxy(undefined, [prop]);\n          }\n          return value;\n        },\n      });\n      Environment._instance = proxied as any;\n    }\n    return Environment._instance as E;\n  }\n\n  /**\n   * @static\n   * @description Accumulates the given value into the environment.\n   * @summary Adds new properties, hiding raw descriptors to avoid leaking enumeration semantics.\n   * @template T\n   * @template V\n   * @param {V} value - Object to merge into the environment.\n   * @return {Environment} Updated environment reference.\n   */\n  static accumulate<V extends object>(\n    value: V\n  ): typeof Environment._instance &\n    V &\n    ObjectAccumulator<typeof Environment._instance & V> {\n    const instance = Environment.instance();\n    Object.keys(instance as any).forEach((key) => {\n      const desc = Object.getOwnPropertyDescriptor(instance as any, key);\n      if (desc && desc.configurable && desc.enumerable) {\n        Object.defineProperty(instance as any, key, {\n          ...desc,\n          enumerable: false,\n        });\n      }\n    });\n    return instance.accumulate(value);\n  }\n\n  /**\n   * @description Retrieves a value using a dot-path key from the accumulated environment.\n   * @summary Delegates to the singleton instance to access stored configuration.\n   * @param {string} key - Key to resolve from the environment store.\n   * @return {unknown} Stored value corresponding to the provided key.\n   */\n  static get(key: string) {\n    return Environment._instance.get(key);\n  }\n\n  /**\n   * @description Builds a proxy that composes environment keys for nested properties.\n   * @summary Allows chained property access to emit uppercase ENV identifiers while honoring existing runtime overrides.\n   * @param {any} current - Seed model segment used when projecting nested structures.\n   * @param {string[]} path - Accumulated path segments leading to the proxy.\n   * @return {any} Proxy that resolves environment values or composes additional proxies for deeper paths.\n   */\n  private static buildEnvProxy(current: any, path: string[]): any {\n    const buildKey = (p: string[]) =>\n      p.map((seg) => toENVFormat(seg)).join(ENV_PATH_DELIMITER);\n\n    // Helper to read from the active environment given a composed key\n    const readEnv = (key: string): unknown => {\n      if (isBrowser()) {\n        const env = (\n          globalThis as typeof globalThis & {\n            [BrowserEnvKey]?: Record<string, unknown>;\n          }\n        )[BrowserEnvKey];\n        return env ? env[key] : undefined;\n      }\n      return (globalThis as any)?.process?.env?.[key];\n    };\n\n    const handler: ProxyHandler<any> = {\n      get(_target, prop: string | symbol) {\n        if (prop === Symbol.toPrimitive) {\n          return () => buildKey(path);\n        }\n        if (prop === \"toString\") {\n          return () => buildKey(path);\n        }\n        if (prop === \"valueOf\") {\n          return () => buildKey(path);\n        }\n        if (typeof prop === \"symbol\") return undefined;\n\n        const nextModel =\n          current && Object.prototype.hasOwnProperty.call(current, prop)\n            ? (current as any)[prop]\n            : undefined;\n        const nextPath = [...path, prop];\n        const composedKey = buildKey(nextPath);\n\n        // If an ENV value exists for this path, return it directly\n        const envValue = readEnv(composedKey);\n        if (typeof envValue !== \"undefined\") return envValue;\n\n        // Otherwise, if the model has an object at this path, keep drilling with a proxy\n        const isNextObject = nextModel && typeof nextModel === \"object\";\n        if (isNextObject) return Environment.buildEnvProxy(nextModel, nextPath);\n\n        // Always return a proxy for further path composition when no ENV value;\n        // do not surface primitive model defaults here (this API is for key composition).\n        return Environment.buildEnvProxy(undefined, nextPath);\n      },\n      ownKeys() {\n        return current ? Reflect.ownKeys(current) : [];\n      },\n      getOwnPropertyDescriptor(_t, p) {\n        if (!current) return undefined as any;\n        if (Object.prototype.hasOwnProperty.call(current, p)) {\n          return { enumerable: true, configurable: true } as PropertyDescriptor;\n        }\n        return undefined as any;\n      },\n    };\n\n    const target = {} as any;\n    return new Proxy(target, handler);\n  }\n\n  /**\n   * @static\n   * @description Retrieves the keys of the environment, optionally converting them to ENV format.\n   * @summary Gets all keys in the environment, with an option to format them for environment variables.\n   * @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.\n   * @return {string[]} An array of keys from the environment.\n   */\n  static keys(toEnv: boolean = true): string[] {\n    return Environment.instance()\n      .keys()\n      .map((k) => (toEnv ? toENVFormat(k) : k));\n  }\n}\n\n/**\n * @description Singleton environment instance seeded with default logging configuration.\n * @summary Combines {@link DefaultLoggingConfig} with runtime environment variables to provide consistent logging defaults across platforms.\n * @const LoggedEnvironment\n * @memberOf module:Logging\n */\nexport const LoggedEnvironment = Environment.accumulate(\n  Object.assign({}, DefaultLoggingConfig, {\n    env:\n      (isBrowser() && (globalThis as any)[BrowserEnvKey]\n        ? (globalThis as any)[BrowserEnvKey][\"NODE_ENV\"]\n        : (globalThis as any).process.env[\"NODE_ENV\"]) || \"development\",\n  })\n);\n"]}

package/lib/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 & {

package/lib/esm/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/esm/LoggedClass.js

@@ -1,11 +1,7 @@
 import { Logging } from "./logging.js";
 /**
- * @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 {
@@ -33,14 +29,15 @@ import { Logging } from "./logging.js";
  */
 export 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.for(this);
+        if (!this._log)
+            this._log = Logging.for(this);
+        return this._log;
     }
     constructor() { }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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