@mks2508/better-logger 0.14.0-alpha.2 → 0.18.2-alpha.2

package/dist/cli/help.d.ts

@@ -1,15 +1,43 @@
 /**
- * @fileoverview Help system for Advanced Logger CLI
+ * @fileoverview Help system del CLI del logger. Expone {@link HelpCommand},
+ * que renderiza un panel ASCII con la lista completa de comandos, opciones de
+ * configuración, filtros de export y ejemplos de uso.
  */
 import type { ICommand } from './CommandProcessor.js';
 import type { Logger } from '../Logger.js';
 /**
- * Help command - show comprehensive CLI help
+ * Comando `/help`: renderiza en consola el panel de ayuda del CLI con todos
+ * los comandos disponibles, opciones de configuración, filtros de export y
+ * ejemplos. El panel usa un gradient claro con {@link StyleBuilder} y los
+ * quick tips se agrupan vía `logger.group`.
+ *
+ * Registrado por defecto por {@link createDefaultCLI}.
+ *
+ * @example
+ * ```ts
+ * const cli = createDefaultCLI();
+ * await cli.processCommand('/help', logger);
+ * // Imprime el panel ASCII con gradient + grupo "Quick Tips".
+ * ```
+ *
+ * @see {@link ICommand}
+ * @see {@link createDefaultCLI}
  */
 export declare class HelpCommand implements ICommand {
     name: string;
     description: string;
     usage: string;
+    /**
+     * Renderiza el panel de ayuda completo. Actualmente ignora `_args`: el
+     * `usage` declara `/help [command]` (sub-comando opcional) pero la
+     * implementación siempre muestra el panel global.
+     *
+     * @param {string} _args - Argumentos opcionales (reservado para ayuda por
+     *   sub-comando; sin uso actual).
+     * @param {Logger} logger - Logger activo; se usa solo para `group`/`info`
+     *   de los quick tips.
+     * @returns {void}
+     */
     execute(_args: string, logger: Logger): void;
 }
 //# sourceMappingURL=help.d.ts.map

package/dist/cli/help.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG3C;;GAEG;AACH,qBAAa,WAAY,YAAW,QAAQ;IACxC,IAAI,SAAU;IACd,WAAW,SAA0C;IACrD,KAAK,SAAqB;IAE1B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CA8G/C"}
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,WAAY,YAAW,QAAQ;IACxC,IAAI,SAAU;IACd,WAAW,SAA0C;IACrD,KAAK,SAAqB;IAE1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CA8G/C"}

package/dist/cli/index.d.ts

@@ -1,15 +1,41 @@
 /**
- * @fileoverview CLI system exports for Advanced Logger
+ * @fileoverview Punto de entrada del subsistema CLI del logger. Re-exporta el
+ * processor, los comandos estándar y expone {@link createDefaultCLI} como
+ * factory principal. El CLI no es un binario standalone — se invoca desde
+ * código vía `logger.cli()` o desde la devtools vía `window.cli()` (cuando el
+ * modo interactivo está activo).
  */
 export { CommandProcessor, type ICommand } from './CommandProcessor.js';
 import { CommandProcessor } from './CommandProcessor.js';
 export { ConfigCommand } from './commands/ConfigCommand.js';
 export { ThemesCommand, BannersCommand, BannerCommand } from './commands/ThemeCommand.js';
-export { StatusCommand, ResetCommand, DemoCommand } from './commands/StatusCommand.js';
-export { ExportCommand, CopyCommand, BufferSizeCommand, ClearBufferCommand, BufferInfoCommand } from './commands/ExportCommand.js';
+export { StatusCommand, ResetCommand, DemoCommand } from './commands/ExportCommand.js';
 export { HelpCommand } from './help.js';
 /**
- * Create and configure default CLI processor
+ * Crea un {@link CommandProcessor} con los 8 comandos estándar ya registrados:
+ * `help`, `config`, `themes`, `banners`, `banner`, `status`, `reset` y
+ * `demo`. Es el factory canónico — los consumidores normalmente no construyen
+ * un `CommandProcessor` vacío a mano, ya que este no trae comandos cargados.
+ *
+ * @returns {CommandProcessor} Processor listo para usar, sin modo interactivo activo.
+ *
+ * @example
+ * ```ts
+ * const cli = createDefaultCLI();
+ * await cli.processCommand('/help', logger);
+ * await cli.processCommand('/config theme=neon', logger);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Modo interactivo en el navegador: expone `window.cli`
+ * const cli = createDefaultCLI();
+ * cli.enterInteractiveMode(logger);
+ * // desde devtools: cli('themes')  →  procesa '/themes'
+ * ```
+ *
+ * @see {@link CommandProcessor}
+ * @see {@link HelpCommand}
  */
 export declare function createDefaultCLI(): CommandProcessor;
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC1F,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EACH,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAqBxC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CAyBnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC1F,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAGvF,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAQxC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CAcnD"}

package/dist/cli-module.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview CLI-only entry point for @mks2508/better-logger/cli
+ * Exports only CLI primitives for minimal bundle size in CLI tools.
+ */
+export { renderStep } from './playground/step.js';
+export { renderHeader } from './playground/header.js';
+export { renderDivider } from './playground/divider.js';
+export { renderBox } from './playground/box.js';
+export { renderTable } from './playground/cli-table.js';
+export { SpinnerManager, NoopSpinner } from './playground/spinner.js';
+export { ServerFallback } from './playground/server-fallback.js';
+export type { CLILogLevel, ISpinnerHandle, IBoxOptions, ITableOptions, } from './types/index.js';
+//# sourceMappingURL=cli-module.d.ts.map

package/dist/cli-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-module.d.ts","sourceRoot":"","sources":["../src/cli-module.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjE,YAAY,EACR,WAAW,EACX,cAAc,EACd,WAAW,EACX,aAAa,GAChB,MAAM,kBAAkB,CAAC"}

package/dist/cli.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_spinner = require("./chunks/spinner-BHyYEXsM.cjs");
+const require_server_fallback = require("./chunks/server-fallback-CaCPjWby.cjs");
+exports.NoopSpinner = require_spinner.NoopSpinner;
+exports.ServerFallback = require_server_fallback.ServerFallback;
+exports.SpinnerManager = require_spinner.SpinnerManager;
+exports.renderBox = require_spinner.renderBox;
+exports.renderDivider = require_spinner.renderDivider;
+exports.renderHeader = require_spinner.renderHeader;
+exports.renderStep = require_spinner.renderStep;
+exports.renderTable = require_spinner.renderTable;

package/dist/cli.js

@@ -0,0 +1,3 @@
+import { a as renderDivider, i as renderBox, n as SpinnerManager, o as renderHeader, r as renderTable, s as renderStep, t as NoopSpinner } from "./chunks/spinner-BtkwpzYv.js";
+import { t as ServerFallback } from "./chunks/server-fallback-jj0T6XaK.js";
+export { NoopSpinner, ServerFallback, SpinnerManager, renderBox, renderDivider, renderHeader, renderStep, renderTable };

package/dist/constants.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Global constants for Advanced Logger
  */
-import type { LogLevel } from './types/index.js';
+import type { LogLevel, CLILogLevel, Verbosity } from './types/index.js';
 import type { LevelStyleConfig } from './utils/index.js';
 /**
  * Default configuration values
@@ -15,18 +15,21 @@ export declare const DEFAULT_CONFIG: {
     readonly bannerType: "simple";
     readonly bufferSize: 1000;
     readonly autoDetectTheme: true;
+    readonly outputFormat: "auto";
 };
 /**
  * Basic level styles for core module (minimal CSS styling)
  */
 export declare const LEVEL_STYLES: Record<LogLevel | 'success', LevelStyleConfig>;
 /**
- * Maximum allowed buffer sizes for performance
+ * Time parsing constants for relative time filters
  */
-export declare const BUFFER_LIMITS: {
-    readonly MIN_SIZE: 50;
-    readonly DEFAULT_SIZE: 1000;
-    readonly MAX_SIZE: 10000;
+export declare const TIME_UNITS: {
+    readonly ms: 1;
+    readonly s: 1000;
+    readonly m: number;
+    readonly h: number;
+    readonly d: number;
 };
 /**
  * Export format definitions with extensions
@@ -53,47 +56,6 @@ export declare const EXPORT_FORMATS: {
         readonly mimeType: "text/html";
     };
 };
-/**
- * CLI command definitions
- */
-export declare const CLI_COMMANDS: {
-    readonly config: "config";
-    readonly help: "help";
-    readonly themes: "themes";
-    readonly banners: "banners";
-    readonly banner: "banner";
-    readonly status: "status";
-    readonly reset: "reset";
-    readonly demo: "demo";
-    readonly export: "export";
-    readonly copy: "copy";
-    readonly 'buffer-size': "buffer-size";
-    readonly 'clear-buffer': "clear-buffer";
-    readonly 'buffer-info': "buffer-info";
-};
-/**
- * Time parsing constants for relative time filters
- */
-export declare const TIME_UNITS: {
-    readonly ms: 1;
-    readonly s: 1000;
-    readonly m: number;
-    readonly h: number;
-    readonly d: number;
-};
-/**
- * Default styling values
- */
-export declare const STYLE_DEFAULTS: {
-    readonly FONT_FAMILY: "Monaco, Consolas, monospace";
-    readonly FONT_SIZE: "12px";
-    readonly BORDER_RADIUS: "4px";
-    readonly PADDING: "4px 8px";
-};
-/**
- * Level priority mapping for filtering
- */
-export declare const LEVEL_PRIORITIES: Record<LogLevel, number>;
 /**
  * Adaptive color configurations for DevTools theme compatibility
  */
@@ -119,4 +81,11 @@ export declare const ADAPTIVE_COLORS: {
         readonly dark: "#a0aec0";
     };
 };
+/**
+ * CLI log level to internal verbosity mapping
+ */
+export declare const CLI_LEVEL_MAP: Record<CLILogLevel, {
+    verbosity: Verbosity;
+    showPrimitives: boolean;
+}>;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;CASjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,QAAQ,GAAG,SAAS,EAAE,gBAAgB,CAiD9D,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;CAMjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAcf,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;CAMb,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAM5C,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAqBuB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAkB,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;CAUjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,QAAQ,GAAG,SAAS,EAAE,gBAAgB,CAyD9D,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;CAMb,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;CAMjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAqBuB,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,WAAW,EAAE;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAAE,CAMvF,CAAC"}

package/dist/context/LogContext.d.ts

@@ -0,0 +1,245 @@
+/**
+ * @fileoverview Bridge de LogContext — gestión de MDC (Mapped Diagnostic Context).
+ *
+ * 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';
+/**
+ * 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>>;
+/**
+ * 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;
+/**
+ * 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>;
+    /** Campo legacy — ya no es la fuente canónica del contexto. */
+    context?: Record<string, unknown>;
+}
+/**
+ * Options que se pasan a {@link createLogContext}.
+ */
+export interface ILogContextOptions {
+    /** Pares key-value iniciales del contexto. */
+    initialContext?: Record<string, unknown>;
+    /** Factory para crear instancias child de logger. */
+    childLoggerFactory: ChildLoggerFactory;
+    /** Resource OTel inicial a mergear en cada record emitido. */
+    initialResource?: Partial<ILogResourceRef>;
+    /**
+     * 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>;
+    /**
+     * Instancia de AsyncLocalStorage a usar para el scoping de `withContext`.
+     * @internal
+     */
+    alsInstance?: ALS;
+}
+/**
+ * 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 {
+    /**
+     * 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;
+    /**
+     * Ejecuta `fn` dentro de un scope de AsyncLocalStorage donde `bindings`
+     * se mergean al contexto para todas las llamadas de log dentro de `fn`.
+     *
+     * 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()`.
+     *
+     * **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;
+    /**
+     * 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 - 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>;
+    /**
+     * 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
+     *
+     * @example
+     * logContext.clearContext();
+     * logger.info('limpio'); // sin attributes
+     */
+    clearContext(): this;
+    /**
+     * 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
+     *
+     * @example
+     * logContext.setResource({ serviceName: 'api-gateway', environment: 'prod' });
+     */
+    setResource(resource: Partial<ILogResourceRef>): this;
+    /**
+     * Devuelve una copia inmutable de este logger con el contexto extra bound.
+     *
+     * 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;
+    /**
+     * Record de contexto interno. Expuesto para el ensamblado de TransportRecord
+     * (base + overlay ALS si hay store activo).
+     * @internal
+     */
+    _getContextRecord(): Record<string, unknown>;
+    /**
+     * 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>;
+    /**
+     * Record de resource interno. Expuesto para el ensamblado de TransportRecord.
+     * @internal
+     */
+    _getResource(): Partial<ILogResourceRef> | undefined;
+    /**
+     * 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;
+};
+/**
+ * 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' });
+ *
+ * // 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 {};
+//# sourceMappingURL=LogContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LogContext.d.ts","sourceRoot":"","sources":["../../src/context/LogContext.ts"],"names":[],"mappings":"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"}

package/dist/context/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Context/MDC subpath barrel.
+ * Exports: child, withContext, withContextAsync, getContext, clearContext, setResource
+ */
+export { createLogContext, type LogContext, type ContextSnapshot, type ChildLoggerFactory, type ChildLoggerShape, } from './LogContext.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/context/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACH,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,GACxB,MAAM,iBAAiB,CAAC"}

package/dist/context-module.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Entry point for ./context subpath.
+ * MDC context utilities: createLogContext, child, withContext, getContext.
+ */
+export { createLogContext, type LogContext, type ContextSnapshot, type ChildLoggerFactory, type ChildLoggerShape } from './context/index.js';
+//# sourceMappingURL=context-module.d.ts.map

package/dist/context-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-module.d.ts","sourceRoot":"","sources":["../src/context-module.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,eAAe,EAAE,KAAK,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/context.cjs

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

package/dist/context.js

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