@oxog/log 1.0.0

package/dist/index.js

@@ -0,0 +1,1784 @@
+// src/logger.ts
+import { createKernel } from "@oxog/plugin";
+import { createEmitter } from "@oxog/emitter";
+import { pigment } from "@oxog/pigment";
+
+// src/types.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Trace"] = 10] = "Trace";
+  LogLevel2[LogLevel2["Debug"] = 20] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 30] = "Info";
+  LogLevel2[LogLevel2["Warn"] = 40] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 50] = "Error";
+  LogLevel2[LogLevel2["Fatal"] = 60] = "Fatal";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/constants.ts
+var LOG_LEVELS = {
+  trace: 10 /* Trace */,
+  debug: 20 /* Debug */,
+  info: 30 /* Info */,
+  warn: 40 /* Warn */,
+  error: 50 /* Error */,
+  fatal: 60 /* Fatal */
+};
+var LEVEL_NAMES = {
+  [10 /* Trace */]: "trace",
+  [20 /* Debug */]: "debug",
+  [30 /* Info */]: "info",
+  [40 /* Warn */]: "warn",
+  [50 /* Error */]: "error",
+  [60 /* Fatal */]: "fatal"
+};
+var LEVEL_ORDER = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal"
+];
+var DEFAULT_NAME = "app";
+var DEFAULT_LEVEL = "info";
+var DEFAULT_FORMAT = "auto";
+var DEFAULT_COLORS = true;
+var DEFAULT_TIMESTAMP = true;
+var DEFAULT_SOURCE = false;
+var DEFAULT_SYNC_LEVELS = {
+  trace: false,
+  debug: false,
+  info: false,
+  warn: false,
+  error: true,
+  fatal: true
+};
+var DEFAULT_BUFFER_OPTIONS = {
+  size: 100,
+  flushInterval: 1e3
+};
+var LEVEL_COLORS = {
+  trace: "gray",
+  debug: "cyan",
+  info: "blue",
+  warn: "yellow",
+  error: "red",
+  fatal: "magenta"
+};
+var LEVEL_LABELS = {
+  trace: "TRACE",
+  debug: "DEBUG",
+  info: "INFO ",
+  warn: "WARN ",
+  error: "ERROR",
+  fatal: "FATAL"
+};
+var REDACTED_VALUE = "[REDACTED]";
+var COMMON_SENSITIVE_FIELDS = [
+  "password",
+  "token",
+  "secret",
+  "apiKey",
+  "api_key",
+  "apikey",
+  "authorization",
+  "auth",
+  "credential",
+  "credentials",
+  "ssn",
+  "creditCard",
+  "credit_card",
+  "creditcard",
+  "cvv",
+  "pin"
+];
+function parseSize(size) {
+  const match = size.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)?$/i);
+  if (!match) {
+    throw new Error(`Invalid size format: ${size}`);
+  }
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || "B").toUpperCase();
+  const units = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+    TB: 1024 * 1024 * 1024 * 1024
+  };
+  return Math.floor(value * (units[unit] ?? 1));
+}
+function parseRotation(rotation) {
+  const match = rotation.match(/^(\d+)\s*(s|m|h|d|w)?$/i);
+  if (!match) {
+    throw new Error(`Invalid rotation format: ${rotation}`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = (match[2] || "s").toLowerCase();
+  const units = {
+    s: 1e3,
+    m: 60 * 1e3,
+    h: 60 * 60 * 1e3,
+    d: 24 * 60 * 60 * 1e3,
+    w: 7 * 24 * 60 * 60 * 1e3
+  };
+  return value * (units[unit] ?? 1e3);
+}
+var IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var IS_BROWSER = typeof window !== "undefined" && typeof window.document !== "undefined";
+var IS_DEV = IS_NODE && process.env["NODE_ENV"] !== "production";
+var IS_TTY = IS_NODE && process.stdout?.isTTY === true;
+
+// src/utils/env.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function isDev() {
+  if (!isNode()) return false;
+  return process.env["NODE_ENV"] !== "production";
+}
+function isTTY() {
+  if (!isNode()) return false;
+  return process.stdout?.isTTY === true;
+}
+function shouldUseColors() {
+  if (isBrowser()) return true;
+  if (!isNode()) return false;
+  if (process.env["NO_COLOR"] !== void 0) return false;
+  if (process.env["FORCE_COLOR"] !== void 0) return true;
+  if (process.env["CI"] !== void 0) return true;
+  return isTTY();
+}
+function getEnvironment() {
+  if (!isNode()) return "browser";
+  return process.env["NODE_ENV"] || "development";
+}
+function getCwd() {
+  if (!isNode()) return void 0;
+  return process.cwd();
+}
+
+// src/utils/format.ts
+function formatJson(entry) {
+  return JSON.stringify(entry, jsonReplacer);
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Error) {
+    const errorObj = value;
+    const result = {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+    for (const key of Object.keys(errorObj)) {
+      if (!(key in result)) {
+        result[key] = errorObj[key];
+      }
+    }
+    return result;
+  }
+  if (typeof value === "object" && value !== null) {
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof Map) {
+      return Object.fromEntries(value);
+    }
+    if (value instanceof Set) {
+      return Array.from(value);
+    }
+  }
+  return value;
+}
+function safeStringify(value, indent2) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    value,
+    (_key, val) => {
+      const replaced = jsonReplacer(_key, val);
+      if (typeof replaced === "object" && replaced !== null) {
+        if (seen.has(replaced)) {
+          return "[Circular]";
+        }
+        seen.add(replaced);
+      }
+      return replaced;
+    },
+    indent2
+  );
+}
+function formatPretty(entry, pigment2, options = {}) {
+  const parts = [];
+  const { timestamp = true, source = true } = options;
+  if (timestamp && entry.time) {
+    const time = formatTime(entry.time);
+    parts.push(pigment2 ? pigment2.gray(`[${time}]`) : `[${time}]`);
+  }
+  const levelLabel = LEVEL_LABELS[entry.levelName] || entry.levelName.toUpperCase();
+  const levelColor = LEVEL_COLORS[entry.levelName] || "white";
+  if (pigment2) {
+    const colorFn = pigment2[levelColor];
+    parts.push(colorFn ? colorFn(levelLabel) : levelLabel);
+  } else {
+    parts.push(levelLabel);
+  }
+  if (source && entry.file) {
+    const location = entry.line ? `${entry.file}:${entry.line}` : entry.file;
+    parts.push(pigment2 ? pigment2.dim(`(${location})`) : `(${location})`);
+  }
+  if (entry.msg) {
+    parts.push(entry.msg);
+  }
+  const extra = getExtraFields(entry);
+  if (Object.keys(extra).length > 0) {
+    const extraStr = safeStringify(extra);
+    parts.push(pigment2 ? pigment2.dim(extraStr) : extraStr);
+  }
+  if (entry.err?.stack) {
+    parts.push("\n" + (pigment2 ? pigment2.red(entry.err.stack) : entry.err.stack));
+  }
+  return parts.join(" ");
+}
+function getExtraFields(entry) {
+  const standardFields = /* @__PURE__ */ new Set([
+    "level",
+    "levelName",
+    "time",
+    "msg",
+    "file",
+    "line",
+    "column",
+    "correlationId",
+    "duration",
+    "err",
+    "name"
+  ]);
+  const extra = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (!standardFields.has(key)) {
+      extra[key] = value;
+    }
+  }
+  return extra;
+}
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+function formatIso(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let unitIndex = 0;
+  let value = bytes;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(unitIndex > 0 ? 2 : 0)} ${units[unitIndex]}`;
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+function indent(str, spaces = 2) {
+  const pad = " ".repeat(spaces);
+  return str.split("\n").map((line) => pad + line).join("\n");
+}
+
+// src/transports/console.ts
+var DEFAULT_LEVEL_COLORS = {
+  trace: "gray",
+  debug: "cyan",
+  info: "blue",
+  warn: "yellow",
+  error: "red",
+  fatal: "magenta"
+};
+function consoleTransport(options = {}) {
+  const {
+    colors = shouldUseColors(),
+    timestamp = true,
+    levelColors = {}
+  } = options;
+  const mergedColors = { ...DEFAULT_LEVEL_COLORS, ...levelColors };
+  let pigment2;
+  return {
+    name: "console",
+    write(entry) {
+      let output;
+      if (isBrowser()) {
+        writeToBrowserConsole(entry, colors);
+        return;
+      }
+      if (colors && pigment2) {
+        output = formatPretty(entry, pigment2, { timestamp, source: true });
+      } else if (colors) {
+        output = formatWithAnsi(entry, mergedColors, timestamp);
+      } else {
+        output = formatJson(entry);
+      }
+      if (entry.level >= 50) {
+        process.stderr.write(output + "\n");
+      } else {
+        process.stdout.write(output + "\n");
+      }
+    },
+    flush() {
+    },
+    close() {
+    },
+    supports(env) {
+      return true;
+    }
+  };
+}
+function formatWithAnsi(entry, levelColors, showTimestamp) {
+  const parts = [];
+  if (showTimestamp && entry.time) {
+    const time = formatTime2(entry.time);
+    parts.push(`\x1B[90m[${time}]\x1B[0m`);
+  }
+  const color = getAnsiColor(levelColors[entry.levelName] || "white");
+  const levelLabel = entry.levelName.toUpperCase().padEnd(5);
+  parts.push(`${color}${levelLabel}\x1B[0m`);
+  if (entry.file) {
+    const location = entry.line ? `${entry.file}:${entry.line}` : entry.file;
+    parts.push(`\x1B[90m(${location})\x1B[0m`);
+  }
+  if (entry.msg) {
+    parts.push(entry.msg);
+  }
+  const extra = getExtraFields2(entry);
+  if (Object.keys(extra).length > 0) {
+    parts.push(`\x1B[90m${JSON.stringify(extra)}\x1B[0m`);
+  }
+  if (entry.err?.stack) {
+    parts.push("\n\x1B[31m" + entry.err.stack + "\x1B[0m");
+  }
+  return parts.join(" ");
+}
+function getAnsiColor(colorName) {
+  const colors = {
+    black: "\x1B[30m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m",
+    gray: "\x1B[90m",
+    grey: "\x1B[90m"
+  };
+  return colors[colorName] || "\x1B[0m";
+}
+function formatTime2(timestamp) {
+  const date = new Date(timestamp);
+  return date.toTimeString().slice(0, 8);
+}
+function getExtraFields2(entry) {
+  const standardFields = /* @__PURE__ */ new Set([
+    "level",
+    "levelName",
+    "time",
+    "msg",
+    "file",
+    "line",
+    "column",
+    "correlationId",
+    "duration",
+    "err",
+    "name"
+  ]);
+  const extra = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (!standardFields.has(key)) {
+      extra[key] = value;
+    }
+  }
+  return extra;
+}
+function writeToBrowserConsole(entry, styled) {
+  const method = getConsoleMethod(entry.levelName);
+  const consoleObj = console;
+  if (styled) {
+    const styles = getBrowserStyles(entry.levelName);
+    const label = `%c[${entry.levelName.toUpperCase()}]`;
+    const extra = getExtraFields2(entry);
+    if (Object.keys(extra).length > 0) {
+      consoleObj[method](label, styles, entry.msg, extra);
+    } else {
+      consoleObj[method](label, styles, entry.msg);
+    }
+  } else {
+    consoleObj[method](`[${entry.levelName.toUpperCase()}]`, entry.msg, entry);
+  }
+}
+function getConsoleMethod(levelName) {
+  switch (levelName) {
+    case "trace":
+    case "debug":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+    case "fatal":
+      return "error";
+    default:
+      return "log";
+  }
+}
+function getBrowserStyles(levelName) {
+  const colors = {
+    trace: "#888888",
+    debug: "#00bcd4",
+    info: "#2196f3",
+    warn: "#ff9800",
+    error: "#f44336",
+    fatal: "#9c27b0"
+  };
+  return `color: ${colors[levelName]}; font-weight: bold;`;
+}
+
+// src/plugins/core/level.ts
+function levelPlugin() {
+  return {
+    name: "level",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (ctx.level === void 0) {
+        ctx.level = LOG_LEVELS.info;
+      }
+    }
+  };
+}
+
+// src/plugins/core/format.ts
+function formatPlugin() {
+  return {
+    name: "format",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (ctx.format === void 0) {
+        ctx.format = detectFormat();
+      } else if (ctx.format === "auto") {
+        ctx.format = detectFormat();
+      }
+    }
+  };
+}
+function detectFormat() {
+  if (isDev() && isTTY()) {
+    return "pretty";
+  }
+  return "json";
+}
+
+// src/plugins/core/timestamp.ts
+function timestampPlugin() {
+  return {
+    name: "timestamp",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (ctx.timestamp === void 0) {
+        ctx.timestamp = true;
+      }
+    }
+  };
+}
+
+// src/errors.ts
+var LogError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Original error if wrapping another error */
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "LogError";
+    this.code = code;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var PluginError = class extends LogError {
+  /** Name of the plugin that caused the error */
+  pluginName;
+  constructor(message, pluginName, cause) {
+    super(`[Plugin: ${pluginName}] ${message}`, "PLUGIN_ERROR", cause);
+    this.name = "PluginError";
+    this.pluginName = pluginName;
+  }
+};
+var TransportError = class extends LogError {
+  /** Name of the transport that caused the error */
+  transportName;
+  constructor(message, transportName, cause) {
+    super(`[Transport: ${transportName}] ${message}`, "TRANSPORT_ERROR", cause);
+    this.name = "TransportError";
+    this.transportName = transportName;
+  }
+};
+var ConfigError = class extends LogError {
+  /** Configuration option that caused the error */
+  option;
+  constructor(message, option, cause) {
+    super(message, "CONFIG_ERROR", cause);
+    this.name = "ConfigError";
+    this.option = option;
+  }
+};
+var SerializationError = class extends LogError {
+  constructor(message, cause) {
+    super(message, "SERIALIZATION_ERROR", cause);
+    this.name = "SerializationError";
+  }
+};
+var EnvironmentError = class extends LogError {
+  /** Required environment */
+  requiredEnv;
+  constructor(message, requiredEnv, cause) {
+    super(message, "ENVIRONMENT_ERROR", cause);
+    this.name = "EnvironmentError";
+    this.requiredEnv = requiredEnv;
+  }
+};
+var BufferError = class extends LogError {
+  constructor(message, cause) {
+    super(message, "BUFFER_ERROR", cause);
+    this.name = "BufferError";
+  }
+};
+function ensureError(value) {
+  if (value instanceof Error) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new Error(value);
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if (typeof obj["message"] === "string") {
+      const err = new Error(obj["message"]);
+      if (typeof obj["name"] === "string") {
+        err.name = obj["name"];
+      }
+      return err;
+    }
+  }
+  return new Error(String(value));
+}
+function wrapError(error, message) {
+  const cause = ensureError(error);
+  return new LogError(`${message}: ${cause.message}`, "WRAPPED_ERROR", cause);
+}
+
+// src/logger.ts
+function createLogger(options = {}) {
+  const {
+    name = DEFAULT_NAME,
+    level = DEFAULT_LEVEL,
+    format = DEFAULT_FORMAT,
+    colors = true,
+    transports = [],
+    redact = [],
+    source = false,
+    timestamp = true,
+    sync = { fatal: true, error: true },
+    buffer,
+    context: initialContext = {},
+    plugins = []
+  } = options;
+  if (!(level in LOG_LEVELS)) {
+    throw new ConfigError(`Invalid log level: ${level}`, "level");
+  }
+  const emitter = createEmitter();
+  const activeTransports = [];
+  const env = getEnvironment();
+  if (transports.length === 0) {
+    activeTransports.push(consoleTransport({ colors }));
+  } else {
+    for (const transport of transports) {
+      if (!transport.supports || transport.supports(env)) {
+        activeTransports.push(transport);
+      }
+    }
+  }
+  const kernelContext = {
+    name,
+    level: LOG_LEVELS[level],
+    format: resolveFormat(format),
+    colors,
+    timestamp,
+    source,
+    transports: activeTransports,
+    redactPaths: redact,
+    bindings: { ...initialContext },
+    correlationId: void 0,
+    pigment,
+    emitter,
+    syncLevels: {
+      trace: sync.trace ?? false,
+      debug: sync.debug ?? false,
+      info: sync.info ?? false,
+      warn: sync.warn ?? false,
+      error: sync.error ?? true,
+      fatal: sync.fatal ?? true
+    },
+    bufferOptions: buffer ?? {},
+    timers: /* @__PURE__ */ new Map(),
+    buffer: [],
+    flushTimerId: void 0
+  };
+  const kernel = createKernel({ context: kernelContext });
+  kernel.use(levelPlugin());
+  kernel.use(formatPlugin());
+  kernel.use(timestampPlugin());
+  for (const plugin of plugins) {
+    kernel.use(plugin);
+  }
+  let closed = false;
+  async function writeToTransports(entry) {
+    if (closed) return;
+    const promises = [];
+    for (const transport of activeTransports) {
+      try {
+        const result = transport.write(entry);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (err) {
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.all(promises).catch(() => {
+      });
+    }
+  }
+  function createEntry(levelNum, levelName, msg, data, error) {
+    const ctx = kernel.getContext();
+    const entry = {
+      level: levelNum,
+      levelName,
+      time: Date.now(),
+      msg,
+      ...ctx.bindings,
+      ...data
+    };
+    if (error) {
+      entry.err = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    if (ctx.correlationId) {
+      entry.correlationId = ctx.correlationId;
+    }
+    return entry;
+  }
+  function isEnabled(levelNum) {
+    const ctx = kernel.getContext();
+    return levelNum >= ctx.level;
+  }
+  function shouldSync(levelName) {
+    const ctx = kernel.getContext();
+    return ctx.syncLevels[levelName] ?? false;
+  }
+  function log(levelNum, levelName, msgOrObj, msgOrUndefined) {
+    if (!isEnabled(levelNum)) return;
+    let msg;
+    let data;
+    let error;
+    if (typeof msgOrObj === "string") {
+      msg = msgOrObj;
+    } else if (msgOrObj instanceof Error) {
+      msg = msgOrUndefined ?? msgOrObj.message;
+      error = msgOrObj;
+    } else {
+      msg = msgOrUndefined ?? "";
+      data = msgOrObj;
+    }
+    const entry = createEntry(levelNum, levelName, msg, data, error);
+    emitter.emit("log", entry);
+    emitter.emit(`log:${levelName}`, entry);
+    if (shouldSync(levelName)) {
+      writeToTransports(entry).catch(() => {
+      });
+    } else {
+      writeToTransports(entry).catch(() => {
+      });
+    }
+  }
+  const logger = {
+    // Log methods with overloads
+    trace(msgOrObj, msg) {
+      log(LOG_LEVELS.trace, "trace", msgOrObj, msg);
+    },
+    debug(msgOrObj, msg) {
+      log(LOG_LEVELS.debug, "debug", msgOrObj, msg);
+    },
+    info(msgOrObj, msg) {
+      log(LOG_LEVELS.info, "info", msgOrObj, msg);
+    },
+    warn(msgOrObj, msg) {
+      log(LOG_LEVELS.warn, "warn", msgOrObj, msg);
+    },
+    error(msgOrObj, msg) {
+      log(LOG_LEVELS.error, "error", msgOrObj, msg);
+    },
+    fatal(msgOrObj, msg) {
+      log(LOG_LEVELS.fatal, "fatal", msgOrObj, msg);
+    },
+    // Level management
+    getLevel() {
+      const ctx = kernel.getContext();
+      return LEVEL_NAMES[ctx.level] ?? "info";
+    },
+    setLevel(newLevel) {
+      if (!(newLevel in LOG_LEVELS)) {
+        throw new ConfigError(`Invalid log level: ${newLevel}`, "level");
+      }
+      const ctx = kernel.getContext();
+      ctx.level = LOG_LEVELS[newLevel];
+    },
+    isLevelEnabled(levelName) {
+      return isEnabled(LOG_LEVELS[levelName]);
+    },
+    // Child logger
+    child(bindings) {
+      const ctx = kernel.getContext();
+      return createLogger({
+        ...options,
+        context: { ...ctx.bindings, ...bindings },
+        transports: activeTransports
+      });
+    },
+    // Correlation
+    withCorrelation(id) {
+      const ctx = kernel.getContext();
+      const correlationId = id ?? generateCorrelationId();
+      const childLogger = createLogger({
+        ...options,
+        context: { ...ctx.bindings },
+        transports: activeTransports
+      });
+      const childCtx = childLogger._getContext?.();
+      if (childCtx) {
+        childCtx.correlationId = correlationId;
+      }
+      return childLogger;
+    },
+    // Timing
+    time(label) {
+      const ctx = kernel.getContext();
+      ctx.timers.set(label, performance.now());
+    },
+    timeEnd(label) {
+      const ctx = kernel.getContext();
+      const start = ctx.timers.get(label);
+      if (start === void 0) {
+        logger.warn(`Timer '${label}' does not exist`);
+        return;
+      }
+      const duration = performance.now() - start;
+      ctx.timers.delete(label);
+      logger.debug({ label, duration }, `${label}: ${duration.toFixed(2)}ms`);
+    },
+    async timeAsync(label, fn) {
+      const start = performance.now();
+      try {
+        return await fn();
+      } finally {
+        const duration = performance.now() - start;
+        logger.debug({ label, duration }, `${label}: ${duration.toFixed(2)}ms`);
+      }
+    },
+    startTimer(label) {
+      const start = performance.now();
+      return () => {
+        const duration = performance.now() - start;
+        logger.debug({ label, duration }, `${label}: ${duration.toFixed(2)}ms`);
+      };
+    },
+    // Plugin management
+    use(plugin) {
+      kernel.use(plugin);
+      return logger;
+    },
+    unregister(pluginName) {
+      return kernel.unregister(pluginName);
+    },
+    hasPlugin(pluginName) {
+      return kernel.has(pluginName);
+    },
+    listPlugins() {
+      return kernel.list();
+    },
+    // Event handling
+    on(event, handler) {
+      return emitter.on(event, handler);
+    },
+    // Lifecycle
+    async flush() {
+      const promises = [];
+      for (const transport of activeTransports) {
+        if (transport.flush) {
+          try {
+            const result = transport.flush();
+            if (result instanceof Promise) {
+              promises.push(result);
+            }
+          } catch {
+          }
+        }
+      }
+      await Promise.all(promises);
+      emitter.emit("flush", void 0);
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      await logger.flush();
+      const promises = [];
+      for (const transport of activeTransports) {
+        if (transport.close) {
+          try {
+            const result = transport.close();
+            if (result instanceof Promise) {
+              promises.push(result);
+            }
+          } catch {
+          }
+        }
+      }
+      await Promise.all(promises);
+      kernel.destroy();
+      emitter.emit("close", void 0);
+    },
+    async destroy() {
+      return logger.close();
+    },
+    // Internal method for getting context
+    _getContext() {
+      return kernel.getContext();
+    }
+  };
+  return logger;
+}
+function resolveFormat(format) {
+  if (format !== "auto") {
+    return format;
+  }
+  if (isNode()) {
+    return process.stdout?.isTTY ? "pretty" : "json";
+  }
+  return "pretty";
+}
+function generateCorrelationId() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/transports/file.ts
+function fileTransport(options) {
+  if (!isNode()) {
+    throw new EnvironmentError("File transport is only available in Node.js", "node");
+  }
+  const {
+    path: filePath,
+    rotate,
+    maxSize,
+    maxFiles = 5,
+    compress = false
+  } = options;
+  const maxSizeBytes = maxSize ? parseSize(maxSize) : void 0;
+  const rotationMs = rotate ? parseRotation(rotate) : void 0;
+  let currentSize = 0;
+  let lastRotation = Date.now();
+  let writeStream = null;
+  let fs = null;
+  let path = null;
+  let zlib = null;
+  async function ensureModules() {
+    if (!fs) {
+      fs = await import("fs");
+      path = await import("path");
+      if (compress) {
+        zlib = await import("zlib");
+      }
+    }
+  }
+  async function ensureStream() {
+    await ensureModules();
+    if (!writeStream) {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      if (fs.existsSync(filePath)) {
+        const stats = fs.statSync(filePath);
+        currentSize = stats.size;
+      }
+      writeStream = fs.createWriteStream(filePath, { flags: "a" });
+    }
+    return writeStream;
+  }
+  function shouldRotate() {
+    if (maxSizeBytes && currentSize >= maxSizeBytes) {
+      return true;
+    }
+    if (rotationMs && Date.now() - lastRotation >= rotationMs) {
+      return true;
+    }
+    return false;
+  }
+  async function performRotation() {
+    await ensureModules();
+    if (!writeStream) return;
+    await new Promise((resolve, reject) => {
+      writeStream.once("finish", resolve);
+      writeStream.once("error", reject);
+      writeStream.end();
+    });
+    writeStream = null;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const ext = path.extname(filePath);
+    const base = filePath.slice(0, -ext.length);
+    const rotatedPath = `${base}.${timestamp}${ext}`;
+    fs.renameSync(filePath, rotatedPath);
+    if (compress && zlib) {
+      const gzPath = `${rotatedPath}.gz`;
+      const input = fs.createReadStream(rotatedPath);
+      const output = fs.createWriteStream(gzPath);
+      const gzip = zlib.createGzip();
+      await new Promise((resolve, reject) => {
+        input.pipe(gzip).pipe(output);
+        output.on("finish", () => {
+          fs.unlinkSync(rotatedPath);
+          resolve();
+        });
+        output.on("error", reject);
+      });
+    }
+    await cleanupOldFiles();
+    currentSize = 0;
+    lastRotation = Date.now();
+  }
+  async function cleanupOldFiles() {
+    await ensureModules();
+    const dir = path.dirname(filePath);
+    const baseName = path.basename(filePath);
+    const ext = path.extname(filePath);
+    const prefix = baseName.slice(0, -ext.length);
+    const files = fs.readdirSync(dir).filter((f) => f.startsWith(prefix) && f !== baseName).map((f) => ({
+      name: f,
+      path: path.join(dir, f),
+      mtime: fs.statSync(path.join(dir, f)).mtime.getTime()
+    })).sort((a, b) => b.mtime - a.mtime);
+    while (files.length > maxFiles) {
+      const file = files.pop();
+      fs.unlinkSync(file.path);
+    }
+  }
+  return {
+    name: "file",
+    async write(entry) {
+      if (shouldRotate()) {
+        await performRotation();
+      }
+      const stream = await ensureStream();
+      const line = formatJson(entry) + "\n";
+      const bytes = Buffer.byteLength(line, "utf8");
+      return new Promise((resolve, reject) => {
+        stream.write(line, (err) => {
+          if (err) {
+            reject(new TransportError(`Failed to write to file: ${err.message}`, "file", err));
+          } else {
+            currentSize += bytes;
+            resolve();
+          }
+        });
+      });
+    },
+    async flush() {
+      if (writeStream && "flush" in writeStream) {
+        return new Promise((resolve) => {
+          writeStream.flush(resolve);
+        });
+      }
+    },
+    async close() {
+      if (writeStream) {
+        await new Promise((resolve, reject) => {
+          writeStream.once("finish", resolve);
+          writeStream.once("error", reject);
+          writeStream.end();
+        });
+        writeStream = null;
+      }
+    },
+    supports(env) {
+      return env === "node";
+    }
+  };
+}
+
+// src/transports/stream.ts
+function streamTransport(options) {
+  if (!isNode()) {
+    throw new EnvironmentError("Stream transport is only available in Node.js", "node");
+  }
+  const { stream } = options;
+  if (!stream) {
+    throw new TransportError("Stream is required", "stream");
+  }
+  let closed = false;
+  return {
+    name: "stream",
+    write(entry) {
+      if (closed) {
+        return Promise.reject(new TransportError("Stream is closed", "stream"));
+      }
+      const line = formatJson(entry) + "\n";
+      return new Promise((resolve, reject) => {
+        const canWrite = stream.write(line, (err) => {
+          if (err) {
+            reject(new TransportError(`Failed to write to stream: ${err.message}`, "stream", err));
+          } else {
+            resolve();
+          }
+        });
+        if (!canWrite) {
+          stream.once("drain", () => {
+            resolve();
+          });
+        }
+      });
+    },
+    flush() {
+      return Promise.resolve();
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      return new Promise((resolve, reject) => {
+        stream.once("finish", resolve);
+        stream.once("error", (err) => {
+          reject(new TransportError(`Failed to close stream: ${err.message}`, "stream", err));
+        });
+        stream.end();
+      });
+    },
+    supports(env) {
+      return env === "node";
+    }
+  };
+}
+
+// src/transports/http.ts
+function httpTransport(options) {
+  const {
+    url,
+    method = "POST",
+    headers = {},
+    batch = 100,
+    interval = 5e3,
+    retry = 3
+  } = options;
+  if (!url) {
+    throw new TransportError("URL is required", "http");
+  }
+  let buffer = [];
+  let flushTimer = null;
+  let isFlushing = false;
+  let closed = false;
+  function startFlushInterval() {
+    if (flushTimer) return;
+    if (interval > 0) {
+      flushTimer = setInterval(() => {
+        flushBuffer2().catch(() => {
+        });
+      }, interval);
+    }
+  }
+  function stopFlushInterval() {
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+  }
+  async function flushBuffer2() {
+    if (isFlushing || buffer.length === 0) return;
+    isFlushing = true;
+    const entries = buffer;
+    buffer = [];
+    try {
+      await sendWithRetry(entries);
+    } catch (err) {
+      buffer = [...entries, ...buffer].slice(0, batch * 2);
+      throw err;
+    } finally {
+      isFlushing = false;
+    }
+  }
+  async function sendWithRetry(entries) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= retry; attempt++) {
+      try {
+        await sendEntries(entries);
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < retry) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          await sleep(delay);
+        }
+      }
+    }
+    throw new TransportError(
+      `Failed to send logs after ${retry + 1} attempts: ${lastError?.message}`,
+      "http",
+      lastError || void 0
+    );
+  }
+  async function sendEntries(entries) {
+    const body = JSON.stringify(entries);
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  let started = false;
+  return {
+    name: "http",
+    async write(entry) {
+      if (closed) {
+        throw new TransportError("Transport is closed", "http");
+      }
+      if (!started) {
+        started = true;
+        startFlushInterval();
+      }
+      buffer.push(entry);
+      if (buffer.length >= batch) {
+        await flushBuffer2();
+      }
+    },
+    async flush() {
+      await flushBuffer2();
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      stopFlushInterval();
+      if (buffer.length > 0) {
+        try {
+          await flushBuffer2();
+        } catch {
+        }
+      }
+    },
+    supports(_env) {
+      return typeof fetch !== "undefined";
+    }
+  };
+}
+
+// src/transports/localStorage.ts
+function localStorageTransport(options) {
+  if (!isBrowser()) {
+    throw new EnvironmentError("LocalStorage transport is only available in browser", "browser");
+  }
+  const {
+    key,
+    maxSize = "1MB",
+    levels
+  } = options;
+  if (!key) {
+    throw new TransportError("Key is required", "localStorage");
+  }
+  const maxBytes = parseSize(maxSize);
+  const allowedLevels = levels ? new Set(levels.map((l) => LOG_LEVELS[l])) : null;
+  function getStorage() {
+    return window.localStorage;
+  }
+  function loadLogs() {
+    try {
+      const data = getStorage().getItem(key);
+      if (!data) return [];
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  function saveLogs(logs) {
+    const data = JSON.stringify(logs);
+    while (data.length > maxBytes && logs.length > 0) {
+      logs.shift();
+    }
+    try {
+      getStorage().setItem(key, JSON.stringify(logs));
+    } catch (err) {
+      if (logs.length > 10) {
+        logs.splice(0, Math.floor(logs.length / 2));
+        saveLogs(logs);
+      }
+    }
+  }
+  function isLevelAllowed(level) {
+    if (!allowedLevels) return true;
+    return allowedLevels.has(level);
+  }
+  return {
+    name: "localStorage",
+    write(entry) {
+      if (!isLevelAllowed(entry.level)) {
+        return;
+      }
+      const logs = loadLogs();
+      logs.push(entry);
+      saveLogs(logs);
+    },
+    flush() {
+    },
+    close() {
+    },
+    supports(env) {
+      return env === "browser";
+    }
+  };
+}
+function readLogs(key) {
+  if (!isBrowser()) return [];
+  try {
+    const data = window.localStorage.getItem(key);
+    if (!data) return [];
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function clearLogs(key) {
+  if (!isBrowser()) return;
+  window.localStorage.removeItem(key);
+}
+function getStorageUsage(key) {
+  if (!isBrowser()) return 0;
+  const data = window.localStorage.getItem(key);
+  if (!data) return 0;
+  return data.length * 2;
+}
+
+// src/utils/redact.ts
+function redactFields(obj, paths, placeholder = REDACTED_VALUE) {
+  if (!obj || typeof obj !== "object" || paths.length === 0) {
+    return obj;
+  }
+  const result = deepClone(obj);
+  for (const path of paths) {
+    redactPath(result, path.split("."), placeholder);
+  }
+  return result;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Map) {
+    const result2 = /* @__PURE__ */ new Map();
+    for (const [key, value] of obj) {
+      result2.set(key, deepClone(value));
+    }
+    return result2;
+  }
+  if (obj instanceof Set) {
+    const result2 = /* @__PURE__ */ new Set();
+    for (const value of obj) {
+      result2.add(deepClone(value));
+    }
+    return result2;
+  }
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = deepClone(obj[key]);
+  }
+  return result;
+}
+function redactPath(obj, pathParts, placeholder) {
+  if (pathParts.length === 0 || !obj || typeof obj !== "object") {
+    return;
+  }
+  const [current, ...rest] = pathParts;
+  if (!current) return;
+  if (current === "*") {
+    for (const key of Object.keys(obj)) {
+      if (rest.length === 0) {
+        obj[key] = placeholder;
+      } else {
+        const value = obj[key];
+        if (value && typeof value === "object") {
+          redactPath(value, rest, placeholder);
+        }
+      }
+    }
+    return;
+  }
+  if (current === "[*]" && Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      if (rest.length === 0) {
+        obj[i] = placeholder;
+      } else {
+        const value = obj[i];
+        if (value && typeof value === "object") {
+          redactPath(value, rest, placeholder);
+        }
+      }
+    }
+    return;
+  }
+  if (!(current in obj)) {
+    return;
+  }
+  if (rest.length === 0) {
+    obj[current] = placeholder;
+  } else {
+    const value = obj[current];
+    if (value && typeof value === "object") {
+      redactPath(value, rest, placeholder);
+    }
+  }
+}
+function isSensitive(fieldName, sensitivePatterns) {
+  const lowerField = fieldName.toLowerCase();
+  return sensitivePatterns.some((pattern) => {
+    const lowerPattern = pattern.toLowerCase();
+    if (lowerField === lowerPattern) return true;
+    if (lowerField.includes(lowerPattern)) return true;
+    if (pattern.startsWith("/") && pattern.endsWith("/")) {
+      try {
+        const regex = new RegExp(pattern.slice(1, -1), "i");
+        return regex.test(fieldName);
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  });
+}
+function createRedactor(paths, placeholder = REDACTED_VALUE) {
+  return (obj) => redactFields(obj, paths, placeholder);
+}
+function autoRedact(obj, additionalPatterns = [], placeholder = REDACTED_VALUE) {
+  if (!obj || typeof obj !== "object") {
+    return obj;
+  }
+  const defaultPatterns = [
+    "password",
+    "passwd",
+    "pwd",
+    "secret",
+    "token",
+    "apikey",
+    "api_key",
+    "apiKey",
+    "auth",
+    "authorization",
+    "credential",
+    "credentials",
+    "private",
+    "privateKey",
+    "private_key"
+  ];
+  const patterns = [...defaultPatterns, ...additionalPatterns];
+  const result = deepClone(obj);
+  autoRedactRecursive(result, patterns, placeholder);
+  return result;
+}
+function autoRedactRecursive(obj, patterns, placeholder) {
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (isSensitive(key, patterns)) {
+      obj[key] = placeholder;
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      autoRedactRecursive(value, patterns, placeholder);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object") {
+          autoRedactRecursive(item, patterns, placeholder);
+        }
+      }
+    }
+  }
+}
+
+// src/plugins/optional/redact.ts
+function redactPlugin(options = {}) {
+  return {
+    name: "redact",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      const paths = options.paths || ctx.redactPaths || [];
+      const placeholder = options.placeholder || REDACTED_VALUE;
+      ctx.redactPaths = paths;
+      kernel.redact = (entry) => {
+        return redactEntry(entry, paths, placeholder);
+      };
+    }
+  };
+}
+function redactEntry(entry, paths, placeholder = REDACTED_VALUE) {
+  if (paths.length === 0) {
+    return entry;
+  }
+  return redactFields(entry, paths, placeholder);
+}
+
+// src/utils/source.ts
+function getSourceLocation(depth = 0) {
+  const err = new Error();
+  const stack = err.stack;
+  if (!stack) {
+    return void 0;
+  }
+  const frames = parseStack(stack);
+  const targetIndex = 2 + depth;
+  if (targetIndex >= frames.length) {
+    return void 0;
+  }
+  return frames[targetIndex];
+}
+function parseStack(stack) {
+  const lines = stack.split("\n");
+  const frames = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("at ")) {
+      continue;
+    }
+    const frame = parseV8Frame(trimmed);
+    if (frame) {
+      frames.push(frame);
+    }
+  }
+  return frames;
+}
+function parseV8Frame(line) {
+  let content = line.slice(3);
+  if (content.startsWith("async ")) {
+    content = content.slice(6);
+  }
+  const parenMatch = content.match(/^(.+?)\s+\((.+):(\d+):(\d+)\)$/);
+  if (parenMatch) {
+    const [, fn, path, lineStr, colStr] = parenMatch;
+    return {
+      fn: fn?.trim() || void 0,
+      path,
+      file: extractFileName(path || ""),
+      line: parseInt(lineStr || "0", 10),
+      column: parseInt(colStr || "0", 10)
+    };
+  }
+  const simpleMatch = content.match(/^(.+):(\d+):(\d+)$/);
+  if (simpleMatch) {
+    const [, path, lineStr, colStr] = simpleMatch;
+    return {
+      path,
+      file: extractFileName(path || ""),
+      line: parseInt(lineStr || "0", 10),
+      column: parseInt(colStr || "0", 10)
+    };
+  }
+  const noColMatch = content.match(/^(.+):(\d+)$/);
+  if (noColMatch) {
+    const [, path, lineStr] = noColMatch;
+    return {
+      path,
+      file: extractFileName(path || ""),
+      line: parseInt(lineStr || "0", 10)
+    };
+  }
+  return void 0;
+}
+function extractFileName(path) {
+  let cleanPath = path.replace(/^file:\/\//, "");
+  cleanPath = cleanPath.replace(/\\/g, "/");
+  cleanPath = cleanPath.split("?")[0]?.split("#")[0] || cleanPath;
+  const parts = cleanPath.split("/");
+  return parts[parts.length - 1] || cleanPath;
+}
+function isInternalFrame(location, internalPatterns = []) {
+  const defaultPatterns = [
+    "@oxog/log",
+    "node_modules",
+    "internal/",
+    "<anonymous>"
+  ];
+  const patterns = [...defaultPatterns, ...internalPatterns];
+  const pathToCheck = location.path || location.file;
+  return patterns.some((pattern) => {
+    if (pattern.includes("/") || pattern.includes("\\")) {
+      return pathToCheck.includes(pattern);
+    }
+    return location.file === pattern || location.file.includes(pattern);
+  });
+}
+function getCallerLocation(depth = 0, internalPatterns = []) {
+  const err = new Error();
+  const stack = err.stack;
+  if (!stack) {
+    return void 0;
+  }
+  const frames = parseStack(stack);
+  let skipped = 0;
+  for (const frame of frames) {
+    if (skipped < 2 + depth) {
+      skipped++;
+      continue;
+    }
+    if (!isInternalFrame(frame, internalPatterns)) {
+      return frame;
+    }
+  }
+  return void 0;
+}
+function formatLocation(location) {
+  let result = location.file;
+  if (location.line) {
+    result += `:${location.line}`;
+  }
+  if (location.column) {
+    result += `:${location.column}`;
+  }
+  return result;
+}
+
+// src/plugins/optional/source.ts
+function sourcePlugin(options = {}) {
+  return {
+    name: "source",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      ctx.source = true;
+      const depth = options.depth ?? 4;
+      kernel.getSource = () => {
+        return getSourceLocation(depth);
+      };
+    }
+  };
+}
+
+// src/plugins/optional/timing.ts
+function timingPlugin() {
+  return {
+    name: "timing",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (!ctx.timers) {
+        ctx.timers = /* @__PURE__ */ new Map();
+      }
+    },
+    onDestroy() {
+    }
+  };
+}
+
+// src/plugins/optional/correlation.ts
+var correlationOptions = {};
+function correlationPlugin(options = {}) {
+  return {
+    name: "correlation",
+    version: "1.0.0",
+    install(_kernel) {
+      correlationOptions = options;
+    }
+  };
+}
+
+// src/plugins/optional/buffer.ts
+function bufferPlugin(options = {}) {
+  return {
+    name: "buffer",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      ctx.buffer = [];
+      ctx.bufferOptions = {
+        size: options.size ?? DEFAULT_BUFFER_OPTIONS.size,
+        flushInterval: options.flushInterval ?? DEFAULT_BUFFER_OPTIONS.flushInterval
+      };
+      const flushInterval = ctx.bufferOptions.flushInterval ?? DEFAULT_BUFFER_OPTIONS.flushInterval;
+      if (flushInterval > 0) {
+        ctx.flushTimerId = setInterval(() => {
+          flushBuffer(ctx).catch(() => {
+          });
+        }, flushInterval);
+      }
+    },
+    async onDestroy() {
+    }
+  };
+}
+async function flushBuffer(ctx) {
+  if (ctx.buffer.length === 0) {
+    return [];
+  }
+  const entries = ctx.buffer;
+  ctx.buffer = [];
+  await Promise.all(
+    entries.flatMap(
+      (entry) => ctx.transports.map(
+        (transport) => Promise.resolve(transport.write(entry)).catch(() => {
+        })
+      )
+    )
+  );
+  ctx.emitter.emit("flush", void 0);
+  return entries;
+}
+
+// src/plugins/optional/browser.ts
+var browserOptions = {};
+function browserPlugin(options = {}) {
+  return {
+    name: "browser",
+    version: "1.0.0",
+    install(_kernel) {
+      browserOptions = options;
+    }
+  };
+}
+export {
+  BufferError,
+  COMMON_SENSITIVE_FIELDS,
+  ConfigError,
+  DEFAULT_BUFFER_OPTIONS,
+  DEFAULT_COLORS,
+  DEFAULT_FORMAT,
+  DEFAULT_LEVEL,
+  DEFAULT_NAME,
+  DEFAULT_SOURCE,
+  DEFAULT_SYNC_LEVELS,
+  DEFAULT_TIMESTAMP,
+  EnvironmentError,
+  IS_BROWSER,
+  IS_DEV,
+  IS_NODE,
+  IS_TTY,
+  LEVEL_COLORS,
+  LEVEL_LABELS,
+  LEVEL_NAMES,
+  LEVEL_ORDER,
+  LOG_LEVELS,
+  LogError,
+  LogLevel,
+  PluginError,
+  REDACTED_VALUE,
+  SerializationError,
+  TransportError,
+  autoRedact,
+  browserPlugin,
+  bufferPlugin,
+  clearLogs,
+  consoleTransport,
+  correlationPlugin,
+  createLogger,
+  createRedactor,
+  createLogger as default,
+  ensureError,
+  extractFileName,
+  fileTransport,
+  formatBytes,
+  formatDuration,
+  formatIso,
+  formatJson,
+  formatLocation,
+  formatPlugin,
+  formatPretty,
+  formatTime,
+  getCallerLocation,
+  getCwd,
+  getEnvironment,
+  getSourceLocation,
+  getStorageUsage,
+  httpTransport,
+  indent,
+  isBrowser,
+  isDev,
+  isNode,
+  isSensitive,
+  isTTY,
+  levelPlugin,
+  localStorageTransport,
+  parseRotation,
+  parseSize,
+  readLogs,
+  redactFields,
+  redactPlugin,
+  safeStringify,
+  shouldUseColors,
+  sourcePlugin,
+  streamTransport,
+  timestampPlugin,
+  timingPlugin,
+  truncate,
+  wrapError
+};
+//# sourceMappingURL=index.js.map