@mks2508/better-logger 0.18.2-alpha.1 → 0.18.3

package/dist/context/LogContext.d.ts

@@ -1,145 +1,242 @@
 /**
- * @fileoverview LogContext bridge — MDC (Mapped Diagnostic Context) management.
- * Encapsulates per-logger structured context, child logger creation, and
- * OTel resource merging.
+ * @fileoverview Bridge de LogContext — gestión de MDC (Mapped Diagnostic Context).
  *
- * F4 MDC API reset:
- * - `withContext(bindings, fn?)` — if fn provided, run within AsyncLocalStorage.
- *   Without fn: no-op (backwards compat shim for the old setter shape).
- * - `withContextAsync(bindings, fn)` — async callback variant.
- * - `child(bindings)` remains immutable (canonical MDC pattern).
- * - Feature-detect AsyncLocalStorage; browser fallback is a no-op.
+ * Encapsula el contexto estructurado por logger, la creación de child loggers y
+ * el merge de resource OTel en cada record emitido.
+ *
+ * Modelo de API:
+ * - `withContext(bindings, fn?)` — si se pasa `fn`, lo ejecuta dentro de un
+ *   scope de AsyncLocalStorage mergeando `bindings`. Sin `fn`: no-op (shim de
+ *   backwards compat para la vieja forma de setter).
+ * - `withContextAsync(bindings, fn)` — variante async callback.
+ * - `child(bindings)` — inmutable (patrón canónico de MDC).
+ * - Feature-detect de AsyncLocalStorage; en browser sin ALS es no-op.
  */
 import type { ILogResourceRef } from '../types/index.js';
 import type { LoggerConfig } from '../types/index.js';
+import { type AsyncLocalStorageLike } from '../utils/asyncLocalStorage.js';
 /**
- * Snapshot of the bound context. Returned by {@link LogContext.getContext}.
+ * Snapshot del contexto bound. Lo retorna {@link LogContext.getContext}.
+ *
+ * Es `Readonly` para marcar contractually que el objeto devuelto es una shallow
+ * copy: mutarlo no afecta a los records que emitan futuras llamadas de log.
  */
 export type ContextSnapshot = Readonly<Record<string, unknown>>;
 /**
- * Factory function type for creating child Logger instances.
- * Passed to LogContext so `child()` can instantiate new loggers without
- * introducing a circular import. Returns unknown — the actual Logger class
- * is used by the caller and the returned instance has its `context` field
- * written to by LogContext.
+ * Tipo de la factory function para crear instancias child de Logger.
+ *
+ * Se inyecta en LogContext para que `child()` pueda instanciar nuevos loggers
+ * sin introducir un import circular entre `Logger.ts` y `LogContext.ts`.
+ * Retorna `unknown` — la clase Logger concreta la maneja el caller, y la
+ * instancia devuelta tiene su campo `context` escrito por LogContext tras la
+ * creación.
  */
 export type ChildLoggerFactory = (config: Partial<LoggerConfig>) => unknown;
 /**
- * Minimal shape of a Logger instance needed by LogContext.
- * Used to avoid circular dependencies between LogContext and Logger.
- * The `_parentContextRecord` field is set by the parent Logger after
- * `LogContext.child()` returns, establishing the context chain.
+ * Shape mínima de una instancia de Logger que LogContext necesita ver.
+ *
+ * Evita dependencias circulares entre LogContext y Logger. El campo
+ * `_parentContextRecord` lo setea el Logger padre después de que
+ * `LogContext.child()` retorna, estableciendo la cadena de contextos.
  */
 export interface ChildLoggerShape {
     _parentContextRecord?: Record<string, unknown>;
-    /** Legacy field — no longer the canonical context source (F4.5.5 fix). */
+    /** Campo legacy — ya no es la fuente canónica del contexto. */
     context?: Record<string, unknown>;
 }
 /**
- * Options passed to {@link createLogContext}.
+ * Options que se pasan a {@link createLogContext}.
  */
 export interface ILogContextOptions {
-    /** Initial context key-value pairs. */
+    /** Pares key-value iniciales del contexto. */
     initialContext?: Record<string, unknown>;
-    /** Factory for creating child logger instances. */
+    /** Factory para crear instancias child de logger. */
     childLoggerFactory: ChildLoggerFactory;
-    /** Initial OTel resource to merge into every record. */
+    /** Resource OTel inicial a mergear en cada record emitido. */
     initialResource?: Partial<ILogResourceRef>;
     /**
-     * Returns the parent logger's merged context record at child-creation time.
-     * Used by _getContextRecord() to build the context chain.
+     * Retorna el record de contexto mergeado del logger padre en el momento
+     * de creación del child. Lo usa `_getContextRecord()` para construir la
+     * cadena de contextos.
      * @internal
      */
     getParentContextRecord?: () => Record<string, unknown>;
     /**
-     * The ALS instance to use for withContext scoping.
+     * Instancia de AsyncLocalStorage a usar para el scoping de `withContext`.
      * @internal
      */
     alsInstance?: ALS;
 }
 /**
- * Result returned by {@link createLogContext}.
+ * Contrato que retorna {@link createLogContext}.
+ *
+ * Fachada de MDC (Mapped Diagnostic Context) por logger. Combina tres fuentes
+ * de contexto:
+ * - **base inmutable** vía `child()` (snapshot capturado al crear el child),
+ * - **scope transitorio** vía `withContext()` / `withContextAsync()` sobre
+ *   AsyncLocalStorage,
+ * - **resource OTel** mergeado en cada record.
+ *
+ * En entornos browser sin `AsyncLocalStorage`, las variantes `withContext*`
+ * degradan a no-op: ejecutan `fn` sin scoping (o lo skipan si no hay `fn`).
+ * `child()` sigue operativo en browser porque no depende de ALS.
  */
 export interface LogContext {
     /**
-     * Current bound context snapshot (shallow copy — mutation does NOT affect
-     * what subsequent log calls emit).
+     * Snapshot actual del contexto bound.
+     *
+     * @returns Copia inmutable (shallow) del contexto; mutarla no afecta a los
+     * records que emitan futuras llamadas de log.
+     *
+     * @example
+     * const ctx = logContext.getContext();
+     * console.log(ctx.requestId); // 'abc-123'
      */
     getContext(): ContextSnapshot;
     /**
-     * Runs `fn` within an AsyncLocalStorage scope where `bindings` are
-     * merged into the context for all log calls inside `fn`.
+     * Ejecuta `fn` dentro de un scope de AsyncLocalStorage donde `bindings`
+     * se mergean al contexto para todas las llamadas de log dentro de `fn`.
      *
-     * If `fn` is not provided (the old setter shape), this is a no-op
-     * for backwards compatibility. Prefer `child()` for persistent binding
-     * or `withContextAsync()` for async callbacks.
+     * Si no se pasa `fn` (la vieja forma de setter), es no-op por backwards
+     * compatibility. Para binding persistente prefiere `child()`; para
+     * callbacks async usa `withContextAsync()`.
      *
-     * @param bindings - Key-value pairs to attach for the duration of `fn`
-     * @param fn - Optional synchronous function to run with the scoped bindings
-     * @returns The return value of `fn`, or undefined if no fn provided
+     * **Browser fallback**: sin ALS, ejecuta `fn` directamente sin scoping
+     * (los bindings NO se mergean). Si tampoco hay `fn`, retorna `undefined`.
+     *
+     * @param bindings - Pares key-value a attachar durante la ejecución de `fn`
+     * @param fn - Función sincrónica opcional a ejecutar bajo el scope ALS
+     * @returns El valor de retorno de `fn`, o `undefined` si no se pasa `fn`
+     *
+     * @example
+     * logContext.withContext({ requestId: 'abc-123' }, () => {
+     *   logger.info('procesando'); // el record lleva requestId=abc-123
+     * });
+     * // fuera de fn: requestId ya no está presente en próximos logs
+     *
+     * @see {@link LogContext.withContextAsync} para callbacks async
+     * @see {@link LogContext.child} para binding persistente inmutable (sin ALS)
      */
     withContext<R>(bindings: Record<string, unknown>, fn?: () => R): R | undefined;
     /**
-     * Async variant of `withContext`. Runs `fn` within an AsyncLocalStorage
-     * scope so bindings are available to all async log calls inside `fn`.
+     * Variante async de {@link withContext}. Ejecuta `fn` dentro de un scope
+     * de AsyncLocalStorage para que los bindings queden disponibles a todas las
+     * llamadas de log async dentro de `fn` (incluso tras `await`).
+     *
+     * **Browser fallback**: sin ALS, ejecuta `fn` directamente sin scoping.
      *
-     * @param bindings - Key-value pairs to attach for the duration of `fn`
-     * @param fn - Async function to run with the scoped bindings
-     * @returns The return value of `fn`
+     * @param bindings - Pares key-value a attachar durante la ejecución de `fn`
+     * @param fn - Función async a ejecutar bajo el scope ALS
+     * @returns El Promise retornado por `fn`
+     *
+     * @example
+     * await logContext.withContextAsync({ traceId }, async () => {
+     *   const user = await fetchUser();
+     *   logger.info('user cargado', { id: user.id });
+     *   // el record lleva el traceId aunque el log ocurra tras un await
+     * });
      */
     withContextAsync<R>(bindings: Record<string, unknown>, fn: () => Promise<R>): Promise<R>;
     /**
-     * Drops every key from the bound context. After this call, emitted
-     * records no longer carry `attributes` until {@link withContext} or
-     * {@link child} re-establishes one.
+     * Droppea todas las keys del contexto bound. Tras esta llamada, los
+     * records emitidos ya no llevan `attributes` hasta que
+     * {@link withContext} o {@link child} restablezcan uno.
+     *
+     * @returns La misma instancia de LogContext, ahora sin contexto
      *
-     * @returns The same LogContext instance, now context-free
+     * @example
+     * logContext.clearContext();
+     * logger.info('limpio'); // sin attributes
      */
     clearContext(): this;
     /**
-     * Updates the default OTel resource (service.name, version, env).
-     * Persisted into every emitted record's `resource` field unless the
-     * record itself overrides it.
+     * Actualiza el resource OTel por defecto (service.name, version,
+     * deployment.environment, ...).
+     *
+     * Se persiste en el campo `resource` de cada record emitido, salvo que el
+     * propio record lo overridee.
+     *
+     * @param resource - Resource OTel parcial a mergear con el actual
+     * @returns La misma instancia de LogContext, para encadenar calls
      *
-     * @param resource - Partial OTel resource to merge into the current one
-     * @returns The same LogContext instance, for chaining
+     * @example
+     * logContext.setResource({ serviceName: 'api-gateway', environment: 'prod' });
      */
     setResource(resource: Partial<ILogResourceRef>): this;
     /**
-     * Returns an immutable copy of this logger with the extra context bound.
-     * Future calls on the child emit with the merged context, without
-     * mutating the parent — the canonical MDC pattern.
+     * Devuelve una copia inmutable de este logger con el contexto extra bound.
      *
-     * @param extra - Key-value pairs to attach (requestId, userId, ...)
-     * @returns A new Logger with merged context
+     * Las llamadas futuras sobre el child emiten con el contexto mergeado, sin
+     * mutar al padre — patrón canónico de MDC.
+     *
+     * A diferencia de {@link withContext}, **no involucra AsyncLocalStorage**:
+     * el binding es persistente y queda capturado en el snapshot del child al
+     * crearse. Por eso `child()` es operativo también en browser sin ALS.
+     *
+     * Los bindings transitorios de ALS activos en el momento de `child()` NO
+     * se bakean en el child — solo se captura el contexto base. ALS se aplica
+     * fresco en cada dispatch vía `_getContextRecord()`.
+     *
+     * @param extra - Pares key-value a attachar (requestId, userId, ...)
+     * @returns Un nuevo Logger con el contexto mergeado
+     *
+     * @example
+     * const requestLog = logContext.child({ requestId: 'abc-123' });
+     * requestLog.info('inicio');   // siempre lleva requestId=abc-123
+     * requestLog.info('fin');
+     * // el logger padre no se ve afectado por estos bindings
+     *
+     * @see {@link LogContext.withContext} para scoping transitorio (ALS)
      */
     child(extra: Record<string, unknown>): ChildLoggerShape;
-    /** Internal context record. Exposed for TransportRecord assembly. */
+    /**
+     * Record de contexto interno. Expuesto para el ensamblado de TransportRecord
+     * (base + overlay ALS si hay store activo).
+     * @internal
+     */
     _getContextRecord(): Record<string, unknown>;
     /**
-     * Returns the base context WITHOUT the ALS overlay.
-     * Used by Logger.child() to capture the parent context snapshot for
-     * child logger creation (F4.5.5 fix).
+     * Retorna el contexto base SIN el overlay de ALS.
+     *
+     * Lo usa `Logger.child()` para capturar el snapshot del contexto padre al
+     * crear un child logger, garantizando que el binding ALS transitorio no
+     * se bakeé en el child.
      * @internal
      */
     _getBaseContextRecord(): Record<string, unknown>;
-    /** Internal resource record. Exposed for TransportRecord assembly. */
+    /**
+     * Record de resource interno. Expuesto para el ensamblado de TransportRecord.
+     * @internal
+     */
     _getResource(): Partial<ILogResourceRef> | undefined;
     /**
-     * Returns the current AsyncLocalStorage store, if ALS is active.
+     * Retorna el store actual de AsyncLocalStorage, si ALS está activo en el
+     * call stack corriente.
      * @internal
      */
     _getAlsStore(): Record<string, unknown> | undefined;
 }
-type ALS = {
-    run<R>(store: Record<string, unknown>, fn: () => R): R;
-    getStore(): Record<string, unknown> | undefined;
-};
+type ALS = AsyncLocalStorageLike<Record<string, unknown>>;
 /**
- * Creates a LogContext instance.
+ * Factory que crea una instancia de {@link LogContext}.
+ *
+ * @param options - Configuración (ver {@link ILogContextOptions})
+ * @returns Una instancia de LogContext lista para usar
+ *
+ * @example
+ * const logContext = createLogContext({
+ *   childLoggerFactory: (cfg) => new Logger(cfg),
+ *   initialContext: { service: 'orders-api' },
+ *   initialResource: { serviceName: 'orders-api', environment: 'prod' }
+ * });
+ *
+ * // Child inmutable con contexto persistente
+ * const requestLog = logContext.child({ requestId: 'abc-123' });
  *
- * @param options - Configuration options
- * @returns A LogContext instance
+ * // Scope transitorio vía ALS (Node; en browser sin ALS es no-op)
+ * logContext.withContext({ traceId: 't-9' }, () => {
+ *   requestLog.info('procesando orden');
+ * });
  */
 export declare function createLogContext(options: ILogContextOptions): LogContext;
 export {};

package/dist/context/LogContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LogContext.d.ts","sourceRoot":"","sources":["../../src/context/LogContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,uCAAuC;IACvC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,mDAAmD;IACnD,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,wDAAwD;IACxD,eAAe,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvD;;;OAGG;IACH,WAAW,CAAC,EAAE,GAAG,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB;;;OAGG;IACH,UAAU,IAAI,eAAe,CAAC;IAE9B;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE/E;;;;;;;OAOG;IACH,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEzF;;;;;;OAMG;IACH,YAAY,IAAI,IAAI,CAAC;IAErB;;;;;;;OAOG;IACH,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;IAEtD;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,gBAAgB,CAAC;IAExD,qEAAqE;IACrE,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjD,sEAAsE;IACtE,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC;IACrD;;;OAGG;IACH,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CACvD;AAGD,KAAK,GAAG,GAAG;IACP,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IACvD,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CACnD,CAAC;AAOF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,UAAU,CA2FxE"}
+{"version":3,"file":"LogContext.d.ts","sourceRoot":"","sources":["../../src/context/LogContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAA4B,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAErG;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC;AAE5E;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,8CAA8C;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,qDAAqD;IACrD,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,8DAA8D;IAC9D,eAAe,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvD;;;OAGG;IACH,WAAW,CAAC,EAAE,GAAG,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,UAAU;IACvB;;;;;;;;;OASG;IACH,UAAU,IAAI,eAAe,CAAC;IAE9B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE/E;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEzF;;;;;;;;;;OAUG;IACH,YAAY,IAAI,IAAI,CAAC;IAErB;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;IAEtD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,gBAAgB,CAAC;IAExD;;;;OAIG;IACH,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C;;;;;;;OAOG;IACH,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjD;;;OAGG;IACH,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC;IACrD;;;;OAIG;IACH,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CACvD;AAGD,KAAK,GAAG,GAAG,qBAAqB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAW1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,UAAU,CA6FxE"}

package/dist/context.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_LogContext = require("./chunks/LogContext-L7HzynFw.cjs");
+const require_LogContext = require("./chunks/LogContext-DZasm_P5.cjs");
 exports.createLogContext = require_LogContext.createLogContext;

package/dist/context.js

@@ -1,2 +1,2 @@
-import { t as createLogContext } from "./chunks/LogContext-Cwn-1Zzb.js";
+import { t as createLogContext } from "./chunks/LogContext-Dyzs61XG.js";
 export { createLogContext };

package/dist/core.cjs

@@ -2,17 +2,17 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_core = require("./chunks/core-Dzz7agGa.cjs");
-const require_utils = require("./chunks/utils-BqlFYocD.cjs");
-const require_environment_detector = require("./chunks/environment-detector-Cnn6wr6O.cjs");
+const require_core = require("./chunks/core-CqS_UBzJ.cjs");
+const require_utils = require("./chunks/utils-W_cxqriN.cjs");
+const require_environment_detector = require("./chunks/environment-detector-D-tHkKWA.cjs");
 //#region src/core.ts
 /**
-* Minimal Logger class with core functionality only
-* 
+* Logger minimal con solo la funcionalidad core.
+*
 * @example
 * ```typescript
 * import { CoreLogger } from '@mks2508/better-logger/core';
-* 
+*
 * const logger = new CoreLogger();
 * logger.info('Hello world');
 * logger.error('Something went wrong', error);
@@ -25,8 +25,8 @@ var CoreLogger = class CoreLogger {
 	timers = /* @__PURE__ */ new Map();
 	groupDepth = 0;
 	/**
-	* Creates a new CoreLogger instance
-	* @param config - Optional configuration
+	* Crea una nueva instancia de CoreLogger.
+	* @param config - Configuración opcional.
 	*/
 	constructor(config = {}) {
 		this.config = {
@@ -40,25 +40,29 @@ var CoreLogger = class CoreLogger {
 		};
 	}
 	/**
-	* Get current configuration
+	* Obtiene la configuración actual.
 	*/
 	getConfig() {
 		return { ...this.config };
 	}
 	/**
-	* Sets the global prefix for all log messages
+	* Define el prefijo global para todos los mensajes de log.
+	* @param prefix - Prefijo a aplicar a todos los mensajes.
 	*/
 	setGlobalPrefix(prefix) {
 		this.config.globalPrefix = prefix;
 	}
 	/**
-	* Sets the verbosity level for filtering log output
+	* Define el nivel de verbosity para filtrar la salida de log.
+	* @param level - Nivel de verbosity.
 	*/
 	setVerbosity(level) {
 		this.config.verbosity = level;
 	}
 	/**
-	* Creates a scoped logger with a specific prefix
+	* Crea un logger con scope y un prefijo específico.
+	* @param prefix - Prefijo del scope.
+	* @returns Nueva instancia de CoreLogger con el prefijo asignado.
 	*/
 	scope(prefix) {
 		const scopedLogger = new CoreLogger(this.config);
@@ -67,13 +71,16 @@ var CoreLogger = class CoreLogger {
 		return scopedLogger;
 	}
 	/**
-	* Adds a custom log handler for extensibility
+	* Añade un handler personalizado para extensibilidad.
+	* @param handler - Handler que implementa la interfaz ILogHandler.
 	*/
 	addHandler(handler) {
 		this.handlers.push(handler);
 	}
 	/**
-	* Checks if a log level should be output based on current verbosity
+	* Comprueba si un nivel debe emitirse según el verbosity actual.
+	* @param level - Nivel a evaluar.
+	* @returns `true` si el nivel debe emitirse.
 	*/
 	shouldLog(level) {
 		if (this.config.verbosity === "silent") return false;
@@ -81,14 +88,17 @@ var CoreLogger = class CoreLogger {
 		return require_core.LOG_LEVELS[level] >= require_core.LOG_LEVELS[verbosity];
 	}
 	/**
-	* Gets the effective prefix (global + scoped)
+	* Obtiene el prefijo efectivo (global + scope).
+	* @returns Prefijo combinado o `undefined` si no hay ninguno.
 	*/
 	getEffectivePrefix() {
 		const parts = [this.config.globalPrefix, this.scopedPrefix].filter(Boolean);
 		return parts.length > 0 ? parts.join(":") : void 0;
 	}
 	/**
-	* Core logging method with universal formatting
+	* Método principal de log con formato universal.
+	* @param level - Nivel del mensaje.
+	* @param args - Argumentos del mensaje.
 	*/
 	log(level, ...args) {
 		if (!this.shouldLog(level)) return;
@@ -123,44 +133,52 @@ var CoreLogger = class CoreLogger {
 		});
 	}
 	/**
-	* Logs debug information (lowest priority)
+	* Emite mensajes de debug (prioridad más baja).
+	* @param args - Argumentos del mensaje.
 	*/
 	debug(...args) {
 		this.log("debug", ...args);
 	}
 	/**
-	* Logs informational messages
+	* Emite mensajes informativos.
+	* @param args - Argumentos del mensaje.
 	*/
 	info(...args) {
 		this.log("info", ...args);
 	}
 	/**
-	* Logs warning messages
+	* Emite mensajes de advertencia.
+	* @param args - Argumentos del mensaje.
 	*/
 	warn(...args) {
 		this.log("warn", ...args);
 	}
 	/**
-	* Logs error messages
+	* Emite mensajes de error.
+	* @param args - Argumentos del mensaje.
 	*/
 	error(...args) {
 		this.log("error", ...args);
 	}
 	/**
-	* Logs critical errors (highest priority)
+	* Emite errores críticos (prioridad más alta).
+	* @param args - Argumentos del mensaje.
 	*/
 	critical(...args) {
 		this.log("critical", ...args);
 	}
 	/**
-	* Logs trace information (detailed debugging)
+	* Emite información de trace (debugging detallado).
+	* @param args - Argumentos del mensaje.
 	*/
 	trace(...args) {
 		this.log("debug", ...args);
 		if (this.shouldLog("debug")) console.trace(...args);
 	}
 	/**
-	* Displays data in a table format
+	* Muestra datos en formato tabla.
+	* @param data - Datos a mostrar.
+	* @param columns - Columnas opcionales a incluir.
 	*/
 	table(data, columns) {
 		if (!this.shouldLog("info")) return;
@@ -177,7 +195,9 @@ var CoreLogger = class CoreLogger {
 		}
 	}
 	/**
-	* Starts a collapsible group in the console
+	* Inicia un grupo colapsable en la console.
+	* @param label - Etiqueta del grupo.
+	* @param collapsed - Si el grupo inicia colapsado.
 	*/
 	group(label, collapsed = false) {
 		const prefix = this.getEffectivePrefix();
@@ -191,7 +211,7 @@ var CoreLogger = class CoreLogger {
 		this.groupDepth++;
 	}
 	/**
-	* Ends the current console group
+	* Cierra el grupo actual de la console.
 	*/
 	groupEnd() {
 		if (this.groupDepth > 0) {
@@ -201,7 +221,8 @@ var CoreLogger = class CoreLogger {
 		}
 	}
 	/**
-	* Starts a timer with the given label
+	* Inicia un timer con el label indicado.
+	* @param label - Identificador del timer.
 	*/
 	time(label) {
 		const timer = {
@@ -214,7 +235,8 @@ var CoreLogger = class CoreLogger {
 		console.log(output);
 	}
 	/**
-	* Ends a timer and logs the elapsed time
+	* Detiene un timer y emite el tiempo transcurrido.
+	* @param label - Identificador del timer previamente iniciado.
 	*/
 	timeEnd(label) {
 		const timer = this.timers.get(label);
@@ -229,7 +251,8 @@ var CoreLogger = class CoreLogger {
 		console.log(output);
 	}
 	/**
-	* Gets performance.now() or fallback for older environments
+	* Obtiene `performance.now()` o un fallback para entornos antiguos.
+	* @returns Timestamp en milisegundos.
 	*/
 	getPerformanceNow() {
 		if (typeof performance !== "undefined" && performance.now) return performance.now();
@@ -242,7 +265,7 @@ var CoreLogger = class CoreLogger {
 };
 const coreLogger = new CoreLogger();
 /**
-* Export individual methods for convenience (with proper binding)
+* Exporta métodos individuales por conveniencia (con binding correcto).
 */
 const debug = (...args) => coreLogger.debug(...args);
 const info = (...args) => coreLogger.info(...args);