@lssm/lib.logger 0.0.0-canary-20251217054315 → 0.0.0-canary-20251217060804

package/dist/context.browser.d.mts

@@ -0,0 +1,48 @@
+import { ContextData, TraceContext } from "./types.mjs";
+import "zone.js";
+
+//#region src/context.browser.d.ts
+
+/**
+ * Browser implementation of LogContext using Zone.js for async context
+ * propagation (similar to AsyncLocalStorage in Node).
+ */
+declare class LogContext {
+  private static instance;
+  private static fallbackCounter;
+  static getInstance(): LogContext;
+  /**
+   * Run a function with a new context
+   */
+  run<T>(context: ContextData, fn: () => T): T;
+  /**
+   * Run a function with an extended context (merges with current)
+   */
+  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  /**
+   * Set context data for the current execution context
+   */
+  set(key: string, value: unknown): void;
+  /**
+   * Get a specific context value
+   */
+  get<T>(key: string): T | undefined;
+  /**
+   * Get all context data
+   */
+  getContext(): ContextData;
+  /**
+   * Set trace context
+   */
+  setTrace(trace: TraceContext): void;
+  /**
+   * Get current trace context
+   */
+  getCurrentTrace(): TraceContext | undefined;
+  /**
+   * Generate a unique ID for requests/operations
+   */
+  generateId(): string;
+}
+//#endregion
+export { LogContext };

package/dist/context.d.mts

@@ -0,0 +1,16 @@
+import { ContextData, TraceContext } from "./types.mjs";
+
+//#region src/context.d.ts
+
+interface LogContextApi {
+  run<T>(context: ContextData, fn: () => T): T;
+  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  set(key: string, value: unknown): void;
+  get<T>(key: string): T | undefined;
+  getContext(): ContextData;
+  setTrace(trace: TraceContext): void;
+  getCurrentTrace(): TraceContext | undefined;
+  generateId(): string;
+}
+//#endregion
+export { type ContextData, LogContextApi, type TraceContext };

package/dist/context.node.d.mts

@@ -0,0 +1,47 @@
+import { ContextData, TraceContext } from "./types.mjs";
+
+//#region src/context.node.d.ts
+
+/**
+ * Node.js implementation of LogContext using AsyncLocalStorage.
+ */
+declare class LogContext {
+  private static instance;
+  private storage;
+  constructor();
+  static getInstance(): LogContext;
+  /**
+   * Run a function with a new context
+   */
+  run<T>(context: ContextData, fn: () => T): T;
+  /**
+   * Run a function with an extended context (merges with current)
+   */
+  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  /**
+   * Set context data for the current execution context
+   */
+  set(key: string, value: unknown): void;
+  /**
+   * Get a specific context value
+   */
+  get<T>(key: string): T | undefined;
+  /**
+   * Get all context data
+   */
+  getContext(): ContextData;
+  /**
+   * Set trace context
+   */
+  setTrace(trace: TraceContext): void;
+  /**
+   * Get current trace context
+   */
+  getCurrentTrace(): TraceContext | undefined;
+  /**
+   * Generate a unique ID for requests/operations
+   */
+  generateId(): string;
+}
+//#endregion
+export { LogContext };

package/dist/elysia-plugin.d.mts

@@ -0,0 +1,63 @@
+import { ContextData } from "./types.mjs";
+import { Logger } from "./logger.node.mjs";
+import * as elysia0 from "elysia";
+import { Elysia } from "elysia";
+
+//#region src/elysia-plugin.d.ts
+interface ElysiaLoggerConfig {
+  logger?: Logger;
+  logRequests?: boolean;
+  logResponses?: boolean;
+  excludePaths?: string[];
+}
+/**
+ * Simple ElysiaJS Logger Plugin
+ * Provides automatic request logging and tracing
+ */
+declare function elysiaLogger<T extends Elysia>(config?: ElysiaLoggerConfig): (app: T) => Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: ({
+    readonly logger: Logger;
+    readonly requestContext?: undefined;
+    readonly startTime?: undefined;
+  } | {
+    readonly logger: Logger;
+    readonly requestContext: ContextData;
+    readonly startTime: number;
+  }) & {
+    readonly logInfo: (message: string, metadata?: Record<string, any>) => void;
+    readonly logError: (message: string, error?: Error, metadata?: Record<string, any>) => void;
+    readonly traceOperation: <T_1>(operationName: string, operation: () => T_1 | Promise<T_1>) => Promise<T_1>;
+  };
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: elysia0.ExtractErrorFromHandle<{
+    readonly logInfo: (message: string, metadata?: Record<string, any>) => void;
+    readonly logError: (message: string, error?: Error, metadata?: Record<string, any>) => void;
+    readonly traceOperation: <T_1>(operationName: string, operation: () => T_1 | Promise<T_1>) => Promise<T_1>;
+  }>;
+}>;
+declare const createElysiaLogger: typeof elysiaLogger;
+//#endregion
+export { ElysiaLoggerConfig, createElysiaLogger, elysiaLogger };

package/dist/elysia-plugin.mjs

@@ -1 +1 @@
-import{LogContext as e}from"./context.node.mjs";import{Logger as t}from"./logger.node.mjs";import"elysia";function n(n={}){let{logger:r=new t,logRequests:i=!0,logResponses:a=!0,excludePaths:o=[`/health`,`/metrics`]}=n,s=e.getInstance();return function(e){return e.derive(e=>{let{request:t,path:n}=e;if(o.some(e=>n.startsWith(e)))return{logger:r};let a=new URL(t.url),c={requestId:s.generateId(),method:t.method,url:t.url,path:a.pathname,userAgent:t.headers.get(`user-agent`)||void 0,timestamp:new Date().toISOString()},l=performance.now();return s.run(c,()=>{i&&r.info(`→ ${t.method} ${n}`,{method:t.method,path:n,userAgent:c.userAgent,requestId:c.requestId})}),{logger:r,requestContext:c,startTime:l}}).onAfterHandle(e=>{let{request:t,startTime:n,requestContext:r,logger:i}=e;if(!n||!r)return;let o=performance.now()-n,s=new URL(t.url).pathname;a&&i.info(`← 200 ${t.method} ${s}`,{method:t.method,path:s,duration:`${o.toFixed(2)}ms`,requestId:r.requestId})}).onError(e=>{let{request:t,error:n,code:r,startTime:i,requestContext:a,logger:o}=e;if(!i||!a)return;let s=performance.now()-i,c=new URL(t.url).pathname;o?.error(`✖ ${r} ${t.method} ${c}`,{method:t.method,path:c,error:n?.toString?.()||`Unknown error`,code:r,duration:`${s.toFixed(2)}ms`,requestId:a.requestId})}).derive(()=>({logInfo:(e,t)=>{r.info(e,t)},logError:(e,t,n)=>{r.error(e,n,t)},traceOperation:async(e,t)=>r.trace({operationType:`custom`,operationName:e,autoTiming:!0},t)}))}}const r=n;export{r as createElysiaLogger,n as elysiaLogger};
+import{LogContext as e}from"./context.node.mjs";import{Logger as t}from"./logger.node.mjs";import{Elysia as n}from"elysia";function r(n={}){let{logger:r=new t,logRequests:i=!0,logResponses:a=!0,excludePaths:o=[`/health`,`/metrics`]}=n,s=e.getInstance();return function(e){return e.derive(e=>{let{request:t,path:n}=e;if(o.some(e=>n.startsWith(e)))return{logger:r};let a=new URL(t.url),c={requestId:s.generateId(),method:t.method,url:t.url,path:a.pathname,userAgent:t.headers.get(`user-agent`)||void 0,timestamp:new Date().toISOString()},l=performance.now();return s.run(c,()=>{i&&r.info(`→ ${t.method} ${n}`,{method:t.method,path:n,userAgent:c.userAgent,requestId:c.requestId})}),{logger:r,requestContext:c,startTime:l}}).onAfterHandle(e=>{let{request:t,startTime:n,requestContext:r,logger:i}=e;if(!n||!r)return;let o=performance.now()-n,s=new URL(t.url).pathname;a&&i.info(`← 200 ${t.method} ${s}`,{method:t.method,path:s,duration:`${o.toFixed(2)}ms`,requestId:r.requestId})}).onError(e=>{let{request:t,error:n,code:r,startTime:i,requestContext:a,logger:o}=e;if(!i||!a)return;let s=performance.now()-i,c=new URL(t.url).pathname;o?.error(`✖ ${r} ${t.method} ${c}`,{method:t.method,path:c,error:n?.toString?.()||`Unknown error`,code:r,duration:`${s.toFixed(2)}ms`,requestId:a.requestId})}).derive(()=>({logInfo:(e,t)=>{r.info(e,t)},logError:(e,t,n)=>{r.error(e,n,t)},traceOperation:async(e,t)=>r.trace({operationType:`custom`,operationName:e,autoTiming:!0},t)}))}}const i=r;export{i as createElysiaLogger,r as elysiaLogger};

package/dist/formatters.d.mts

@@ -0,0 +1,28 @@
+import { Formatter, LogEntry } from "./types.mjs";
+
+//#region src/formatters.d.ts
+declare class DevFormatter implements Formatter {
+  private enableColors;
+  constructor(enableColors?: boolean);
+  format(entry: LogEntry): string;
+  private formatTimestamp;
+  private formatTraceInfo;
+  private formatDuration;
+  private formatContext;
+  private formatMetadata;
+  private formatError;
+  private formatObject;
+  private formatValue;
+  private colorize;
+}
+declare class ProductionFormatter implements Formatter {
+  format(entry: LogEntry): string;
+}
+declare class CustomFormatter implements Formatter {
+  private template;
+  private dateFormat;
+  constructor(template?: string, dateFormat?: (date: Date) => string);
+  format(entry: LogEntry): string;
+}
+//#endregion
+export { CustomFormatter, DevFormatter, ProductionFormatter };

package/dist/index.browser.d.mts

@@ -0,0 +1,7 @@
+import { LogEntry, LogLevel, TraceContext, TracingOptions } from "./types.mjs";
+import { LogContext } from "./context.browser.mjs";
+import { Timer } from "./timer.mjs";
+import { DevFormatter, ProductionFormatter } from "./formatters.mjs";
+import { Logger } from "./logger.browser.mjs";
+import { Tracer } from "./tracer.browser.mjs";
+export { DevFormatter, LogContext, type LogEntry, LogLevel, Logger, ProductionFormatter, Timer, type TraceContext, Tracer, type TracingOptions };

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { LogEntry, LogLevel, TraceContext, TracingOptions } from "./types.mjs";
+import { LogContext } from "./context.node.mjs";
+import { Timer } from "./timer.mjs";
+import { Logger } from "./logger.node.mjs";
+import { createElysiaLogger, elysiaLogger } from "./elysia-plugin.mjs";
+import { DevFormatter, ProductionFormatter } from "./formatters.mjs";
+import { Tracer } from "./tracer.node.mjs";
+export { DevFormatter, LogContext, type LogEntry, LogLevel, Logger, ProductionFormatter, Timer, type TraceContext, Tracer, type TracingOptions, createElysiaLogger, elysiaLogger };

package/dist/logger.browser.d.mts

@@ -0,0 +1,50 @@
+import { ContextData, Formatter, LogLevel, LoggerConfig, TraceContext, TraceMethod, TracingOptions } from "./types.mjs";
+import { Timer } from "./timer.mjs";
+
+//#region src/logger.browser.d.ts
+declare class Logger {
+  private config;
+  private formatter;
+  private context;
+  private tracer;
+  private timerManager;
+  constructor(config?: Partial<LoggerConfig>);
+  traceLog(message: string, metadata?: Record<string, unknown>): void;
+  debug(message: string, metadata?: Record<string, unknown>): void;
+  info(message: string, metadata?: Record<string, unknown>): void;
+  warn(message: string, metadata?: Record<string, unknown>): void;
+  error(message: string, metadata?: Record<string, unknown>, error?: Error): void;
+  fatal(message: string, metadata?: Record<string, unknown>, error?: Error): void;
+  withContext<T>(context: ContextData, fn: () => T): T;
+  extendContext<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  setContext(key: string, value: unknown): void;
+  getContext(): ContextData;
+  trace: TraceMethod;
+  getTraceId(): string | undefined;
+  startSpan(options: TracingOptions): TraceContext | null;
+  finishSpan(spanId: string): number | undefined;
+  addTraceMetadata(key: string, value: unknown): void;
+  addTraceTags(...tags: string[]): void;
+  startTimer(id?: string): Timer | null;
+  stopTimer(id: string): number | undefined;
+  getTimer(id: string): Timer | undefined;
+  child(context: Partial<ContextData>): Logger;
+  setLevel(level: LogLevel): void;
+  setFormatter(formatter: Formatter): void;
+  profile<T>(operationName: string, fn: () => T | Promise<T>, options?: {
+    logResult?: boolean;
+    logLevel?: LogLevel;
+  }): Promise<T>;
+  logRequest(method: string, url: string, statusCode?: number, duration?: number): void;
+  flush(): Promise<void>;
+  getStats(): {
+    activeTimers: number;
+    activeSpans: number;
+    config: LoggerConfig;
+  };
+  protected output(message: string, level: LogLevel): void;
+  private log;
+  private getHttpLogLevel;
+}
+//#endregion
+export { Logger };

package/dist/logger.d.mts

@@ -0,0 +1,2 @@
+import { Logger } from "./logger.node.mjs";
+export { Logger };

package/dist/logger.node.d.mts

@@ -0,0 +1,50 @@
+import { ContextData, Formatter, LogLevel, LoggerConfig, TraceContext, TraceMethod, TracingOptions } from "./types.mjs";
+import { Timer } from "./timer.mjs";
+
+//#region src/logger.node.d.ts
+declare class Logger {
+  private config;
+  private formatter;
+  private context;
+  private tracer;
+  private timerManager;
+  constructor(config?: Partial<LoggerConfig>);
+  traceLog(message: string, metadata?: Record<string, unknown>): void;
+  debug(message: string, metadata?: Record<string, unknown>): void;
+  info(message: string, metadata?: Record<string, unknown>): void;
+  warn(message: string, metadata?: Record<string, unknown>): void;
+  error(message: string, metadata?: Record<string, unknown>, error?: Error): void;
+  fatal(message: string, metadata?: Record<string, unknown>, error?: Error): void;
+  withContext<T>(context: ContextData, fn: () => T): T;
+  extendContext<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  setContext(key: string, value: unknown): void;
+  getContext(): ContextData;
+  trace: TraceMethod;
+  getTraceId(): string | undefined;
+  startSpan(options: TracingOptions): TraceContext | null;
+  finishSpan(spanId: string): number | undefined;
+  addTraceMetadata(key: string, value: unknown): void;
+  addTraceTags(...tags: string[]): void;
+  startTimer(id?: string): Timer | null;
+  stopTimer(id: string): number | undefined;
+  getTimer(id: string): Timer | undefined;
+  child(context: Partial<ContextData>): Logger;
+  setLevel(level: LogLevel): void;
+  setFormatter(formatter: Formatter): void;
+  profile<T>(operationName: string, fn: () => T | Promise<T>, options?: {
+    logResult?: boolean;
+    logLevel?: LogLevel;
+  }): Promise<T>;
+  logRequest(method: string, url: string, statusCode?: number, duration?: number): void;
+  flush(): Promise<void>;
+  getStats(): {
+    activeTimers: number;
+    activeSpans: number;
+    config: LoggerConfig;
+  };
+  protected output(message: string, level: LogLevel): void;
+  private log;
+  private getHttpLogLevel;
+}
+//#endregion
+export { Logger };

package/dist/timer.d.mts

@@ -0,0 +1,102 @@
+import { Timer as Timer$1 } from "./types.mjs";
+
+//#region src/timer.d.ts
+declare class Timer implements Timer$1 {
+  readonly id: string;
+  private startTime;
+  private laps;
+  private stopped;
+  private stopTime?;
+  constructor(id?: string);
+  /**
+   * Stop the timer and return elapsed time in milliseconds
+   */
+  stop(): number;
+  /**
+   * Record a lap time and return elapsed time since start
+   */
+  lap(label?: string): number;
+  /**
+   * Get elapsed time without stopping the timer
+   */
+  getElapsed(): number;
+  /**
+   * Get all recorded laps
+   */
+  getLaps(): {
+    label?: string;
+    time: number;
+    elapsed: number;
+  }[];
+  /**
+   * Get timer summary with total time and laps
+   */
+  getSummary(): {
+    id: string;
+    totalTime: number;
+    isRunning: boolean;
+    laps: {
+      label?: string;
+      time: number;
+      elapsed: number;
+    }[];
+  };
+  /**
+   * Reset the timer (starts a new timing session)
+   */
+  reset(): void;
+}
+/**
+ * Utility class for managing multiple timers
+ */
+declare class TimerManager {
+  private timers;
+  /**
+   * Start a new timer
+   */
+  start(id?: string): Timer;
+  /**
+   * Get an existing timer
+   */
+  get(id: string): Timer | undefined;
+  /**
+   * Stop and remove a timer
+   */
+  stop(id: string): number | undefined;
+  /**
+   * Get all active timers
+   */
+  getActive(): Timer[];
+  /**
+   * Clear all timers
+   */
+  clear(): void;
+  /**
+   * Get summary of all timers
+   */
+  getSummary(): ReturnType<Timer['getSummary']>[];
+}
+/**
+ * Decorator/wrapper function to time async operations
+ */
+declare function timed<T>(operation: () => Promise<T>, options?: {
+  id?: string;
+  onComplete?: (elapsed: number) => void;
+}): Promise<{
+  result: T;
+  elapsed: number;
+  timer: Timer;
+}>;
+/**
+ * Decorator/wrapper function to time synchronous operations
+ */
+declare function timedSync<T>(operation: () => T, options?: {
+  id?: string;
+  onComplete?: (elapsed: number) => void;
+}): {
+  result: T;
+  elapsed: number;
+  timer: Timer;
+};
+//#endregion
+export { Timer, TimerManager, timed, timedSync };

package/dist/tracer.browser.d.mts

@@ -0,0 +1,50 @@
+import { TraceContext, TracingOptions } from "./types.mjs";
+
+//#region src/tracer.browser.d.ts
+declare class Tracer {
+  private context;
+  private activeSpans;
+  constructor();
+  /**
+   * Start a new trace span
+   */
+  startSpan(options: TracingOptions): TraceContext;
+  /**
+   * Finish a trace span
+   */
+  finishSpan(spanId: string): number | undefined;
+  /**
+   * Execute a function within a trace span
+   */
+  trace<T>(options: TracingOptions, fn: () => T | Promise<T>): Promise<T>;
+  /**
+   * Add metadata to current span
+   */
+  addMetadata(key: string, value: unknown): void;
+  /**
+   * Add tags to current span
+   */
+  addTags(...tags: string[]): void;
+  /**
+   * Get current trace context
+   */
+  getCurrentTrace(): TraceContext | undefined;
+  /**
+   * Get all active spans
+   */
+  getActiveSpans(): TraceContext[];
+  /**
+   * Find a span by ID
+   */
+  findSpanById(spanId: string): TraceContext | undefined;
+  /**
+   * Generate a unique trace ID
+   */
+  private generateTraceId;
+  /**
+   * Generate a unique span ID
+   */
+  private generateSpanId;
+}
+//#endregion
+export { Tracer };

package/dist/tracer.d.mts

@@ -0,0 +1,2 @@
+import { Tracer } from "./tracer.node.mjs";
+export { Tracer };

package/dist/tracer.node.d.mts

@@ -0,0 +1,50 @@
+import { TraceContext, TracingOptions } from "./types.mjs";
+
+//#region src/tracer.node.d.ts
+declare class Tracer {
+  private context;
+  private activeSpans;
+  constructor();
+  /**
+   * Start a new trace span
+   */
+  startSpan(options: TracingOptions): TraceContext;
+  /**
+   * Finish a trace span
+   */
+  finishSpan(spanId: string): number | undefined;
+  /**
+   * Execute a function within a trace span
+   */
+  trace<T>(options: TracingOptions, fn: () => T | Promise<T>): Promise<T>;
+  /**
+   * Add metadata to current span
+   */
+  addMetadata(key: string, value: unknown): void;
+  /**
+   * Add tags to current span
+   */
+  addTags(...tags: string[]): void;
+  /**
+   * Get current trace context
+   */
+  getCurrentTrace(): TraceContext | undefined;
+  /**
+   * Get all active spans
+   */
+  getActiveSpans(): TraceContext[];
+  /**
+   * Find a span by ID
+   */
+  findSpanById(spanId: string): TraceContext | undefined;
+  /**
+   * Generate a unique trace ID
+   */
+  private generateTraceId;
+  /**
+   * Generate a unique span ID
+   */
+  private generateSpanId;
+}
+//#endregion
+export { Tracer };

package/dist/types.d.mts

@@ -0,0 +1,70 @@
+//#region src/types.d.ts
+declare enum LogLevel {
+  TRACE = 0,
+  DEBUG = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4,
+  FATAL = 5,
+}
+interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: Date;
+  traceId?: string;
+  parentId?: string;
+  spanId?: string;
+  context?: Record<string, any>;
+  metadata?: Record<string, any>;
+  duration?: number;
+  error?: Error;
+  tags?: string[];
+}
+interface TraceContext {
+  traceId: string;
+  parentId?: string;
+  spanId: string;
+  operationType: string;
+  operationName: string;
+  startTime: number;
+  metadata: Record<string, any>;
+  tags: string[];
+}
+interface TracingOptions {
+  operationType: 'http' | 'websocket' | 'cron' | 'queue' | 'database' | 'custom';
+  operationName: string;
+  metadata?: Record<string, any>;
+  tags?: string[];
+  autoTiming?: boolean;
+}
+interface LoggerConfig {
+  level: LogLevel;
+  environment: 'development' | 'production' | 'test';
+  enableTracing: boolean;
+  enableTiming: boolean;
+  enableContext: boolean;
+  enableColors: boolean;
+  maxContextDepth: number;
+  timestampFormat: 'iso' | 'epoch' | 'relative';
+}
+interface Formatter {
+  format(entry: LogEntry): string;
+}
+interface Timer {
+  readonly id: string;
+  stop(): number;
+  lap(label?: string): number;
+  getElapsed(): number;
+}
+interface ContextData {
+  [key: string]: any;
+  userId?: string;
+  requestId?: string;
+  sessionId?: string;
+  ip?: string;
+  userAgent?: string;
+}
+type LogMethod = (message: string, metadata?: Record<string, any>) => void;
+type TraceMethod = <T>(options: TracingOptions, fn: () => T | Promise<T>) => Promise<T>;
+//#endregion
+export { ContextData, Formatter, LogEntry, LogLevel, LogMethod, LoggerConfig, Timer, TraceContext, TraceMethod, TracingOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.logger",
-  "version": "0.0.0-canary-20251217054315",
+  "version": "0.0.0-canary-20251217060804",
   "description": "Comprehensive logging library optimized for Bun with ElysiaJS integration",
   "keywords": [
     "logging",
@@ -23,8 +23,8 @@
     "dev": "bun build:bundle --watch"
   },
   "devDependencies": {
-    "@lssm/tool.typescript": "0.0.0-canary-20251217054315",
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217054315",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217060804",
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217060804",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },
@@ -46,21 +46,21 @@
     "README.md"
   ],
   "exports": {
-    ".": "./src/index.ts",
-    "./context": "./src/context.ts",
-    "./context.browser": "./src/context.browser.ts",
-    "./context.node": "./src/context.node.ts",
-    "./elysia-plugin": "./src/elysia-plugin.ts",
-    "./formatters": "./src/formatters.ts",
-    "./index.browser": "./src/index.browser.ts",
-    "./logger": "./src/logger.ts",
-    "./logger.browser": "./src/logger.browser.ts",
-    "./logger.node": "./src/logger.node.ts",
-    "./timer": "./src/timer.ts",
-    "./tracer": "./src/tracer.ts",
-    "./tracer.browser": "./src/tracer.browser.ts",
-    "./tracer.node": "./src/tracer.node.ts",
-    "./types": "./src/types.ts",
+    ".": "./dist/index.mjs",
+    "./context": "./dist/context.mjs",
+    "./context.browser": "./dist/context.browser.mjs",
+    "./context.node": "./dist/context.node.mjs",
+    "./elysia-plugin": "./dist/elysia-plugin.mjs",
+    "./formatters": "./dist/formatters.mjs",
+    "./index.browser": "./dist/index.browser.mjs",
+    "./logger": "./dist/logger.mjs",
+    "./logger.browser": "./dist/logger.browser.mjs",
+    "./logger.node": "./dist/logger.node.mjs",
+    "./timer": "./dist/timer.mjs",
+    "./tracer": "./dist/tracer.mjs",
+    "./tracer.browser": "./dist/tracer.browser.mjs",
+    "./tracer.node": "./dist/tracer.node.mjs",
+    "./types": "./dist/types.mjs",
     "./*": "./*"
   },
   "module": "./dist/index.mjs",