voltlog-io 1.0.3 → 1.0.4

package/dist/index.mjs

@@ -1,430 +1,40 @@
-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');
-});
-
-// node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var getFilename = () => fileURLToPath(import.meta.url);
-var __filename = /* @__PURE__ */ getFilename();
-
-// src/core/types.ts
-var LogLevel = {
-  TRACE: 10,
-  DEBUG: 20,
-  INFO: 30,
-  WARN: 40,
-  ERROR: 50,
-  FATAL: 60,
-  SILENT: Infinity
-};
-var LogLevelNameMap = Object.fromEntries(
-  Object.entries(LogLevel).map(([k, v]) => [k.toLowerCase(), v])
-);
-var LogLevelValueMap = Object.fromEntries(
-  Object.entries(LogLevel).filter(([, v]) => Number.isFinite(v)).map(([k, v]) => [v, k])
-);
-
-// src/core/levels.ts
-function resolveLevel(level) {
-  const n = LogLevelNameMap[level.toLowerCase()];
-  return n !== void 0 ? n : LogLevel.INFO;
-}
-function shouldLog(entryLevel, filterLevel) {
-  return entryLevel >= filterLevel;
-}
-function shouldIncludeStack(entryLevel, includeStack) {
-  if (typeof includeStack === "boolean") return includeStack;
-  return entryLevel >= resolveLevel(includeStack);
-}
-
-// src/core/logger.ts
-import { randomUUID } from "crypto";
-
-// src/core/pipeline.ts
-function composeMiddleware(middleware, final) {
-  if (middleware.length === 0) return final;
-  return (entry) => {
-    let index = 0;
-    const next = (e) => {
-      if (index < middleware.length) {
-        const mw = middleware[index++];
-        mw(e, next);
-      } else {
-        final(e);
-      }
-    };
-    next(entry);
-  };
-}
-function fanOutToTransports(entry, transports, loggerLevel) {
-  for (const t of transports) {
-    const tLevel = t.level ? resolveLevel(t.level) : loggerLevel;
-    if (!shouldLog(entry.level, tLevel)) continue;
-    try {
-      const result = t.write(entry);
-      if (result && typeof result.catch === "function") {
-        result.catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-}
-
-// src/core/logger.ts
-var LoggerImpl = class {
-  _level;
-  _transports;
-  _middlewareList;
-  _pipeline;
-  _context;
-  _includeStack;
-  _timestampFn;
-  _idFn;
-  constructor(options = {}) {
-    this._level = resolveLevel(options.level ?? "INFO");
-    this._transports = [...options.transports ?? []];
-    this._middlewareList = [...options.middleware ?? []];
-    this._context = options.context ? { ...options.context } : {};
-    this._includeStack = options.includeStack ?? "ERROR";
-    this._timestampFn = options.timestamp ?? Date.now;
-    this._idFn = options.idGenerator !== void 0 ? options.idGenerator : 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 {
-      this._log(50, "ERROR", message, metaOrError, error);
-    }
-  }
-  fatal(message, metaOrError, error) {
-    if (metaOrError instanceof Error) {
-      this._log(60, "FATAL", message, void 0, metaOrError);
-    } else {
-      this._log(60, "FATAL", message, metaOrError, error);
-    }
-  }
-  // ─── Child Logger ───────────────────────────────────────────
-  child(context) {
-    return new ChildLoggerImpl(this, { ...this._context, ...context });
-  }
-  // ─── Dynamic Configuration ─────────────────────────────────
-  addTransport(transport) {
-    this._transports.push(transport);
-  }
-  removeTransport(name) {
-    this._transports = this._transports.filter((t) => t.name !== name);
-  }
-  addMiddleware(middleware) {
-    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 LogLevelValueMap[this._level] ?? "INFO";
-  }
-  isLevelEnabled(level) {
-    return resolveLevel(level) >= this._level;
-  }
-  // ─── Timer ─────────────────────────────────────────────────
-  startTimer(level) {
-    const start = performance.now();
-    const logLevel = 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));
-  }
-  async close() {
-    await this.flush();
-    await Promise.all(this._transports.map((t) => t.close?.()).filter(Boolean));
-  }
-  // ─── Internal ───────────────────────────────────────────────
-  /** @internal */
-  _log(level, levelName, message, meta, error) {
-    this._logWithContext(level, levelName, message, this._context, meta, error);
-  }
-  /** @internal — used by child loggers to inject bound context */
-  _logWithContext(level, levelName, message, context, meta, error) {
-    if (!shouldLog(level, this._level)) return;
-    const entry = {
-      id: this._idFn ? this._idFn() : "",
-      level,
-      levelName,
-      message,
-      timestamp: this._timestampFn(),
-      meta: meta ?? {},
-      context: Object.keys(context).length > 0 ? context : void 0
-    };
-    if (error) {
-      entry.error = serializeError(
-        error,
-        shouldIncludeStack(level, this._includeStack)
-      );
-    }
-    this._pipeline(entry);
-  }
-  _buildPipeline() {
-    return composeMiddleware(this._middlewareList, (entry) => {
-      fanOutToTransports(entry, this._transports, this._level);
-    });
-  }
-};
-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;
-    this._context = _context;
-  }
-  trace(message, meta) {
-    this._parent._logWithContext(10, "TRACE", message, this._context, meta);
-  }
-  debug(message, meta) {
-    this._parent._logWithContext(20, "DEBUG", message, this._context, meta);
-  }
-  info(message, meta) {
-    this._parent._logWithContext(30, "INFO", message, this._context, meta);
-  }
-  warn(message, meta) {
-    this._parent._logWithContext(40, "WARN", message, this._context, meta);
-  }
-  error(message, metaOrError, error) {
-    if (metaOrError instanceof Error) {
-      this._parent._logWithContext(
-        50,
-        "ERROR",
-        message,
-        this._context,
-        void 0,
-        metaOrError
-      );
-    } else {
-      this._parent._logWithContext(
-        50,
-        "ERROR",
-        message,
-        this._context,
-        metaOrError,
-        error
-      );
-    }
-  }
-  fatal(message, metaOrError, error) {
-    if (metaOrError instanceof Error) {
-      this._parent._logWithContext(
-        60,
-        "FATAL",
-        message,
-        this._context,
-        void 0,
-        metaOrError
-      );
-    } else {
-      this._parent._logWithContext(
-        60,
-        "FATAL",
-        message,
-        this._context,
-        metaOrError,
-        error
-      );
-    }
-  }
-  child(context) {
-    return new _ChildLoggerImpl(this._parent, {
-      ...this._context,
-      ...context
-    });
-  }
-  addTransport(transport) {
-    this._parent.addTransport(transport);
-  }
-  removeTransport(name) {
-    this._parent.removeTransport(name);
-  }
-  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();
-  }
-  close() {
-    return this._parent.close();
-  }
-};
-function createLogger(options) {
-  return new LoggerImpl(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";
-  return async (entry, next) => {
-    if (entry.level < minLevel) {
-      next(entry);
-      return;
-    }
-    try {
-      const analysisPromise = options.analyzer(entry);
-      const timeoutPromise = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("AI Analysis Timeout")), timeoutMs)
-      );
-      const result = await Promise.race([analysisPromise, timeoutPromise]);
-      if (result) {
-        entry.meta = {
-          ...entry.meta,
-          [fieldName]: result
-        };
-      }
-    } catch (err) {
-      if (!swallow) {
-        throw err;
-      }
-    }
-    next(entry);
-  };
-}
-function createOpenAiErrorAnalyzer(apiKey, model = "gpt-3.5-turbo", systemPrompt = "You are a log analyzer. Explain this error briefly and suggest a fix in 1 sentence.") {
-  return async (entry) => {
-    try {
-      const response = await fetch(
-        "https://api.openai.com/v1/chat/completions",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`
-          },
-          body: JSON.stringify({
-            model,
-            messages: [
-              { role: "system", content: systemPrompt },
-              {
-                role: "user",
-                content: `Error Message: ${entry.message}
-Context: ${JSON.stringify(entry.meta)}`
-              }
-            ],
-            max_tokens: 150
-          })
-        }
-      );
-      if (!response.ok) return null;
-      const data = await response.json();
-      return data.choices?.[0]?.message?.content ?? null;
-    } catch {
-      return null;
-    }
-  };
-}
-
-// src/middleware/alert.ts
-function alertMiddleware(rules) {
-  const states = /* @__PURE__ */ new Map();
-  for (const rule of rules) {
-    states.set(rule.name, { entries: [], lastFired: -Infinity });
-  }
-  return (entry, next) => {
-    const now = entry.timestamp;
-    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;
-      if (Number.isFinite(windowMs)) {
-        state.entries = state.entries.filter(
-          (e) => now - e.timestamp < windowMs
-        );
-      }
-      state.entries.push(entry);
-      if (state.entries.length >= threshold && now - state.lastFired >= cooldownMs) {
-        const alertEntries = [...state.entries];
-        state.entries = [];
-        state.lastFired = now;
-        try {
-          const result = rule.onAlert(alertEntries);
-          if (result && typeof result.catch === "function") {
-            result.catch(() => {
-            });
-          }
-        } catch {
-        }
-      }
-    }
-    next(entry);
-  };
-}
+import {
+  LogLevel,
+  LogLevelNameMap,
+  LogLevelValueMap,
+  aiEnrichmentMiddleware,
+  alertMiddleware,
+  batchTransport,
+  browserJsonStreamTransport,
+  consoleTransport,
+  createHttpLogger,
+  createLogger,
+  createMiddleware,
+  createOpenAiErrorAnalyzer,
+  createTransport,
+  datadogTransport,
+  deduplicationMiddleware,
+  discordTransport,
+  heapUsageMiddleware,
+  ipMiddleware,
+  levelOverrideMiddleware,
+  lokiTransport,
+  nodeHttpMappers,
+  ocppMiddleware,
+  otelTraceMiddleware,
+  otelTransport,
+  prettyTransport,
+  redactionMiddleware,
+  resolveLevel,
+  ringBufferTransport,
+  samplingMiddleware,
+  sentryTransport,
+  shouldIncludeStack,
+  shouldLog,
+  slackTransport,
+  userAgentMiddleware,
+  webhookTransport
+} from "./chunk-DAFMRCAN.mjs";
 
 // src/middleware/async-context.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -465,10 +75,10 @@ function asyncContextMiddleware() {
 }
 
 // src/middleware/correlation-id.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 function correlationIdMiddleware(options = {}) {
   const header = options.header ?? "x-correlation-id";
-  const generate = options.generator ?? randomUUID2;
+  const generate = options.generator ?? randomUUID;
   return (entry, next) => {
     if (entry.correlationId) {
       return next(entry);
@@ -486,586 +96,9 @@ function correlationIdMiddleware(options = {}) {
   };
 }
 
-// src/middleware/create-middleware.ts
-function createMiddleware(fn) {
-  return 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 buffer = /* @__PURE__ */ new Map();
-  return (entry, next) => {
-    const key = keyFn(entry);
-    if (buffer.has(key)) {
-      const state = buffer.get(key);
-      state.count++;
-      return;
-    }
-    const timer = setTimeout(() => {
-      const state = buffer.get(key);
-      if (state) {
-        buffer.delete(key);
-        if (state.count > 1) {
-          state.entry.meta = {
-            ...state.entry.meta,
-            duplicateCount: state.count
-          };
-        }
-        next(state.entry);
-      }
-    }, windowMs);
-    buffer.set(key, {
-      entry,
-      count: 1,
-      timer
-    });
-  };
-}
-
-// src/middleware/heap-usage.ts
-function heapUsageMiddleware(options = {}) {
-  const fieldName = options.fieldName ?? "memory";
-  return (entry, next) => {
-    if (typeof process !== "undefined" && process.memoryUsage) {
-      const memory = process.memoryUsage();
-      entry.meta = {
-        ...entry.meta,
-        [fieldName]: {
-          rss: memory.rss,
-          heapTotal: memory.heapTotal,
-          heapUsed: memory.heapUsed
-        }
-      };
-    }
-    next(entry);
-  };
-}
-
-// src/middleware/http.ts
-var nodeHttpMappers = {
-  req: {
-    getMethod: (req) => req.method || "UNKNOWN",
-    getUrl: (req) => req.originalUrl || req.url || "/",
-    getIp: (req) => req.ip || req.socket?.remoteAddress || req.headers?.["x-forwarded-for"] || void 0,
-    getUserAgent: (req) => req.headers?.["user-agent"] || void 0,
-    getHeader: (req, name) => req.headers?.[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 (skip?.(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 ?? [
-    "x-forwarded-for",
-    "x-real-ip",
-    "req.ip",
-    "ip",
-    "x-client-ip"
-  ];
-  return (entry, next) => {
-    const meta = entry.meta;
-    const headers = meta.headers || {};
-    const req = meta.req || {};
-    let foundIp;
-    for (const key of keysToCheck) {
-      if (typeof meta[key] === "string") {
-        foundIp = meta[key];
-        break;
-      }
-      if (typeof headers[key] === "string") {
-        foundIp = headers[key];
-        break;
-      }
-      if (typeof req[key] === "string") {
-        foundIp = req[key];
-        break;
-      }
-      if (key === "req.ip" && typeof req.ip === "string") {
-        foundIp = req.ip;
-        break;
-      }
-    }
-    if (foundIp) {
-      const firstIp = typeof foundIp === "string" ? foundIp.split(",")[0].trim() : String(foundIp);
-      entry.meta = {
-        ...entry.meta,
-        [targetField]: firstIp
-      };
-    }
-    next(entry);
-  };
-}
-
-// src/middleware/level-override.ts
-function levelOverrideMiddleware(options = {}) {
-  const key = options.key ?? "x-log-level";
-  const cleanup = options.cleanup ?? true;
-  return (entry, next) => {
-    const meta = entry.meta;
-    const context = entry.context;
-    const levelName = meta[key] || context?.[key] || meta.headers?.[key];
-    if (levelName && typeof levelName === "string") {
-      const upperName = levelName.toUpperCase();
-      if (LogLevel[upperName]) {
-        entry.level = LogLevel[upperName];
-        entry.levelName = upperName;
-        if (cleanup) {
-          delete meta[key];
-          if (meta.headers) {
-            delete meta.headers[key];
-          }
-        }
-      }
-    }
-    next(entry);
-  };
-}
-
-// src/middleware/ocpp.ts
-function ocppMiddleware(options = {}) {
-  const autoPayloadSize = options.autoPayloadSize ?? true;
-  const propagateCorrelationId = 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 {
-      }
-    }
-    if (propagateCorrelationId && enriched.meta.correlationId && !enriched.correlationId) {
-      enriched.correlationId = enriched.meta.correlationId;
-    }
-    next(enriched);
-  };
-}
-
-// src/middleware/otel-trace.ts
-function otelTraceMiddleware(options = {}) {
-  let traceApi = 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 {
-    }
-  }
-  return (entry, next) => {
-    if (resolved && traceApi?.trace) {
-      try {
-        const activeSpan = traceApi.trace.getActiveSpan?.();
-        if (activeSpan) {
-          const spanContext = activeSpan.spanContext?.();
-          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 {
-      }
-    }
-    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;
-  function redactObject(obj) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (paths.has(key.toLowerCase())) {
-        result[key] = replacement;
-      } else if (deep && value !== null && typeof value === "object" && !Array.isArray(value)) {
-        result[key] = redactObject(value);
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  }
-  return (entry, next) => {
-    const redacted = { ...entry };
-    if (entry.meta && typeof entry.meta === "object") {
-      redacted.meta = redactObject(
-        entry.meta
-      );
-    }
-    if (entry.context && typeof entry.context === "object") {
-      redacted.context = redactObject(entry.context);
-    }
-    next(redacted);
-  };
-}
-
-// 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 buckets = /* @__PURE__ */ new Map();
-  return (entry, next) => {
-    if (entry.level >= priorityLevel) {
-      return next(entry);
-    }
-    if (sampleRate < 1 && Math.random() > sampleRate) {
-      return;
-    }
-    const key = keyFn(entry);
-    const now = entry.timestamp;
-    let bucket = buckets.get(key);
-    if (!bucket || now - bucket.windowStart >= windowMs) {
-      bucket = { count: 0, windowStart: now };
-      buckets.set(key, bucket);
-    }
-    if (bucket.count < maxPerWindow) {
-      bucket.count++;
-      next(entry);
-    }
-    if (buckets.size > 2e3) {
-      const expireBefore = now - windowMs * 2;
-      for (const [k, b] of buckets) {
-        if (b.windowStart < expireBefore) {
-          buckets.delete(k);
-        }
-      }
-    }
-  };
-}
-
-// src/middleware/user-agent.ts
-function userAgentMiddleware(options = {}) {
-  const sourceField = options.sourceField;
-  const targetField = 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"];
-    if (ua) {
-      const info = parseUserAgent(ua);
-      entry.meta = {
-        ...entry.meta,
-        [targetField]: info
-      };
-    }
-    next(entry);
-  };
-}
-function parseUserAgent(ua) {
-  const browser = /(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i.exec(ua) || [];
-  let name = browser[1] ? browser[1].toLowerCase() : "unknown";
-  let version = browser[2] || "unknown";
-  if (/trident/i.test(name)) {
-    name = "ie";
-  } else if (name === "chrome") {
-    const edge = /edg(e)?\/(\d+)/i.exec(ua);
-    if (edge) {
-      name = "edge";
-      version = edge[2];
-    }
-  }
-  const osResult = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.exec(
-    ua
-  );
-  const os = osResult ? osResult[0].toLowerCase() : "desktop";
-  return { browser: name, version, os };
-}
-
-// src/transports/batch.ts
-function batchTransport(inner, options = {}) {
-  const batchSize = options.batchSize ?? 100;
-  const flushIntervalMs = options.flushIntervalMs ?? 5e3;
-  let buffer = [];
-  let flushTimer = null;
-  function scheduleFlush() {
-    if (flushTimer) return;
-    flushTimer = setTimeout(() => {
-      flushTimer = null;
-      doFlush();
-    }, flushIntervalMs);
-  }
-  function doFlush() {
-    if (buffer.length === 0) return;
-    const batch = buffer;
-    buffer = [];
-    for (const entry of batch) {
-      try {
-        const result = inner.write(entry);
-        if (result && typeof result.catch === "function") {
-          result.catch(() => {
-          });
-        }
-      } catch {
-      }
-    }
-  }
-  return {
-    name: `batch(${inner.name})`,
-    level: inner.level,
-    write(entry) {
-      buffer.push(entry);
-      if (buffer.length >= batchSize) {
-        doFlush();
-      } else {
-        scheduleFlush();
-      }
-    },
-    async flush() {
-      if (flushTimer) {
-        clearTimeout(flushTimer);
-        flushTimer = null;
-      }
-      doFlush();
-      await inner.flush?.();
-    },
-    async close() {
-      await this.flush?.();
-      await inner.close?.();
-    }
-  };
-}
-
-// src/transports/browser-json-stream.ts
-function browserJsonStreamTransport(options) {
-  const stream = options.stream;
-  const writer = stream.getWriter();
-  const serialize = options.serializer ?? ((entry) => `${JSON.stringify(entry)}
-`);
-  return {
-    name: "browser-stream",
-    level: options.level,
-    async write(entry) {
-      try {
-        const data = serialize(entry);
-        await writer.ready;
-        await writer.write(data);
-      } catch (err) {
-        console.error("[voltlog] Failed to write to browser stream", err);
-      }
-    },
-    async close() {
-      try {
-        await writer.close();
-      } catch (_err) {
-      }
-    }
-  };
-}
-
-// src/transports/console.ts
-function consoleTransport(options = {}) {
-  const useConsoleLevels = options.useConsoleLevels ?? true;
-  const formatter = options.formatter ?? ((entry) => JSON.stringify(entry));
-  return {
-    name: "console",
-    level: options.level,
-    write(entry) {
-      const output = formatter(entry);
-      if (!useConsoleLevels) {
-        console.log(output);
-        return;
-      }
-      if (entry.level >= LogLevel.FATAL) {
-        console.error(output);
-      } else if (entry.level >= LogLevel.ERROR) {
-        console.error(output);
-      } else if (entry.level >= LogLevel.WARN) {
-        console.warn(output);
-      } else if (entry.level >= LogLevel.INFO) {
-        console.info(output);
-      } else if (entry.level >= LogLevel.DEBUG) {
-        console.debug(output);
-      } else {
-        console.log(output);
-      }
-    }
-  };
-}
-
-// src/transports/create-transport.ts
-function createTransport(name, write, options = {}) {
-  return {
-    name,
-    write,
-    ...options
-  };
-}
-
-// src/transports/datadog.ts
-function datadogTransport(options) {
-  const {
-    apiKey,
-    site = "datadoghq.com",
-    service,
-    ddSource = "nodejs",
-    hostname,
-    tags,
-    level
-  } = options;
-  const url = `https://http-intake.logs.${site}/api/v2/logs`;
-  return {
-    name: "datadog",
-    level,
-    async write(entry) {
-      const payload = {
-        ddsource: ddSource,
-        ddtags: tags,
-        hostname,
-        service,
-        message: entry.message,
-        status: entry.levelName.toLowerCase(),
-        // Datadog uses lowercase status
-        ...entry.meta,
-        timestamp: entry.timestamp
-        // Datadog auto-parses this
-      };
-      try {
-        await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "DD-API-KEY": apiKey
-          },
-          body: JSON.stringify(payload)
-        });
-      } catch (err) {
-        console.error("[voltlog] Datadog push failed", err);
-      }
-    }
-  };
-}
-
-// src/transports/discord.ts
-function discordTransport(options) {
-  const { webhookUrl, username, avatarUrl, level = "ERROR" } = options;
-  return {
-    name: "discord",
-    level,
-    async write(entry) {
-      try {
-        await fetch(webhookUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(
-            formatDiscordPayload(entry, username, avatarUrl)
-          )
-        });
-      } catch (_err) {
-      }
-    }
-  };
-}
-function formatDiscordPayload(entry, username, avatar_url) {
-  const color = getLevelColor(entry.level);
-  return {
-    username: username || "VoltLog",
-    avatar_url,
-    embeds: [
-      {
-        title: `${entry.levelName} - ${entry.message}`,
-        color,
-        timestamp: new Date(entry.timestamp).toISOString(),
-        fields: [
-          {
-            name: "Meta",
-            value: `\`\`\`json
-${JSON.stringify(entry.meta, null, 2).slice(
-              0,
-              1e3
-            )}
-\`\`\``
-          },
-          entry.error?.stack ? {
-            name: "Stack",
-            value: `\`\`\`js
-${entry.error.stack.slice(0, 1e3)}
-\`\`\``
-          } : null
-        ].filter(Boolean)
-      }
-    ]
-  };
-}
-function getLevelColor(level) {
-  if (level >= 50) return 15158332;
-  if (level >= 40) return 16776960;
-  if (level >= 30) return 3447003;
-  return 9807270;
-}
-
 // src/transports/file.ts
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 function fileTransport(options) {
   const { dir, level, maxSize } = options;
   const filenamePattern = options.filename ?? "app-%DATE%.log";
@@ -1092,11 +125,11 @@ function fileTransport(options) {
     const dateStr = getCachedDate();
     const filename = filenamePattern.replace("%DATE%", dateStr);
     if (sizeRotation && rotationIndex > 0) {
-      const ext = path2.extname(filename);
+      const ext = path.extname(filename);
       const base = filename.slice(0, -ext.length || void 0);
-      return path2.join(dir, `${base}.${rotationIndex}${ext}`);
+      return path.join(dir, `${base}.${rotationIndex}${ext}`);
     }
-    return path2.join(dir, filename);
+    return path.join(dir, filename);
   }
   function openStream(filePath) {
     if (currentStream) {
@@ -1174,431 +207,6 @@ function jsonStreamTransport(options) {
   };
 }
 
-// src/transports/loki.ts
-function lokiTransport(options) {
-  const { host, level } = options;
-  const staticLabels = options.labels ?? { app: "voltlog" };
-  const batchSize = options.batchSize ?? 10;
-  const interval = options.interval ?? 5e3;
-  const includeMetadata = options.includeMetadata !== false;
-  const retryEnabled = options.retry ?? false;
-  const maxRetries = options.maxRetries ?? 3;
-  const url = `${host.replace(/\/$/, "")}/loki/api/v1/push`;
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (options.basicAuthUser && options.basicAuthPassword) {
-    const creds = btoa(`${options.basicAuthUser}:${options.basicAuthPassword}`);
-    headers.Authorization = `Basic ${creds}`;
-  }
-  if (options.tenantId) {
-    headers["X-Scope-OrgID"] = options.tenantId;
-  }
-  let buffer = [];
-  let timer = null;
-  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 = [];
-    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 this.flush?.();
-    }
-  };
-}
-
-// 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 = options.batchSize ?? 20;
-  const interval = 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 = 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: severity?.number,
-      severityText: severity?.text,
-      body: { stringValue: entry.message },
-      attributes
-    };
-    const meta = entry.meta;
-    if (meta?.traceId) {
-      record.traceId = meta.traceId;
-    }
-    if (meta?.spanId) {
-      record.spanId = meta.spanId;
-    }
-    if (meta?.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 {
-      const response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(payload)
-      });
-      if (!response.ok) {
-        console.error(
-          `[voltlog] OTLP push failed: ${response.status} ${response.statusText}`
-        );
-      }
-    } catch (err) {
-      console.error("[voltlog] OTLP push failed", err);
-    }
-  }
-  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: "otel",
-    level,
-    write(entry) {
-      buffer.push(entry);
-      if (buffer.length >= batchSize) {
-        if (timer) clearTimeout(timer);
-        timer = null;
-        flush();
-      } else {
-        schedule();
-      }
-    },
-    async flush() {
-      if (timer) clearTimeout(timer);
-      timer = null;
-      if (buffer.length === 0) return;
-      const batch = buffer;
-      buffer = [];
-      await sendBatch(batch);
-    },
-    async close() {
-      await this.flush?.();
-    }
-  };
-}
-
-// src/transports/pretty.ts
-var RESET = "\x1B[0m";
-var DIM = "\x1B[2m";
-var BOLD = "\x1B[1m";
-var COLORS = {
-  TRACE: "\x1B[90m",
-  // gray
-  DEBUG: "\x1B[36m",
-  // cyan
-  INFO: "\x1B[32m",
-  // green
-  WARN: "\x1B[33m",
-  // yellow
-  ERROR: "\x1B[31m",
-  // red
-  FATAL: "\x1B[35;1m"
-  // bold magenta
-};
-var ICONS = {
-  TRACE: "\u{1F50D}",
-  DEBUG: "\u{1F41B}",
-  INFO: "\u2139",
-  WARN: "\u26A0",
-  ERROR: "\u2716",
-  FATAL: "\u{1F480}"
-};
-var EXCHANGE_ICONS = {
-  CALL: "\u26A1",
-  CALLRESULT: "\u2714",
-  CALLERROR: "\u{1F6A8}"
-};
-var DIRECTION_ARROWS = {
-  IN: "\u2192",
-  OUT: "\u2190"
-};
-function prettyTransport(options = {}) {
-  const showTimestamps = options.timestamps ?? true;
-  const useColors = options.colors ?? true;
-  const hideMeta = options.hideMeta ?? false;
-  const prettyMeta = 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 action = meta.action;
-    const msgType = meta.messageType;
-    const dir = 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 latency = meta.latencyMs !== void 0 ? `(${meta.latencyMs}ms)` : "";
-      line += `
-${statusIcon} ${status}  ${colorize(latency, DIM)}`;
-    }
-    return line;
-  }
-  function formatStandard(entry) {
-    const icon = ICONS[entry.levelName] ?? "\u2022";
-    const levelColor = 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) {
-      const kvStr = Object.entries(entry.context).map(
-        ([k, v]) => `${k}:${typeof v === "string" ? v : JSON.stringify(v)}`
-      ).join(" ");
-      line += `  ${colorize(kvStr, 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 ?? ""
-      )}`;
-      if (entry.error.stack) {
-        line += `
-${colorize(entry.error.stack, DIM)}`;
-      }
-    }
-    return line;
-  }
-  return {
-    name: "pretty",
-    level: options.level,
-    write(entry) {
-      const exchangeOutput = formatExchange(entry);
-      if (exchangeOutput) {
-        console.log(exchangeOutput);
-        return;
-      }
-      const output = formatStandard(entry);
-      if (entry.level >= LogLevel.ERROR) {
-        console.error(output);
-      } else if (entry.level >= LogLevel.WARN) {
-        console.warn(output);
-      } else {
-        console.log(output);
-      }
-    }
-  };
-}
-
 // src/transports/redis.ts
 function redisTransport(options) {
   const { client, streamKey = "logs", maxLen, level } = options;
@@ -1638,283 +246,6 @@ function redisTransport(options) {
     }
   };
 }
-
-// src/transports/ring-buffer.ts
-function ringBufferTransport(options = {}) {
-  const maxSize = 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 (query?.level) {
-        const minLevel = resolveLevel(query.level);
-        entries = entries.filter((e) => e.level >= minLevel);
-      }
-      if (query?.since) {
-        const since = query.since;
-        entries = entries.filter((e) => e.timestamp >= since);
-      }
-      if (query?.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");
-  return {
-    name: "sentry",
-    write(entry) {
-      if (entry.level >= errorLevelValue) {
-        if (entry.error) {
-          sentry.captureException(entry.error, {
-            extra: {
-              ...entry.meta,
-              context: entry.context
-            },
-            level: "error"
-          });
-        } else {
-          sentry.captureMessage(entry.message, "error");
-        }
-      }
-      if (entry.level >= breadcrumbLevelValue) {
-        sentry.addBreadcrumb({
-          category: "log",
-          message: entry.message,
-          level: mapLevelToSentry(entry.level),
-          data: { ...entry.meta, ...entry.context },
-          timestamp: entry.timestamp / 1e3
-        });
-      }
-    }
-  };
-}
-function mapLevelToSentry(level) {
-  if (level >= 60) return "fatal";
-  if (level >= 50) return "error";
-  if (level >= 40) return "warning";
-  if (level >= 30) return "info";
-  return "debug";
-}
-
-// src/transports/slack.ts
-function slackTransport(options) {
-  const { webhookUrl, username, iconEmoji, level } = options;
-  return {
-    name: "slack",
-    level: level ?? "ERROR",
-    // Default to ERROR to prevent spamming
-    async write(entry) {
-      try {
-        const payload = formatSlackMessage(entry, username, iconEmoji);
-        const response = await fetch(webhookUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(payload)
-        });
-        if (!response.ok) {
-        }
-      } catch (_err) {
-      }
-    }
-  };
-}
-function formatSlackMessage(entry, username, icon_emoji) {
-  const levelEmoji = getLevelEmoji(entry.level);
-  const color = getLevelColor2(entry.level);
-  const blocks = [
-    {
-      type: "header",
-      text: {
-        type: "plain_text",
-        text: `${levelEmoji} ${entry.levelName}: ${entry.message}`,
-        emoji: true
-      }
-    },
-    {
-      type: "context",
-      elements: [
-        {
-          type: "mrkdwn",
-          text: `*Time:* ${new Date(entry.timestamp).toISOString()}`
-        },
-        {
-          type: "mrkdwn",
-          text: `*ID:* \`${entry.id}\``
-        }
-      ]
-    }
-  ];
-  if (entry.correlationId) {
-    blocks[1].elements.push({
-      type: "mrkdwn",
-      text: `*Trace:* \`${entry.correlationId}\``
-    });
-  }
-  if (Object.keys(entry.meta).length > 0) {
-    blocks.push({
-      type: "section",
-      text: {
-        type: "mrkdwn",
-        text: `*Metadata:*
-\`\`\`${JSON.stringify(entry.meta, null, 2)}\`\`\``,
-        emoji: true
-      }
-    });
-  }
-  if (entry.error?.stack) {
-    blocks.push({
-      type: "section",
-      text: {
-        type: "mrkdwn",
-        text: `*Error Stack:*
-\`\`\`${entry.error.stack}\`\`\``,
-        emoji: true
-      }
-    });
-  }
-  return {
-    username,
-    icon_emoji,
-    attachments: [
-      {
-        color,
-        blocks
-      }
-    ]
-  };
-}
-function getLevelEmoji(level) {
-  if (level >= 60) return "\u{1F525}";
-  if (level >= 50) return "\u{1F6A8}";
-  if (level >= 40) return "\u26A0\uFE0F";
-  if (level >= 30) return "\u2139\uFE0F";
-  if (level >= 20) return "\u{1F41B}";
-  return "\u{1F50D}";
-}
-function getLevelColor2(level) {
-  if (level >= 60) return "#ff0000";
-  if (level >= 50) return "#ff4444";
-  if (level >= 40) return "#ffbb33";
-  if (level >= 30) return "#33b5e5";
-  if (level >= 20) return "#99cc00";
-  return "#aa66cc";
-}
-
-// src/transports/webhook.ts
-function webhookTransport(options) {
-  const {
-    url,
-    method = "POST",
-    headers = {},
-    batchSize = 1,
-    flushIntervalMs = 5e3,
-    retry = false,
-    maxRetries = 3
-  } = options;
-  const serialize = options.serializer ?? ((entries) => JSON.stringify({
-    entries,
-    count: entries.length,
-    timestamp: Date.now()
-  }));
-  let buffer = [];
-  let flushTimer = null;
-  async function sendBatch(entries, attempt = 0) {
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          ...headers
-        },
-        body: serialize(entries)
-      });
-      if (!response.ok && retry && attempt < maxRetries) {
-        const delay = Math.min(1e3 * 2 ** attempt, 3e4);
-        await new Promise((r) => setTimeout(r, delay));
-        return sendBatch(entries, attempt + 1);
-      }
-    } catch {
-      if (retry && attempt < maxRetries) {
-        const delay = Math.min(1e3 * 2 ** attempt, 3e4);
-        await new Promise((r) => setTimeout(r, delay));
-        return sendBatch(entries, attempt + 1);
-      }
-    }
-  }
-  function scheduleFlush() {
-    if (flushTimer) return;
-    flushTimer = setTimeout(() => {
-      flushTimer = null;
-      doFlush();
-    }, flushIntervalMs);
-  }
-  function doFlush() {
-    if (buffer.length === 0) return;
-    const batch = buffer;
-    buffer = [];
-    sendBatch(batch).catch(() => {
-    });
-  }
-  return {
-    name: "webhook",
-    level: options.level,
-    write(entry) {
-      buffer.push(entry);
-      if (buffer.length >= batchSize) {
-        doFlush();
-      } else {
-        scheduleFlush();
-      }
-    },
-    async flush() {
-      if (flushTimer) {
-        clearTimeout(flushTimer);
-        flushTimer = null;
-      }
-      if (buffer.length > 0) {
-        const batch = buffer;
-        buffer = [];
-        await sendBatch(batch);
-      }
-    },
-    async close() {
-      await this.flush?.();
-    }
-  };
-}
 export {
   LogLevel,
   LogLevelNameMap,