voltlog-io 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,71 +1,9 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  LogLevel: () => LogLevel,
-  LogLevelNameMap: () => LogLevelNameMap,
-  LogLevelValueMap: () => LogLevelValueMap,
-  aiEnrichmentMiddleware: () => aiEnrichmentMiddleware,
-  alertMiddleware: () => alertMiddleware,
-  batchTransport: () => batchTransport,
-  browserJsonStreamTransport: () => browserJsonStreamTransport,
-  consoleTransport: () => consoleTransport,
-  correlationIdMiddleware: () => correlationIdMiddleware,
-  createLogger: () => createLogger,
-  createMiddleware: () => createMiddleware,
-  createOpenAiErrorAnalyzer: () => createOpenAiErrorAnalyzer,
-  createTransport: () => createTransport,
-  datadogTransport: () => datadogTransport,
-  deduplicationMiddleware: () => deduplicationMiddleware,
-  discordTransport: () => discordTransport,
-  fileTransport: () => fileTransport,
-  heapUsageMiddleware: () => heapUsageMiddleware,
-  ipMiddleware: () => ipMiddleware,
-  jsonStreamTransport: () => jsonStreamTransport,
-  levelOverrideMiddleware: () => levelOverrideMiddleware,
-  lokiTransport: () => lokiTransport,
-  ocppMiddleware: () => ocppMiddleware,
-  prettyTransport: () => prettyTransport,
-  redactionMiddleware: () => redactionMiddleware,
-  redisTransport: () => redisTransport,
-  resolveLevel: () => resolveLevel,
-  samplingMiddleware: () => samplingMiddleware,
-  sentryTransport: () => sentryTransport,
-  shouldIncludeStack: () => shouldIncludeStack,
-  shouldLog: () => shouldLog,
-  slackTransport: () => slackTransport,
-  userAgentMiddleware: () => userAgentMiddleware,
-  webhookTransport: () => webhookTransport
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
 });
-module.exports = __toCommonJS(src_exports);
 
 // src/core/types.ts
 var LogLevel = {
@@ -98,7 +36,7 @@ function shouldIncludeStack(entryLevel, includeStack) {
 }
 
 // src/core/logger.ts
-var import_cuid2 = require("@paralleldrive/cuid2");
+var _crypto = require('crypto');
 
 // src/core/pipeline.ts
 function composeMiddleware(middleware, final) {
@@ -126,43 +64,50 @@ function fanOutToTransports(entry, transports, loggerLevel) {
         result.catch(() => {
         });
       }
-    } catch {
+    } catch (e2) {
     }
   }
 }
 
 // src/core/logger.ts
 var LoggerImpl = class {
-  _level;
-  _transports;
-  _middlewareList;
-  _pipeline;
-  _context;
-  _includeStack;
-  _timestampFn;
+  
+  
+  
+  
+  
+  
+  
+  
   constructor(options = {}) {
-    this._level = resolveLevel(options.level ?? "INFO");
-    this._transports = [...options.transports ?? []];
-    this._middlewareList = [...options.middleware ?? []];
+    this._level = resolveLevel(_nullishCoalesce(options.level, () => ( "INFO")));
+    this._transports = [..._nullishCoalesce(options.transports, () => ( []))];
+    this._middlewareList = [..._nullishCoalesce(options.middleware, () => ( []))];
     this._context = options.context ? { ...options.context } : {};
-    this._includeStack = options.includeStack ?? "ERROR";
-    this._timestampFn = options.timestamp ?? Date.now;
+    this._includeStack = _nullishCoalesce(options.includeStack, () => ( "ERROR"));
+    this._timestampFn = _nullishCoalesce(options.timestamp, () => ( Date.now));
+    this._idFn = options.idGenerator !== void 0 ? options.idGenerator : _crypto.randomUUID;
     this._pipeline = this._buildPipeline();
   }
   // ─── Log Methods ────────────────────────────────────────────
   trace(message, meta) {
+    if (10 < this._level) return;
     this._log(10, "TRACE", message, meta);
   }
   debug(message, meta) {
+    if (20 < this._level) return;
     this._log(20, "DEBUG", message, meta);
   }
   info(message, meta) {
+    if (30 < this._level) return;
     this._log(30, "INFO", message, meta);
   }
   warn(message, meta) {
+    if (40 < this._level) return;
     this._log(40, "WARN", message, meta);
   }
   error(message, metaOrError, error) {
+    if (50 < this._level) return;
     if (metaOrError instanceof Error) {
       this._log(50, "ERROR", message, void 0, metaOrError);
     } else {
@@ -191,13 +136,41 @@ var LoggerImpl = class {
     this._middlewareList.push(middleware);
     this._pipeline = this._buildPipeline();
   }
+  removeMiddleware(middleware) {
+    this._middlewareList = this._middlewareList.filter((m) => m !== middleware);
+    this._pipeline = this._buildPipeline();
+  }
+  // ─── Level Control ─────────────────────────────────────────
+  setLevel(level) {
+    this._level = resolveLevel(level);
+  }
+  getLevel() {
+    return _nullishCoalesce(LogLevelValueMap[this._level], () => ( "INFO"));
+  }
+  isLevelEnabled(level) {
+    return resolveLevel(level) >= this._level;
+  }
+  // ─── Timer ─────────────────────────────────────────────────
+  startTimer(level) {
+    const start = performance.now();
+    const logLevel = _nullishCoalesce(level, () => ( "INFO"));
+    return {
+      done: (message, meta) => {
+        const durationMs = Math.round(performance.now() - start);
+        const merged = { ...meta, durationMs };
+        const methodKey = logLevel.toLowerCase();
+        this[methodKey](message, merged);
+      },
+      elapsed: () => Math.round(performance.now() - start)
+    };
+  }
   // ─── Lifecycle ──────────────────────────────────────────────
   async flush() {
-    await Promise.all(this._transports.map((t) => t.flush?.()).filter(Boolean));
+    await Promise.all(this._transports.map((t) => _optionalChain([t, 'access', _2 => _2.flush, 'optionalCall', _3 => _3()])).filter(Boolean));
   }
   async close() {
     await this.flush();
-    await Promise.all(this._transports.map((t) => t.close?.()).filter(Boolean));
+    await Promise.all(this._transports.map((t) => _optionalChain([t, 'access', _4 => _4.close, 'optionalCall', _5 => _5()])).filter(Boolean));
   }
   // ─── Internal ───────────────────────────────────────────────
   /** @internal */
@@ -208,24 +181,19 @@ var LoggerImpl = class {
   _logWithContext(level, levelName, message, context, meta, error) {
     if (!shouldLog(level, this._level)) return;
     const entry = {
-      id: (0, import_cuid2.createId)(),
+      id: this._idFn ? this._idFn() : "",
       level,
       levelName,
       message,
       timestamp: this._timestampFn(),
-      meta: meta ?? {},
+      meta: _nullishCoalesce(meta, () => ( {})),
       context: Object.keys(context).length > 0 ? context : void 0
     };
     if (error) {
-      const logError = {
-        message: error.message,
-        name: error.name,
-        code: error.code
-      };
-      if (shouldIncludeStack(level, this._includeStack)) {
-        logError.stack = error.stack;
-      }
-      entry.error = logError;
+      entry.error = serializeError(
+        error,
+        shouldIncludeStack(level, this._includeStack)
+      );
     }
     this._pipeline(entry);
   }
@@ -235,6 +203,20 @@ var LoggerImpl = class {
     });
   }
 };
+function serializeError(error, includeStack, depth = 0) {
+  const logError = {
+    message: error.message,
+    name: error.name,
+    code: error.code
+  };
+  if (includeStack) {
+    logError.stack = error.stack;
+  }
+  if (error.cause instanceof Error && depth < 5) {
+    logError.cause = serializeError(error.cause, includeStack, depth + 1);
+  }
+  return logError;
+}
 var ChildLoggerImpl = class _ChildLoggerImpl {
   constructor(_parent, _context) {
     this._parent = _parent;
@@ -309,6 +291,21 @@ var ChildLoggerImpl = class _ChildLoggerImpl {
   addMiddleware(middleware) {
     this._parent.addMiddleware(middleware);
   }
+  removeMiddleware(middleware) {
+    this._parent.removeMiddleware(middleware);
+  }
+  setLevel(level) {
+    this._parent.setLevel(level);
+  }
+  getLevel() {
+    return this._parent.getLevel();
+  }
+  isLevelEnabled(level) {
+    return this._parent.isLevelEnabled(level);
+  }
+  startTimer(level) {
+    return this._parent.startTimer(level);
+  }
   flush() {
     return this._parent.flush();
   }
@@ -322,10 +319,10 @@ function createLogger(options) {
 
 // src/middleware/ai-enrichment.ts
 function aiEnrichmentMiddleware(options) {
-  const minLevel = resolveLevel(options.level ?? "ERROR");
-  const timeoutMs = options.timeout ?? 2e3;
-  const swallow = options.swallowErrors ?? true;
-  const fieldName = options.targetField ?? "ai_analysis";
+  const minLevel = resolveLevel(_nullishCoalesce(options.level, () => ( "ERROR")));
+  const timeoutMs = _nullishCoalesce(options.timeout, () => ( 2e3));
+  const swallow = _nullishCoalesce(options.swallowErrors, () => ( true));
+  const fieldName = _nullishCoalesce(options.targetField, () => ( "ai_analysis"));
   return async (entry, next) => {
     if (entry.level < minLevel) {
       next(entry);
@@ -378,8 +375,8 @@ Context: ${JSON.stringify(entry.meta)}`
       );
       if (!response.ok) return null;
       const data = await response.json();
-      return data.choices?.[0]?.message?.content ?? null;
-    } catch {
+      return _nullishCoalesce(_optionalChain([data, 'access', _6 => _6.choices, 'optionalAccess', _7 => _7[0], 'optionalAccess', _8 => _8.message, 'optionalAccess', _9 => _9.content]), () => ( null));
+    } catch (e3) {
       return null;
     }
   };
@@ -396,9 +393,9 @@ function alertMiddleware(rules) {
     for (const rule of rules) {
       if (!rule.when(entry)) continue;
       const state = states.get(rule.name);
-      const windowMs = rule.windowMs ?? Infinity;
-      const threshold = rule.threshold ?? 1;
-      const cooldownMs = rule.cooldownMs ?? 0;
+      const windowMs = _nullishCoalesce(rule.windowMs, () => ( Infinity));
+      const threshold = _nullishCoalesce(rule.threshold, () => ( 1));
+      const cooldownMs = _nullishCoalesce(rule.cooldownMs, () => ( 0));
       if (Number.isFinite(windowMs)) {
         state.entries = state.entries.filter(
           (e) => now - e.timestamp < windowMs
@@ -415,7 +412,7 @@ function alertMiddleware(rules) {
             result.catch(() => {
             });
           }
-        } catch {
+        } catch (e4) {
         }
       }
     }
@@ -423,11 +420,49 @@ function alertMiddleware(rules) {
   };
 }
 
+// src/middleware/async-context.ts
+var _async_hooks = require('async_hooks');
+function asyncContextMiddleware() {
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  const middleware = (entry, next) => {
+    const ctx = storage.getStore();
+    if (ctx) {
+      const meta = entry.meta;
+      for (const [key, value] of Object.entries(ctx)) {
+        if (!(key in meta)) {
+          meta[key] = value;
+        }
+      }
+      if (ctx.requestId && !entry.correlationId) {
+        entry.correlationId = String(ctx.requestId);
+      }
+    }
+    next(entry);
+  };
+  return {
+    middleware,
+    runInContext(context, fn) {
+      const parentCtx = storage.getStore();
+      const mergedCtx = parentCtx ? { ...parentCtx, ...context } : { ...context };
+      storage.run(mergedCtx, fn);
+    },
+    getContext() {
+      return storage.getStore();
+    },
+    updateContext(updates) {
+      const ctx = storage.getStore();
+      if (ctx) {
+        Object.assign(ctx, updates);
+      }
+    }
+  };
+}
+
 // src/middleware/correlation-id.ts
-var import_cuid22 = require("@paralleldrive/cuid2");
+
 function correlationIdMiddleware(options = {}) {
-  const header = options.header ?? "x-correlation-id";
-  const generate = options.generator ?? import_cuid22.createId;
+  const header = _nullishCoalesce(options.header, () => ( "x-correlation-id"));
+  const generate = _nullishCoalesce(options.generator, () => ( _crypto.randomUUID));
   return (entry, next) => {
     if (entry.correlationId) {
       return next(entry);
@@ -452,8 +487,8 @@ function createMiddleware(fn) {
 
 // src/middleware/deduplication.ts
 function deduplicationMiddleware(options = {}) {
-  const windowMs = options.windowMs ?? 1e3;
-  const keyFn = options.keyFn ?? ((e) => `${e.level}:${e.message}:${e.error?.message ?? ""}`);
+  const windowMs = _nullishCoalesce(options.windowMs, () => ( 1e3));
+  const keyFn = _nullishCoalesce(options.keyFn, () => ( ((e) => `${e.level}:${e.message}:${_nullishCoalesce(_optionalChain([e, 'access', _10 => _10.error, 'optionalAccess', _11 => _11.message]), () => ( ""))}`)));
   const buffer = /* @__PURE__ */ new Map();
   return (entry, next) => {
     const key = keyFn(entry);
@@ -485,7 +520,7 @@ function deduplicationMiddleware(options = {}) {
 
 // src/middleware/heap-usage.ts
 function heapUsageMiddleware(options = {}) {
-  const fieldName = options.fieldName ?? "memory";
+  const fieldName = _nullishCoalesce(options.fieldName, () => ( "memory"));
   return (entry, next) => {
     if (typeof process !== "undefined" && process.memoryUsage) {
       const memory = process.memoryUsage();
@@ -502,16 +537,81 @@ function heapUsageMiddleware(options = {}) {
   };
 }
 
+// src/middleware/http.ts
+var nodeHttpMappers = {
+  req: {
+    getMethod: (req) => req.method || "UNKNOWN",
+    getUrl: (req) => req.originalUrl || req.url || "/",
+    getIp: (req) => req.ip || _optionalChain([req, 'access', _12 => _12.socket, 'optionalAccess', _13 => _13.remoteAddress]) || _optionalChain([req, 'access', _14 => _14.headers, 'optionalAccess', _15 => _15["x-forwarded-for"]]) || void 0,
+    getUserAgent: (req) => _optionalChain([req, 'access', _16 => _16.headers, 'optionalAccess', _17 => _17["user-agent"]]) || void 0,
+    getHeader: (req, name) => _optionalChain([req, 'access', _18 => _18.headers, 'optionalAccess', _19 => _19[name]]) || void 0
+  },
+  res: {
+    getStatusCode: (res) => res.statusCode || 200,
+    onFinish: (res, callback) => {
+      if (typeof res.on === "function") {
+        res.on("finish", callback);
+        res.on("close", callback);
+      } else {
+        callback();
+      }
+    }
+  }
+};
+function createHttpLogger(logger, options) {
+  const {
+    reqMapper,
+    resMapper,
+    level = "INFO",
+    skip,
+    extractContext
+  } = options;
+  return (req, res) => {
+    if (_optionalChain([skip, 'optionalCall', _20 => _20(req)])) {
+      return;
+    }
+    const startTime = performance.now();
+    let finished = false;
+    resMapper.onFinish(res, () => {
+      if (finished) return;
+      finished = true;
+      const durationMs = Math.round(performance.now() - startTime);
+      const statusCode = resMapper.getStatusCode(res);
+      const method = reqMapper.getMethod(req);
+      const url = reqMapper.getUrl(req);
+      const meta = {
+        method,
+        url,
+        statusCode,
+        durationMs,
+        ip: reqMapper.getIp ? reqMapper.getIp(req) : void 0,
+        userAgent: reqMapper.getUserAgent ? reqMapper.getUserAgent(req) : void 0
+      };
+      if (extractContext) {
+        Object.assign(meta, extractContext(req, res));
+      }
+      let finalLevel = level;
+      if (statusCode >= 500) finalLevel = "ERROR";
+      else if (statusCode >= 400 && level === "INFO") finalLevel = "WARN";
+      const methodKey = finalLevel.toLowerCase();
+      logger[methodKey](
+        `${method} ${url} - ${statusCode} (${durationMs}ms)`,
+        meta
+      );
+    });
+  };
+}
+
 // src/middleware/ip.ts
 function ipMiddleware(options = {}) {
-  const targetField = options.fieldName ?? "ip";
-  const keysToCheck = options.headerKeys ?? [
+  const targetField = _nullishCoalesce(options.fieldName, () => ( "ip"));
+  const keysToCheck = _nullishCoalesce(options.headerKeys, () => ( [
     "x-forwarded-for",
     "x-real-ip",
     "req.ip",
     "ip",
     "x-client-ip"
-  ];
+  ]));
   return (entry, next) => {
     const meta = entry.meta;
     const headers = meta.headers || {};
@@ -548,12 +648,12 @@ function ipMiddleware(options = {}) {
 
 // src/middleware/level-override.ts
 function levelOverrideMiddleware(options = {}) {
-  const key = options.key ?? "x-log-level";
-  const cleanup = options.cleanup ?? true;
+  const key = _nullishCoalesce(options.key, () => ( "x-log-level"));
+  const cleanup = _nullishCoalesce(options.cleanup, () => ( true));
   return (entry, next) => {
     const meta = entry.meta;
     const context = entry.context;
-    const levelName = meta[key] || context?.[key] || meta.headers?.[key];
+    const levelName = meta[key] || _optionalChain([context, 'optionalAccess', _21 => _21[key]]) || _optionalChain([meta, 'access', _22 => _22.headers, 'optionalAccess', _23 => _23[key]]);
     if (levelName && typeof levelName === "string") {
       const upperName = levelName.toUpperCase();
       if (LogLevel[upperName]) {
@@ -573,14 +673,14 @@ function levelOverrideMiddleware(options = {}) {
 
 // src/middleware/ocpp.ts
 function ocppMiddleware(options = {}) {
-  const autoPayloadSize = options.autoPayloadSize ?? true;
-  const propagateCorrelationId = options.propagateCorrelationId ?? true;
+  const autoPayloadSize = _nullishCoalesce(options.autoPayloadSize, () => ( true));
+  const propagateCorrelationId = _nullishCoalesce(options.propagateCorrelationId, () => ( true));
   return (entry, next) => {
     const enriched = { ...entry, meta: { ...entry.meta } };
     if (autoPayloadSize && enriched.meta.payloadSize === void 0 && enriched.meta.action) {
       try {
         enriched.meta.payloadSize = JSON.stringify(enriched.meta).length;
-      } catch {
+      } catch (e5) {
       }
     }
     if (propagateCorrelationId && enriched.meta.correlationId && !enriched.correlationId) {
@@ -590,12 +690,49 @@ function ocppMiddleware(options = {}) {
   };
 }
 
+// src/middleware/otel-trace.ts
+function otelTraceMiddleware(options = {}) {
+  let traceApi = _nullishCoalesce(options.traceApi, () => ( null));
+  let resolved = !!traceApi;
+  if (!resolved) {
+    try {
+      const { createRequire } = __require("module");
+      const dynamicRequire = createRequire(__filename);
+      const api = dynamicRequire("@opentelemetry/api");
+      traceApi = api;
+      resolved = true;
+    } catch (e6) {
+    }
+  }
+  return (entry, next) => {
+    if (resolved && _optionalChain([traceApi, 'optionalAccess', _24 => _24.trace])) {
+      try {
+        const activeSpan = _optionalChain([traceApi, 'access', _25 => _25.trace, 'access', _26 => _26.getActiveSpan, 'optionalCall', _27 => _27()]);
+        if (activeSpan) {
+          const spanContext = _optionalChain([activeSpan, 'access', _28 => _28.spanContext, 'optionalCall', _29 => _29()]);
+          if (spanContext) {
+            const meta = entry.meta;
+            meta.traceId = spanContext.traceId;
+            meta.spanId = spanContext.spanId;
+            meta.traceFlags = spanContext.traceFlags;
+            if (!entry.correlationId) {
+              entry.correlationId = spanContext.traceId;
+            }
+          }
+        }
+      } catch (e7) {
+      }
+    }
+    next(entry);
+  };
+}
+
 // src/middleware/redaction.ts
 var DEFAULT_REDACT_VALUE = "[REDACTED]";
 function redactionMiddleware(options) {
   const paths = new Set(options.paths.map((p) => p.toLowerCase()));
-  const replacement = options.replacement ?? DEFAULT_REDACT_VALUE;
-  const deep = options.deep ?? true;
+  const replacement = _nullishCoalesce(options.replacement, () => ( DEFAULT_REDACT_VALUE));
+  const deep = _nullishCoalesce(options.deep, () => ( true));
   function redactObject(obj) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
@@ -625,11 +762,11 @@ function redactionMiddleware(options) {
 
 // src/middleware/sampling.ts
 function samplingMiddleware(options = {}) {
-  const keyFn = options.keyFn ?? ((entry) => entry.message);
-  const maxPerWindow = options.maxPerWindow ?? 100;
-  const windowMs = options.windowMs ?? 6e4;
-  const sampleRate = options.sampleRate ?? 1;
-  const priorityLevel = options.priorityLevel ?? 40;
+  const keyFn = _nullishCoalesce(options.keyFn, () => ( ((entry) => entry.message)));
+  const maxPerWindow = _nullishCoalesce(options.maxPerWindow, () => ( 100));
+  const windowMs = _nullishCoalesce(options.windowMs, () => ( 6e4));
+  const sampleRate = _nullishCoalesce(options.sampleRate, () => ( 1));
+  const priorityLevel = _nullishCoalesce(options.priorityLevel, () => ( 40));
   const buckets = /* @__PURE__ */ new Map();
   return (entry, next) => {
     if (entry.level >= priorityLevel) {
@@ -663,11 +800,11 @@ function samplingMiddleware(options = {}) {
 // src/middleware/user-agent.ts
 function userAgentMiddleware(options = {}) {
   const sourceField = options.sourceField;
-  const targetField = options.targetField ?? "client";
+  const targetField = _nullishCoalesce(options.targetField, () => ( "client"));
   return (entry, next) => {
     const meta = entry.meta;
     const context = entry.context;
-    const ua = (sourceField ? meta[sourceField] : void 0) || meta.userAgent || meta["user-agent"] || context?.userAgent || context?.["user-agent"];
+    const ua = (sourceField ? meta[sourceField] : void 0) || meta.userAgent || meta["user-agent"] || _optionalChain([context, 'optionalAccess', _30 => _30.userAgent]) || _optionalChain([context, 'optionalAccess', _31 => _31["user-agent"]]);
     if (ua) {
       const info = parseUserAgent(ua);
       entry.meta = {
@@ -700,8 +837,8 @@ function parseUserAgent(ua) {
 
 // src/transports/batch.ts
 function batchTransport(inner, options = {}) {
-  const batchSize = options.batchSize ?? 100;
-  const flushIntervalMs = options.flushIntervalMs ?? 5e3;
+  const batchSize = _nullishCoalesce(options.batchSize, () => ( 100));
+  const flushIntervalMs = _nullishCoalesce(options.flushIntervalMs, () => ( 5e3));
   let buffer = [];
   let flushTimer = null;
   function scheduleFlush() {
@@ -722,7 +859,7 @@ function batchTransport(inner, options = {}) {
           result.catch(() => {
           });
         }
-      } catch {
+      } catch (e8) {
       }
     }
   }
@@ -743,11 +880,11 @@ function batchTransport(inner, options = {}) {
         flushTimer = null;
       }
       doFlush();
-      await inner.flush?.();
+      await _optionalChain([inner, 'access', _32 => _32.flush, 'optionalCall', _33 => _33()]);
     },
     async close() {
-      await this.flush?.();
-      await inner.close?.();
+      await _optionalChain([this, 'access', _34 => _34.flush, 'optionalCall', _35 => _35()]);
+      await _optionalChain([inner, 'access', _36 => _36.close, 'optionalCall', _37 => _37()]);
     }
   };
 }
@@ -756,8 +893,8 @@ function batchTransport(inner, options = {}) {
 function browserJsonStreamTransport(options) {
   const stream = options.stream;
   const writer = stream.getWriter();
-  const serialize = options.serializer ?? ((entry) => `${JSON.stringify(entry)}
-`);
+  const serialize = _nullishCoalesce(options.serializer, () => ( ((entry) => `${JSON.stringify(entry)}
+`)));
   return {
     name: "browser-stream",
     level: options.level,
@@ -781,8 +918,8 @@ function browserJsonStreamTransport(options) {
 
 // src/transports/console.ts
 function consoleTransport(options = {}) {
-  const useConsoleLevels = options.useConsoleLevels ?? true;
-  const formatter = options.formatter ?? ((entry) => JSON.stringify(entry));
+  const useConsoleLevels = _nullishCoalesce(options.useConsoleLevels, () => ( true));
+  const formatter = _nullishCoalesce(options.formatter, () => ( ((entry) => JSON.stringify(entry))));
   return {
     name: "console",
     level: options.level,
@@ -902,7 +1039,7 @@ ${JSON.stringify(entry.meta, null, 2).slice(
             )}
 \`\`\``
           },
-          entry.error?.stack ? {
+          _optionalChain([entry, 'access', _38 => _38.error, 'optionalAccess', _39 => _39.stack]) ? {
             name: "Stack",
             value: `\`\`\`js
 ${entry.error.stack.slice(0, 1e3)}
@@ -921,35 +1058,61 @@ function getLevelColor(level) {
 }
 
 // src/transports/file.ts
-var import_node_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("path"));
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 function fileTransport(options) {
-  const { dir, level } = options;
-  const filenamePattern = options.filename ?? "app-%DATE%.log";
+  const { dir, level, maxSize } = options;
+  const filenamePattern = _nullishCoalesce(options.filename, () => ( "app-%DATE%.log"));
   let currentStream = null;
   let currentPath = "";
+  let currentSize = 0;
+  let rotationIndex = 0;
+  let cachedDate = "";
+  let cacheExpiry = 0;
+  function getCachedDate() {
+    const now = Date.now();
+    if (now >= cacheExpiry) {
+      cachedDate = new Date(now).toISOString().split("T")[0];
+      cacheExpiry = now + 1e3;
+    }
+    return cachedDate;
+  }
   try {
-    import_node_fs.default.mkdirSync(dir, { recursive: true });
+    _fs2.default.mkdirSync(dir, { recursive: true });
   } catch (err) {
     console.error(`[voltlog] Failed to create log directory: ${dir}`, err);
   }
-  function getPath() {
-    const now = /* @__PURE__ */ new Date();
-    const dateStr = now.toISOString().split("T")[0];
+  function getPath(sizeRotation = false) {
+    const dateStr = getCachedDate();
     const filename = filenamePattern.replace("%DATE%", dateStr);
-    return import_node_path.default.join(dir, filename);
+    if (sizeRotation && rotationIndex > 0) {
+      const ext = _path2.default.extname(filename);
+      const base = filename.slice(0, -ext.length || void 0);
+      return _path2.default.join(dir, `${base}.${rotationIndex}${ext}`);
+    }
+    return _path2.default.join(dir, filename);
+  }
+  function openStream(filePath) {
+    if (currentStream) {
+      currentStream.end();
+    }
+    currentPath = filePath;
+    currentSize = 0;
+    currentStream = _fs2.default.createWriteStream(filePath, { flags: "a" });
+    try {
+      const stat = _fs2.default.statSync(filePath);
+      currentSize = stat.size;
+    } catch (e9) {
+    }
+    currentStream.on("error", (err) => {
+      console.error(`[voltlog] File write error to ${filePath}:`, err);
+    });
   }
   function rotate() {
     const newPath = getPath();
     if (newPath !== currentPath) {
-      if (currentStream) {
-        currentStream.end();
-      }
-      currentPath = newPath;
-      currentStream = import_node_fs.default.createWriteStream(newPath, { flags: "a" });
-      currentStream.on("error", (err) => {
-        console.error(`[voltlog] File write error to ${newPath}:`, err);
-      });
+      rotationIndex = 0;
+      openStream(newPath);
     }
   }
   rotate();
@@ -958,10 +1121,15 @@ function fileTransport(options) {
     level,
     write(entry) {
       rotate();
-      if (currentStream && !currentStream.writableEnded) {
-        const line = `${JSON.stringify(entry)}
+      const line = `${JSON.stringify(entry)}
 `;
+      if (maxSize && currentSize + line.length > maxSize) {
+        rotationIndex++;
+        openStream(getPath(true));
+      }
+      if (currentStream && !currentStream.writableEnded) {
         currentStream.write(line);
+        currentSize += line.length;
       }
     },
     async flush() {
@@ -969,7 +1137,7 @@ function fileTransport(options) {
     async close() {
       if (currentStream) {
         return new Promise((resolve) => {
-          currentStream?.end(() => resolve());
+          _optionalChain([currentStream, 'optionalAccess', _40 => _40.end, 'call', _41 => _41(() => resolve())]);
         });
       }
     }
@@ -979,8 +1147,8 @@ function fileTransport(options) {
 // src/transports/json-stream.ts
 function jsonStreamTransport(options) {
   const stream = options.stream;
-  const serialize = options.serializer ?? ((entry) => `${JSON.stringify(entry)}
-`);
+  const serialize = _nullishCoalesce(options.serializer, () => ( ((entry) => `${JSON.stringify(entry)}
+`)));
   return {
     name: "json-stream",
     level: options.level,
@@ -1002,9 +1170,13 @@ function jsonStreamTransport(options) {
 
 // src/transports/loki.ts
 function lokiTransport(options) {
-  const { host, labels = { app: "voltlog" }, level } = options;
-  const batchSize = options.batchSize ?? 10;
-  const interval = options.interval ?? 5e3;
+  const { host, level } = options;
+  const staticLabels = _nullishCoalesce(options.labels, () => ( { app: "voltlog" }));
+  const batchSize = _nullishCoalesce(options.batchSize, () => ( 10));
+  const interval = _nullishCoalesce(options.interval, () => ( 5e3));
+  const includeMetadata = options.includeMetadata !== false;
+  const retryEnabled = _nullishCoalesce(options.retry, () => ( false));
+  const maxRetries = _nullishCoalesce(options.maxRetries, () => ( 3));
   const url = `${host.replace(/\/$/, "")}/loki/api/v1/push`;
   const headers = {
     "Content-Type": "application/json"
@@ -1018,44 +1190,256 @@ function lokiTransport(options) {
   }
   let buffer = [];
   let timer = null;
-  const flush = async () => {
+  function buildLogLine(entry) {
+    const payload = {
+      level: entry.levelName,
+      message: entry.message,
+      ...entry.meta
+    };
+    if (includeMetadata) {
+      if (entry.correlationId) {
+        payload.correlationId = entry.correlationId;
+      }
+      if (entry.context) {
+        payload.context = entry.context;
+      }
+      if (entry.error) {
+        payload.error = entry.error;
+      }
+    }
+    return JSON.stringify(payload);
+  }
+  function buildStreams(batch) {
+    if (!options.dynamicLabels) {
+      return [
+        {
+          stream: staticLabels,
+          values: batch.map((e) => [
+            String(e.timestamp * 1e6),
+            // Loki wants nanoseconds
+            buildLogLine(e)
+          ])
+        }
+      ];
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of batch) {
+      const dynamic = options.dynamicLabels(entry);
+      const merged = { ...staticLabels };
+      for (const [k, v] of Object.entries(dynamic)) {
+        if (v !== void 0) merged[k] = v;
+      }
+      const key = JSON.stringify(merged);
+      let group = grouped.get(key);
+      if (!group) {
+        group = { labels: merged, values: [] };
+        grouped.set(key, group);
+      }
+      group.values.push([
+        String(entry.timestamp * 1e6),
+        buildLogLine(entry)
+      ]);
+    }
+    return Array.from(grouped.values()).map((g) => ({
+      stream: g.labels,
+      values: g.values
+    }));
+  }
+  async function pushWithRetry(batch) {
+    const body = JSON.stringify({ streams: buildStreams(batch) });
+    let lastError;
+    const attempts = retryEnabled ? maxRetries : 1;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        const response = await fetch(url, { method: "POST", headers, body });
+        if (response.ok) return;
+        if (response.status >= 400 && response.status < 500) {
+          console.error(`[voltlog] Loki push failed: ${response.status}`);
+          return;
+        }
+        lastError = new Error(`Loki HTTP ${response.status}`);
+      } catch (err) {
+        lastError = err;
+      }
+      if (attempt < attempts - 1) {
+        await new Promise((r) => setTimeout(r, 100 * 2 ** attempt));
+      }
+    }
+    console.error("[voltlog] Loki push failed after retries", lastError);
+  }
+  const doFlush = async () => {
     if (buffer.length === 0) return;
     const batch = buffer;
     buffer = [];
-    const streams = [
-      {
-        stream: labels,
-        values: batch.map((e) => [
-          String(e.timestamp * 1e6),
-          // Loki wants nanoseconds
-          JSON.stringify({
-            level: e.levelName,
-            message: e.message,
-            ...e.meta
-          })
-        ])
+    await pushWithRetry(batch);
+  };
+  const schedule = () => {
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        doFlush();
+      }, interval);
+    }
+  };
+  return {
+    name: "loki",
+    level,
+    write(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        if (timer) clearTimeout(timer);
+        timer = null;
+        doFlush();
+      } else {
+        schedule();
+      }
+    },
+    async flush() {
+      if (timer) clearTimeout(timer);
+      await doFlush();
+    },
+    async close() {
+      await _optionalChain([this, 'access', _42 => _42.flush, 'optionalCall', _43 => _43()]);
+    }
+  };
+}
+
+// src/transports/otel.ts
+var OTEL_SEVERITY_MAP = {
+  TRACE: { number: 1, text: "TRACE" },
+  DEBUG: { number: 5, text: "DEBUG" },
+  INFO: { number: 9, text: "INFO" },
+  WARN: { number: 13, text: "WARN" },
+  ERROR: { number: 17, text: "ERROR" },
+  FATAL: { number: 21, text: "FATAL" }
+};
+function otelTransport(options) {
+  const { endpoint, serviceName, level, resource = {} } = options;
+  const batchSize = _nullishCoalesce(options.batchSize, () => ( 20));
+  const interval = _nullishCoalesce(options.interval, () => ( 5e3));
+  const url = `${endpoint.replace(/\/$/, "")}/v1/logs`;
+  const headers = {
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  const resourceAttributes = [
+    { key: "service.name", value: { stringValue: serviceName } },
+    ...Object.entries(resource).map(([key, val]) => ({
+      key,
+      value: { stringValue: val }
+    }))
+  ];
+  let buffer = [];
+  let timer = null;
+  function toOtlpLogRecord(entry) {
+    const severity = _nullishCoalesce(OTEL_SEVERITY_MAP[entry.levelName], () => ( OTEL_SEVERITY_MAP.INFO));
+    const attributes = [];
+    if (entry.meta && typeof entry.meta === "object") {
+      for (const [key, val] of Object.entries(entry.meta)) {
+        if (key === "traceId" || key === "spanId" || key === "traceFlags")
+          continue;
+        if (val !== void 0 && val !== null) {
+          attributes.push({
+            key,
+            value: typeof val === "number" ? { intValue: val } : { stringValue: String(val) }
+          });
+        }
+      }
+    }
+    if (entry.context) {
+      for (const [key, val] of Object.entries(entry.context)) {
+        if (val !== void 0 && val !== null) {
+          attributes.push({
+            key: `context.${key}`,
+            value: { stringValue: String(val) }
+          });
+        }
+      }
+    }
+    if (entry.error) {
+      attributes.push({
+        key: "error.message",
+        value: { stringValue: entry.error.message }
+      });
+      if (entry.error.name) {
+        attributes.push({
+          key: "error.type",
+          value: { stringValue: entry.error.name }
+        });
       }
-    ];
+      if (entry.error.stack) {
+        attributes.push({
+          key: "error.stack",
+          value: { stringValue: entry.error.stack }
+        });
+      }
+    }
+    const record = {
+      timeUnixNano: String(entry.timestamp * 1e6),
+      // ms → ns
+      severityNumber: _optionalChain([severity, 'optionalAccess', _44 => _44.number]),
+      severityText: _optionalChain([severity, 'optionalAccess', _45 => _45.text]),
+      body: { stringValue: entry.message },
+      attributes
+    };
+    const meta = entry.meta;
+    if (_optionalChain([meta, 'optionalAccess', _46 => _46.traceId])) {
+      record.traceId = meta.traceId;
+    }
+    if (_optionalChain([meta, 'optionalAccess', _47 => _47.spanId])) {
+      record.spanId = meta.spanId;
+    }
+    if (_optionalChain([meta, 'optionalAccess', _48 => _48.traceFlags]) !== void 0) {
+      record.flags = meta.traceFlags;
+    }
+    return record;
+  }
+  async function sendBatch(batch) {
+    const payload = {
+      resourceLogs: [
+        {
+          resource: { attributes: resourceAttributes },
+          scopeLogs: [
+            {
+              scope: { name: "voltlog-io" },
+              logRecords: batch.map(toOtlpLogRecord)
+            }
+          ]
+        }
+      ]
+    };
     try {
-      await fetch(url, {
+      const response = await fetch(url, {
         method: "POST",
         headers,
-        body: JSON.stringify({ streams })
+        body: JSON.stringify(payload)
       });
+      if (!response.ok) {
+        console.error(
+          `[voltlog] OTLP push failed: ${response.status} ${response.statusText}`
+        );
+      }
     } catch (err) {
-      console.error("[voltlog] Loki push failed", err);
+      console.error("[voltlog] OTLP push failed", err);
     }
-  };
-  const schedule = () => {
+  }
+  function flush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    sendBatch(batch).catch(() => {
+    });
+  }
+  function schedule() {
     if (!timer) {
       timer = setTimeout(() => {
         timer = null;
         flush();
       }, interval);
     }
-  };
+  }
   return {
-    name: "loki",
+    name: "otel",
     level,
     write(entry) {
       buffer.push(entry);
@@ -1069,10 +1453,14 @@ function lokiTransport(options) {
     },
     async flush() {
       if (timer) clearTimeout(timer);
-      await flush();
+      timer = null;
+      if (buffer.length === 0) return;
+      const batch = buffer;
+      buffer = [];
+      await sendBatch(batch);
     },
     async close() {
-      await this.flush?.();
+      await _optionalChain([this, 'access', _49 => _49.flush, 'optionalCall', _50 => _50()]);
     }
   };
 }
@@ -1113,27 +1501,29 @@ var DIRECTION_ARROWS = {
   OUT: "\u2190"
 };
 function prettyTransport(options = {}) {
-  const showTimestamps = options.timestamps ?? true;
-  const useColors = options.colors ?? true;
+  const showTimestamps = _nullishCoalesce(options.timestamps, () => ( true));
+  const useColors = _nullishCoalesce(options.colors, () => ( true));
+  const hideMeta = _nullishCoalesce(options.hideMeta, () => ( false));
+  const prettyMeta = _nullishCoalesce(options.prettyMeta, () => ( false));
   function colorize(text, color) {
     return useColors ? `${color}${text}${RESET}` : text;
   }
   function formatExchange(entry) {
     const meta = entry.meta;
     if (!meta || !meta.action || !meta.messageType) return null;
-    const icon = EXCHANGE_ICONS[meta.messageType] ?? "\u2022";
-    const arrow = DIRECTION_ARROWS[meta.direction ?? "IN"] ?? "\u2192";
-    const cpId = meta.chargePointId ?? "unknown";
+    const icon = _nullishCoalesce(EXCHANGE_ICONS[meta.messageType], () => ( "\u2022"));
+    const arrow = _nullishCoalesce(DIRECTION_ARROWS[_nullishCoalesce(meta.direction, () => ( "IN"))], () => ( "\u2192"));
+    const cpId = _nullishCoalesce(meta.chargePointId, () => ( "unknown"));
     const action = meta.action;
     const msgType = meta.messageType;
-    const dir = meta.direction ?? "";
+    const dir = _nullishCoalesce(meta.direction, () => ( ""));
     let line = `${icon} ${colorize(cpId, BOLD)}  ${arrow}  ${colorize(
       action,
       BOLD
     )}  [${dir}]  ${colorize(msgType, DIM)}`;
     if (meta.status || meta.latencyMs !== void 0) {
       const statusIcon = meta.messageType === "CALLERROR" ? "\u274C" : "\u2714";
-      const status = meta.status ?? "";
+      const status = _nullishCoalesce(meta.status, () => ( ""));
       const latency = meta.latencyMs !== void 0 ? `(${meta.latencyMs}ms)` : "";
       line += `
 ${statusIcon} ${status}  ${colorize(latency, DIM)}`;
@@ -1141,22 +1531,39 @@ ${statusIcon} ${status}  ${colorize(latency, DIM)}`;
     return line;
   }
   function formatStandard(entry) {
-    const icon = ICONS[entry.levelName] ?? "\u2022";
-    const levelColor = COLORS[entry.levelName] ?? "";
+    const icon = _nullishCoalesce(ICONS[entry.levelName], () => ( "\u2022"));
+    const levelColor = _nullishCoalesce(COLORS[entry.levelName], () => ( ""));
     const level = colorize(entry.levelName.padEnd(5), levelColor);
     const ts = showTimestamps ? `${colorize(new Date(entry.timestamp).toISOString(), DIM)}  ` : "";
     let line = `${icon} ${ts}${level}  ${entry.message}`;
     if (entry.context && Object.keys(entry.context).length > 0) {
-      line += `  ${colorize(JSON.stringify(entry.context), DIM)}`;
+      const kvStr = Object.entries(entry.context).map(
+        ([k, v]) => `${k}:${typeof v === "string" ? v : JSON.stringify(v)}`
+      ).join(" ");
+      line += `  ${colorize(kvStr, DIM)}`;
     }
-    if (entry.meta && Object.keys(entry.meta).length > 0) {
-      line += `  ${colorize(JSON.stringify(entry.meta), DIM)}`;
+    if (!hideMeta && entry.meta && Object.keys(entry.meta).length > 0) {
+      if (prettyMeta) {
+        const metaEntries = Object.entries(
+          entry.meta
+        );
+        const parts = metaEntries.map(([key, value]) => {
+          const valStr = typeof value === "string" ? value : JSON.stringify(value);
+          return `${colorize(`${key}:`, DIM)}${valStr}`;
+        });
+        line += `  ${parts.join(" ")}`;
+      } else {
+        const kvStr = Object.entries(entry.meta).map(
+          ([k, v]) => `${k}:${typeof v === "string" ? v : JSON.stringify(v)}`
+        ).join(" ");
+        line += `  ${colorize(kvStr, DIM)}`;
+      }
     }
     if (entry.error) {
       line += `
   ${colorize(
-        `${entry.error.name ?? "Error"}: ${entry.error.message}`,
-        COLORS.ERROR ?? ""
+        `${_nullishCoalesce(entry.error.name, () => ( "Error"))}: ${entry.error.message}`,
+        _nullishCoalesce(COLORS.ERROR, () => ( ""))
       )}`;
       if (entry.error.stack) {
         line += `
@@ -1189,7 +1596,7 @@ ${colorize(entry.error.stack, DIM)}`;
 // src/transports/redis.ts
 function redisTransport(options) {
   const { client, streamKey = "logs", maxLen, level } = options;
-  const fieldMapper = options.fieldMapper ?? defaultFieldMapper;
+  const fieldMapper = _nullishCoalesce(options.fieldMapper, () => ( defaultFieldMapper));
   function defaultFieldMapper(entry) {
     return {
       id: entry.id,
@@ -1226,11 +1633,60 @@ function redisTransport(options) {
   };
 }
 
+// src/transports/ring-buffer.ts
+function ringBufferTransport(options = {}) {
+  const maxSize = _nullishCoalesce(options.maxSize, () => ( 1e3));
+  const buffer = [];
+  let head = 0;
+  let count = 0;
+  return {
+    name: "ring-buffer",
+    level: options.level,
+    write(entry) {
+      if (count < maxSize) {
+        buffer.push(entry);
+        count++;
+      } else {
+        buffer[head] = entry;
+      }
+      head = (head + 1) % maxSize;
+    },
+    getEntries(query) {
+      let entries;
+      if (count < maxSize) {
+        entries = buffer.slice();
+      } else {
+        entries = [...buffer.slice(head), ...buffer.slice(0, head)];
+      }
+      if (_optionalChain([query, 'optionalAccess', _51 => _51.level])) {
+        const minLevel = resolveLevel(query.level);
+        entries = entries.filter((e) => e.level >= minLevel);
+      }
+      if (_optionalChain([query, 'optionalAccess', _52 => _52.since])) {
+        const since = query.since;
+        entries = entries.filter((e) => e.timestamp >= since);
+      }
+      if (_optionalChain([query, 'optionalAccess', _53 => _53.limit])) {
+        entries = entries.slice(-query.limit);
+      }
+      return entries;
+    },
+    clear() {
+      buffer.length = 0;
+      head = 0;
+      count = 0;
+    },
+    get size() {
+      return count;
+    }
+  };
+}
+
 // src/transports/sentry.ts
 function sentryTransport(options) {
   const { sentry } = options;
-  const errorLevelValue = resolveLevel(options.errorLevel ?? "ERROR");
-  const breadcrumbLevelValue = resolveLevel(options.breadcrumbLevel ?? "INFO");
+  const errorLevelValue = resolveLevel(_nullishCoalesce(options.errorLevel, () => ( "ERROR")));
+  const breadcrumbLevelValue = resolveLevel(_nullishCoalesce(options.breadcrumbLevel, () => ( "INFO")));
   return {
     name: "sentry",
     write(entry) {
@@ -1272,7 +1728,7 @@ function slackTransport(options) {
   const { webhookUrl, username, iconEmoji, level } = options;
   return {
     name: "slack",
-    level: level ?? "ERROR",
+    level: _nullishCoalesce(level, () => ( "ERROR")),
     // Default to ERROR to prevent spamming
     async write(entry) {
       try {
@@ -1332,7 +1788,7 @@ function formatSlackMessage(entry, username, icon_emoji) {
       }
     });
   }
-  if (entry.error?.stack) {
+  if (_optionalChain([entry, 'access', _54 => _54.error, 'optionalAccess', _55 => _55.stack])) {
     blocks.push({
       type: "section",
       text: {
@@ -1382,11 +1838,11 @@ function webhookTransport(options) {
     retry = false,
     maxRetries = 3
   } = options;
-  const serialize = options.serializer ?? ((entries) => JSON.stringify({
+  const serialize = _nullishCoalesce(options.serializer, () => ( ((entries) => JSON.stringify({
     entries,
     count: entries.length,
     timestamp: Date.now()
-  }));
+  }))));
   let buffer = [];
   let flushTimer = null;
   async function sendBatch(entries, attempt = 0) {
@@ -1404,7 +1860,7 @@ function webhookTransport(options) {
         await new Promise((r) => setTimeout(r, delay));
         return sendBatch(entries, attempt + 1);
       }
-    } catch {
+    } catch (e10) {
       if (retry && attempt < maxRetries) {
         const delay = Math.min(1e3 * 2 ** attempt, 3e4);
         await new Promise((r) => setTimeout(r, delay));
@@ -1449,45 +1905,50 @@ function webhookTransport(options) {
       }
     },
     async close() {
-      await this.flush?.();
+      await _optionalChain([this, 'access', _56 => _56.flush, 'optionalCall', _57 => _57()]);
     }
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LogLevel,
-  LogLevelNameMap,
-  LogLevelValueMap,
-  aiEnrichmentMiddleware,
-  alertMiddleware,
-  batchTransport,
-  browserJsonStreamTransport,
-  consoleTransport,
-  correlationIdMiddleware,
-  createLogger,
-  createMiddleware,
-  createOpenAiErrorAnalyzer,
-  createTransport,
-  datadogTransport,
-  deduplicationMiddleware,
-  discordTransport,
-  fileTransport,
-  heapUsageMiddleware,
-  ipMiddleware,
-  jsonStreamTransport,
-  levelOverrideMiddleware,
-  lokiTransport,
-  ocppMiddleware,
-  prettyTransport,
-  redactionMiddleware,
-  redisTransport,
-  resolveLevel,
-  samplingMiddleware,
-  sentryTransport,
-  shouldIncludeStack,
-  shouldLog,
-  slackTransport,
-  userAgentMiddleware,
-  webhookTransport
-});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.LogLevel = LogLevel; exports.LogLevelNameMap = LogLevelNameMap; exports.LogLevelValueMap = LogLevelValueMap; exports.aiEnrichmentMiddleware = aiEnrichmentMiddleware; exports.alertMiddleware = alertMiddleware; exports.asyncContextMiddleware = asyncContextMiddleware; exports.batchTransport = batchTransport; exports.browserJsonStreamTransport = browserJsonStreamTransport; exports.consoleTransport = consoleTransport; exports.correlationIdMiddleware = correlationIdMiddleware; exports.createHttpLogger = createHttpLogger; exports.createLogger = createLogger; exports.createMiddleware = createMiddleware; exports.createOpenAiErrorAnalyzer = createOpenAiErrorAnalyzer; exports.createTransport = createTransport; exports.datadogTransport = datadogTransport; exports.deduplicationMiddleware = deduplicationMiddleware; exports.discordTransport = discordTransport; exports.fileTransport = fileTransport; exports.heapUsageMiddleware = heapUsageMiddleware; exports.ipMiddleware = ipMiddleware; exports.jsonStreamTransport = jsonStreamTransport; exports.levelOverrideMiddleware = levelOverrideMiddleware; exports.lokiTransport = lokiTransport; exports.nodeHttpMappers = nodeHttpMappers; exports.ocppMiddleware = ocppMiddleware; exports.otelTraceMiddleware = otelTraceMiddleware; exports.otelTransport = otelTransport; exports.prettyTransport = prettyTransport; exports.redactionMiddleware = redactionMiddleware; exports.redisTransport = redisTransport; exports.resolveLevel = resolveLevel; exports.ringBufferTransport = ringBufferTransport; exports.samplingMiddleware = samplingMiddleware; exports.sentryTransport = sentryTransport; exports.shouldIncludeStack = shouldIncludeStack; exports.shouldLog = shouldLog; exports.slackTransport = slackTransport; exports.userAgentMiddleware = userAgentMiddleware; exports.webhookTransport = webhookTransport;
 //# sourceMappingURL=index.js.map