@statly/observe 1.2.0 → 1.2.1

package/dist/index.js

@@ -1,2788 +1,61 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/span.ts
-var Span, TraceContext;
-var init_span = __esm({
-  "src/span.ts"() {
-    "use strict";
-    Span = class {
-      constructor(name, context, tags) {
-        this._status = "ok" /* OK */;
-        this._tags = {};
-        this._metadata = {};
-        this._finished = false;
-        this.name = name;
-        this.context = context;
-        this.startTime = Date.now();
-        if (tags) this._tags = { ...tags };
-      }
-      /**
-       * Finish the span and calculate duration
-       */
-      finish(endTime) {
-        if (this._finished) return;
-        this._endTime = endTime || Date.now();
-        this._durationMs = this._endTime - this.startTime;
-        this._finished = true;
-      }
-      setTag(key, value) {
-        this._tags[key] = value;
-        return this;
-      }
-      setMetadata(key, value) {
-        this._metadata[key] = value;
-        return this;
-      }
-      setStatus(status) {
-        this._status = status;
-        return this;
-      }
-      get status() {
-        return this._status;
-      }
-      get tags() {
-        return { ...this._tags };
-      }
-      get durationMs() {
-        return this._durationMs;
-      }
-      toDict() {
-        return {
-          name: this.name,
-          traceId: this.context.traceId,
-          spanId: this.context.spanId,
-          parentId: this.context.parentId,
-          startTime: this.startTime,
-          endTime: this._endTime,
-          durationMs: this._durationMs,
-          status: this._status,
-          tags: this._tags,
-          metadata: this._metadata
-        };
-      }
-    };
-    TraceContext = class {
-      static getActiveSpan() {
-        return this.currentSpan;
-      }
-      static setActiveSpan(span) {
-        this.currentSpan = span;
-      }
-    };
-    TraceContext.currentSpan = null;
-  }
-});
-
-// src/telemetry.ts
-var telemetry_exports = {};
-__export(telemetry_exports, {
-  TelemetryProvider: () => TelemetryProvider,
-  trace: () => trace
-});
-async function trace(name, operation, tags) {
-  const provider = TelemetryProvider.getInstance();
-  const span = provider.startSpan(name, tags);
-  try {
-    const result = await operation(span);
-    return result;
-  } catch (error2) {
-    span.setStatus("error" /* ERROR */);
-    span.setTag("error", "true");
-    if (error2 instanceof Error) {
-      span.setTag("exception.type", error2.name);
-      span.setTag("exception.message", error2.message);
-    }
-    throw error2;
-  } finally {
-    provider.finishSpan(span);
-  }
-}
-var TelemetryProvider;
-var init_telemetry = __esm({
-  "src/telemetry.ts"() {
-    "use strict";
-    init_span();
-    TelemetryProvider = class _TelemetryProvider {
-      constructor() {
-        this.client = null;
-      }
-      static getInstance() {
-        if (!_TelemetryProvider.instance) {
-          _TelemetryProvider.instance = new _TelemetryProvider();
-        }
-        return _TelemetryProvider.instance;
-      }
-      setClient(client2) {
-        this.client = client2;
-      }
-      /**
-       * Start a new span
-       */
-      startSpan(name, tags) {
-        const parent = TraceContext.getActiveSpan();
-        const traceId = parent ? parent.context.traceId : this.generateId();
-        const parentId = parent ? parent.context.spanId : null;
-        const span = new Span(name, {
-          traceId,
-          spanId: this.generateId(),
-          parentId
-        }, tags);
-        TraceContext.setActiveSpan(span);
-        return span;
-      }
-      /**
-       * Finish and report a span
-       */
-      finishSpan(span) {
-        span.finish();
-        if (TraceContext.getActiveSpan() === span) {
-          TraceContext.setActiveSpan(null);
-        }
-        if (this.client) {
-          this.client.captureSpan(span);
-        }
-      }
-      generateId() {
-        return Math.random().toString(16).substring(2, 18);
-      }
-    };
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AIFeatures: () => AIFeatures,
-  ConsoleDestination: () => ConsoleDestination,
-  DEFAULT_LEVELS: () => DEFAULT_LEVELS,
-  EXTENDED_LEVELS: () => EXTENDED_LEVELS,
-  FileDestination: () => FileDestination,
-  LOG_LEVELS: () => LOG_LEVELS,
-  Logger: () => Logger,
-  ObserveDestination: () => ObserveDestination,
-  REDACTED: () => REDACTED,
-  SCRUB_PATTERNS: () => SCRUB_PATTERNS,
-  SENSITIVE_KEYS: () => SENSITIVE_KEYS,
-  Scrubber: () => Scrubber,
-  Statly: () => Statly,
-  StatlyClient: () => StatlyClient,
-  addBreadcrumb: () => addBreadcrumb,
-  captureException: () => captureException,
-  captureMessage: () => captureMessage,
-  captureNextJsError: () => captureNextJsError,
-  captureSpan: () => captureSpan,
-  close: () => close,
-  createRequestCapture: () => createRequestCapture,
-  expressErrorHandler: () => expressErrorHandler,
-  flush: () => flush,
-  formatJson: () => formatJson,
-  formatJsonPretty: () => formatJsonPretty,
-  formatPretty: () => formatPretty,
-  getClient: () => getClient,
-  getConsoleMethod: () => getConsoleMethod,
-  getDefaultLogger: () => getDefaultLogger,
-  init: () => init,
-  isSensitiveKey: () => isSensitiveKey,
-  logAudit: () => audit,
-  logDebug: () => debug,
-  logError: () => error,
-  logFatal: () => fatal,
-  logInfo: () => info,
-  logTrace: () => trace2,
-  logWarn: () => warn,
-  requestHandler: () => requestHandler,
-  setDefaultLogger: () => setDefaultLogger,
-  setTag: () => setTag,
-  setTags: () => setTags,
-  setUser: () => setUser,
-  startSpan: () => startSpan,
-  statlyFastifyPlugin: () => statlyFastifyPlugin,
-  statlyPlugin: () => statlyPlugin,
-  trace: () => trace3,
-  withStatly: () => withStatly,
-  withStatlyGetServerSideProps: () => withStatlyGetServerSideProps,
-  withStatlyGetStaticProps: () => withStatlyGetStaticProps,
-  withStatlyPagesApi: () => withStatlyPagesApi,
-  withStatlyServerAction: () => withStatlyServerAction
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/transport.ts
-var Transport = class {
-  constructor(options) {
-    this.queue = [];
-    this.isSending = false;
-    this.maxQueueSize = 100;
-    this.flushInterval = 5e3;
-    this.dsn = options.dsn;
-    this.debug = options.debug ?? false;
-    this.endpoint = this.parseEndpoint(options.dsn);
-    this.startFlushTimer();
-  }
-  parseEndpoint(dsn) {
-    try {
-      const url = new URL(dsn);
-      return `${url.protocol}//${url.host}/api/v1/observe/ingest`;
-    } catch {
-      return `https://statly.live/api/v1/observe/ingest`;
-    }
-  }
-  startFlushTimer() {
-    if (typeof window !== "undefined") {
-      this.flushTimer = setInterval(() => {
-        this.flush();
-      }, this.flushInterval);
-    }
-  }
-  /**
-   * Add an event to the queue
-   */
-  enqueue(event) {
-    if (this.queue.length >= this.maxQueueSize) {
-      this.queue.shift();
-      if (this.debug) {
-        console.warn("[Statly] Event queue full, dropping oldest event");
-      }
-    }
-    this.queue.push(event);
-    if (this.queue.length >= 10) {
-      this.flush();
-    }
-  }
-  /**
-   * Send a single event immediately
-   */
-  async send(event) {
-    return this.sendBatch([event]);
-  }
-  /**
-   * Flush all queued events
-   */
-  async flush() {
-    if (this.isSending || this.queue.length === 0) {
-      return;
-    }
-    this.isSending = true;
-    const events = [...this.queue];
-    this.queue = [];
-    try {
-      await this.sendBatch(events);
-    } catch (error2) {
-      this.queue = [...events, ...this.queue].slice(0, this.maxQueueSize);
-      if (this.debug) {
-        console.error("[Statly] Failed to send events:", error2);
-      }
-    } finally {
-      this.isSending = false;
-    }
-  }
-  /**
-   * Send a batch of events
-   */
-  async sendBatch(events) {
-    if (events.length === 0) {
-      return { success: true };
-    }
-    const payload = events.length === 1 ? events[0] : { events };
-    try {
-      const response = await fetch(this.endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Statly-DSN": this.dsn
-        },
-        body: JSON.stringify(payload),
-        // Use keepalive for better reliability during page unload
-        keepalive: true
-      });
-      if (!response.ok) {
-        const errorText = await response.text().catch(() => "Unknown error");
-        if (this.debug) {
-          console.error("[Statly] API error:", response.status, errorText);
-        }
-        return {
-          success: false,
-          status: response.status,
-          error: errorText
-        };
-      }
-      if (this.debug) {
-        console.log(`[Statly] Sent ${events.length} event(s)`);
-      }
-      return { success: true, status: response.status };
-    } catch (error2) {
-      if (this.debug) {
-        console.error("[Statly] Network error:", error2);
-      }
-      return {
-        success: false,
-        error: error2 instanceof Error ? error2.message : "Network error"
-      };
-    }
-  }
-  /**
-   * Clean up resources
-   */
-  destroy() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-    }
-    this.flush();
-  }
-};
-
-// src/breadcrumbs.ts
-var BreadcrumbManager = class {
-  constructor(maxBreadcrumbs = 100) {
-    this.breadcrumbs = [];
-    this.maxBreadcrumbs = maxBreadcrumbs;
-  }
-  /**
-   * Add a breadcrumb
-   */
-  add(breadcrumb) {
-    const crumb = {
-      timestamp: Date.now(),
-      ...breadcrumb
-    };
-    this.breadcrumbs.push(crumb);
-    if (this.breadcrumbs.length > this.maxBreadcrumbs) {
-      this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
-    }
-  }
-  /**
-   * Get all breadcrumbs
-   */
-  getAll() {
-    return [...this.breadcrumbs];
-  }
-  /**
-   * Clear all breadcrumbs
-   */
-  clear() {
-    this.breadcrumbs = [];
-  }
-  /**
-   * Set maximum breadcrumbs to keep
-   */
-  setMaxBreadcrumbs(max) {
-    this.maxBreadcrumbs = max;
-    if (this.breadcrumbs.length > max) {
-      this.breadcrumbs = this.breadcrumbs.slice(-max);
-    }
-  }
-};
-
-// src/integrations/global-handlers.ts
-var GlobalHandlers = class {
-  constructor(options = {}) {
-    this.originalOnError = null;
-    this.originalOnUnhandledRejection = null;
-    this.errorCallback = null;
-    this.handleUnhandledRejection = (event) => {
-      if (!this.errorCallback) {
-        return;
-      }
-      let error2;
-      if (event.reason instanceof Error) {
-        error2 = event.reason;
-      } else if (typeof event.reason === "string") {
-        error2 = new Error(event.reason);
-      } else {
-        error2 = new Error("Unhandled Promise Rejection");
-        error2.reason = event.reason;
-      }
-      this.errorCallback(error2, {
-        mechanism: { type: "onunhandledrejection", handled: false }
-      });
-    };
-    this.options = {
-      onerror: options.onerror !== false,
-      onunhandledrejection: options.onunhandledrejection !== false
-    };
-  }
-  /**
-   * Install global error handlers
-   */
-  install(callback) {
-    this.errorCallback = callback;
-    if (typeof window === "undefined") {
-      return;
-    }
-    if (this.options.onerror) {
-      this.installOnError();
-    }
-    if (this.options.onunhandledrejection) {
-      this.installOnUnhandledRejection();
-    }
-  }
-  /**
-   * Uninstall global error handlers
-   */
-  uninstall() {
-    if (typeof window === "undefined") {
-      return;
-    }
-    if (this.originalOnError !== null) {
-      window.onerror = this.originalOnError;
-      this.originalOnError = null;
-    }
-    if (this.originalOnUnhandledRejection !== null) {
-      window.removeEventListener("unhandledrejection", this.handleUnhandledRejection);
-      this.originalOnUnhandledRejection = null;
-    }
-    this.errorCallback = null;
-  }
-  installOnError() {
-    this.originalOnError = window.onerror;
-    window.onerror = (message, source, lineno, colno, error2) => {
-      if (this.originalOnError) {
-        this.originalOnError.call(window, message, source, lineno, colno, error2);
-      }
-      if (this.errorCallback) {
-        const errorObj = error2 || new Error(String(message));
-        if (!error2 && source) {
-          errorObj.filename = source;
-          errorObj.lineno = lineno;
-          errorObj.colno = colno;
-        }
-        this.errorCallback(errorObj, {
-          mechanism: { type: "onerror", handled: false },
-          source,
-          lineno,
-          colno
-        });
-      }
-      return false;
-    };
-  }
-  installOnUnhandledRejection() {
-    this.originalOnUnhandledRejection = this.handleUnhandledRejection.bind(this);
-    window.addEventListener("unhandledrejection", this.handleUnhandledRejection);
-  }
-};
-
-// src/integrations/console.ts
-var ConsoleIntegration = class {
-  constructor() {
-    this.originalMethods = {};
-    this.callback = null;
-    this.levels = ["debug", "info", "warn", "error", "log"];
-  }
-  /**
-   * Install console breadcrumb tracking
-   */
-  install(callback, levels) {
-    this.callback = callback;
-    if (levels) {
-      this.levels = levels;
-    }
-    if (typeof console === "undefined") {
-      return;
-    }
-    for (const level of this.levels) {
-      this.wrapConsoleMethod(level);
-    }
-  }
-  /**
-   * Uninstall console breadcrumb tracking
-   */
-  uninstall() {
-    if (typeof console === "undefined") {
-      return;
-    }
-    for (const level of this.levels) {
-      if (this.originalMethods[level]) {
-        console[level] = this.originalMethods[level];
-        delete this.originalMethods[level];
-      }
-    }
-    this.callback = null;
-  }
-  wrapConsoleMethod(level) {
-    const originalMethod = console[level];
-    if (!originalMethod) {
-      return;
-    }
-    this.originalMethods[level] = originalMethod;
-    const self = this;
-    console[level] = function(...args) {
-      if (self.callback) {
-        self.callback({
-          category: "console",
-          message: self.formatArgs(args),
-          level: self.mapLevel(level),
-          data: args.length > 1 ? { arguments: args } : void 0
-        });
-      }
-      originalMethod.apply(console, args);
-    };
-  }
-  formatArgs(args) {
-    return args.map((arg) => {
-      if (typeof arg === "string") {
-        return arg;
-      }
-      if (arg instanceof Error) {
-        return arg.message;
-      }
-      try {
-        return JSON.stringify(arg);
-      } catch {
-        return String(arg);
-      }
-    }).join(" ");
-  }
-  mapLevel(consoleLevel) {
-    switch (consoleLevel) {
-      case "debug":
-        return "debug";
-      case "info":
-      case "log":
-        return "info";
-      case "warn":
-        return "warning";
-      case "error":
-        return "error";
-      default:
-        return "info";
-    }
-  }
-};
-
-// src/client.ts
-init_telemetry();
-var SDK_NAME = "@statly/observe-sdk";
-var SDK_VERSION = "0.1.0";
-var StatlyClient = class {
-  constructor(options) {
-    this.user = null;
-    this.initialized = false;
-    this.options = this.mergeOptions(options);
-    this.transport = new Transport({
-      dsn: this.options.dsn,
-      debug: this.options.debug
-    });
-    this.breadcrumbs = new BreadcrumbManager(this.options.maxBreadcrumbs);
-    this.globalHandlers = new GlobalHandlers();
-    this.consoleIntegration = new ConsoleIntegration();
-    TelemetryProvider.getInstance().setClient(this);
-  }
-  mergeOptions(options) {
-    return {
-      dsn: options.dsn,
-      release: options.release ?? "",
-      environment: options.environment ?? this.detectEnvironment(),
-      debug: options.debug ?? false,
-      sampleRate: options.sampleRate ?? 1,
-      maxBreadcrumbs: options.maxBreadcrumbs ?? 100,
-      autoCapture: options.autoCapture !== false,
-      captureConsole: options.captureConsole !== false,
-      captureNetwork: options.captureNetwork ?? false,
-      tags: options.tags ?? {},
-      beforeSend: options.beforeSend ?? ((e) => e)
-    };
-  }
-  detectEnvironment() {
-    if (typeof window !== "undefined") {
-      if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") {
-        return "development";
-      }
-      if (window.location.hostname.includes("staging") || window.location.hostname.includes("stage")) {
-        return "staging";
-      }
-    }
-    return "production";
-  }
-  /**
-   * Initialize the SDK
-   */
-  init() {
-    if (this.initialized) {
-      if (this.options.debug) {
-        console.warn("[Statly] SDK already initialized");
-      }
-      return;
-    }
-    this.initialized = true;
-    if (this.options.autoCapture) {
-      this.globalHandlers.install((error2, context) => {
-        this.captureError(error2, context);
-      });
-    }
-    if (this.options.captureConsole) {
-      this.consoleIntegration.install((breadcrumb) => {
-        this.breadcrumbs.add(breadcrumb);
-      });
-    }
-    this.addBreadcrumb({
-      category: "navigation",
-      message: "SDK initialized",
-      level: "info"
-    });
-    if (this.options.debug) {
-      console.log("[Statly] SDK initialized", {
-        environment: this.options.environment,
-        release: this.options.release
-      });
-    }
-  }
-  /**
-   * Capture an exception/error
-   */
-  captureException(error2, context) {
-    let errorObj;
-    if (error2 instanceof Error) {
-      errorObj = error2;
-    } else if (typeof error2 === "string") {
-      errorObj = new Error(error2);
-    } else {
-      errorObj = new Error("Unknown error");
-      errorObj.originalError = error2;
-    }
-    return this.captureError(errorObj, context);
-  }
-  /**
-   * Capture a message
-   */
-  captureMessage(message, level = "info") {
-    const event = this.buildEvent({
-      message,
-      level
-    });
-    return this.sendEvent(event);
-  }
-  /**
-   * Capture a completed span
-   */
-  captureSpan(span) {
-    const event = this.buildEvent({
-      message: `Span: ${span.name}`,
-      level: "span",
-      span: span.toDict()
-    });
-    return this.sendEvent(event);
-  }
-  /**
-   * Start a new tracing span
-   */
-  startSpan(name, tags) {
-    return TelemetryProvider.getInstance().startSpan(name, tags);
-  }
-  /**
-   * Execute a function within a trace span
-   */
-  async trace(name, operation, tags) {
-    const { trace: traceFn } = await Promise.resolve().then(() => (init_telemetry(), telemetry_exports));
-    return traceFn(name, operation, tags);
-  }
-  /**
-   * Internal method to capture an error
-   */
-  captureError(error2, context) {
-    if (Math.random() > this.options.sampleRate) {
-      return "";
-    }
-    const event = this.buildEvent({
-      message: error2.message,
-      level: "error",
-      stack: error2.stack,
-      exception: {
-        type: error2.name,
-        value: error2.message,
-        stacktrace: this.parseStackTrace(error2.stack)
-      },
-      extra: context
-    });
-    return this.sendEvent(event);
-  }
-  /**
-   * Build a complete event from partial data
-   */
-  buildEvent(partial) {
-    const event = {
-      message: partial.message || "Unknown error",
-      timestamp: Date.now(),
-      level: partial.level || "error",
-      environment: this.options.environment,
-      release: this.options.release || void 0,
-      url: typeof window !== "undefined" ? window.location.href : void 0,
-      user: this.user || void 0,
-      tags: { ...this.options.tags, ...partial.tags },
-      extra: partial.extra,
-      breadcrumbs: this.breadcrumbs.getAll(),
-      browser: this.getBrowserInfo(),
-      os: this.getOSInfo(),
-      sdk: {
-        name: SDK_NAME,
-        version: SDK_VERSION
-      },
-      ...partial
-    };
-    return event;
-  }
-  /**
-   * Parse a stack trace string into structured frames
-   */
-  parseStackTrace(stack) {
-    if (!stack) {
-      return void 0;
-    }
-    const frames = [];
-    const lines = stack.split("\n");
-    for (const line of lines) {
-      const chromeMatch = line.match(/^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
-      if (chromeMatch) {
-        frames.push({
-          function: chromeMatch[1] || "<anonymous>",
-          filename: chromeMatch[2],
-          lineno: parseInt(chromeMatch[3], 10),
-          colno: parseInt(chromeMatch[4], 10)
-        });
-        continue;
-      }
-      const firefoxMatch = line.match(/^(.+?)@(.+?):(\d+):(\d+)$/);
-      if (firefoxMatch) {
-        frames.push({
-          function: firefoxMatch[1] || "<anonymous>",
-          filename: firefoxMatch[2],
-          lineno: parseInt(firefoxMatch[3], 10),
-          colno: parseInt(firefoxMatch[4], 10)
-        });
-      }
-    }
-    return frames.length > 0 ? { frames } : void 0;
-  }
-  /**
-   * Send an event to the server
-   */
-  sendEvent(event) {
-    const processed = this.options.beforeSend(event);
-    if (!processed) {
-      if (this.options.debug) {
-        console.log("[Statly] Event dropped by beforeSend");
-      }
-      return "";
-    }
-    const eventId = this.generateEventId();
-    this.breadcrumbs.add({
-      category: "statly",
-      message: `Captured ${event.level}: ${event.message.slice(0, 50)}`,
-      level: "info"
-    });
-    this.transport.enqueue(processed);
-    if (this.options.debug) {
-      console.log("[Statly] Event captured:", eventId, event.message);
-    }
-    return eventId;
-  }
-  generateEventId() {
-    return crypto.randomUUID?.() || "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);
-    });
-  }
-  /**
-   * Set user context
-   */
-  setUser(user) {
-    this.user = user;
-    if (this.options.debug && user) {
-      console.log("[Statly] User set:", user.id || user.email);
-    }
-  }
-  /**
-   * Set a single tag
-   */
-  setTag(key, value) {
-    this.options.tags[key] = value;
-  }
-  /**
-   * Set multiple tags
-   */
-  setTags(tags) {
-    Object.assign(this.options.tags, tags);
-  }
-  /**
-   * Add a breadcrumb
-   */
-  addBreadcrumb(breadcrumb) {
-    this.breadcrumbs.add(breadcrumb);
-  }
-  /**
-   * Get browser info
-   */
-  getBrowserInfo() {
-    if (typeof navigator === "undefined") {
-      return void 0;
-    }
-    const ua = navigator.userAgent;
-    let name = "Unknown";
-    let version = "";
-    if (ua.includes("Firefox/")) {
-      name = "Firefox";
-      version = ua.split("Firefox/")[1]?.split(" ")[0] || "";
-    } else if (ua.includes("Chrome/")) {
-      name = "Chrome";
-      version = ua.split("Chrome/")[1]?.split(" ")[0] || "";
-    } else if (ua.includes("Safari/") && !ua.includes("Chrome")) {
-      name = "Safari";
-      version = ua.split("Version/")[1]?.split(" ")[0] || "";
-    } else if (ua.includes("Edge/") || ua.includes("Edg/")) {
-      name = "Edge";
-      version = ua.split(/Edg?e?\//)[1]?.split(" ")[0] || "";
-    }
-    return { name, version };
-  }
-  /**
-   * Get OS info
-   */
-  getOSInfo() {
-    if (typeof navigator === "undefined") {
-      return void 0;
-    }
-    const ua = navigator.userAgent;
-    let name = "Unknown";
-    let version = "";
-    if (ua.includes("Windows")) {
-      name = "Windows";
-      const match = ua.match(/Windows NT (\d+\.\d+)/);
-      if (match) version = match[1];
-    } else if (ua.includes("Mac OS X")) {
-      name = "macOS";
-      const match = ua.match(/Mac OS X (\d+[._]\d+)/);
-      if (match) version = match[1].replace("_", ".");
-    } else if (ua.includes("Linux")) {
-      name = "Linux";
-    } else if (ua.includes("Android")) {
-      name = "Android";
-      const match = ua.match(/Android (\d+\.\d+)/);
-      if (match) version = match[1];
-    } else if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) {
-      name = "iOS";
-      const match = ua.match(/OS (\d+_\d+)/);
-      if (match) version = match[1].replace("_", ".");
-    }
-    return { name, version };
-  }
-  /**
-   * Flush pending events and clean up
-   */
-  async close() {
-    this.globalHandlers.uninstall();
-    this.consoleIntegration.uninstall();
-    await this.transport.flush();
-    this.transport.destroy();
-    this.initialized = false;
-  }
-  /**
-   * Force flush pending events
-   */
-  async flush() {
-    await this.transport.flush();
-  }
-};
-
-// src/integrations/express.ts
-function requestHandler() {
-  return (req, res, next) => {
-    req.statlyContext = {
-      transactionName: `${req.method} ${req.path || req.url}`,
-      startTime: Date.now()
-    };
-    Statly.addBreadcrumb({
-      category: "http",
-      message: `${req.method} ${req.originalUrl || req.url}`,
-      level: "info",
-      data: {
-        method: req.method,
-        url: req.originalUrl || req.url
-      }
-    });
-    if (req.user) {
-      Statly.setUser({
-        id: req.user.id?.toString(),
-        email: req.user.email?.toString()
-      });
-    }
-    res.on("finish", () => {
-      const duration = req.statlyContext?.startTime ? Date.now() - req.statlyContext.startTime : void 0;
-      Statly.addBreadcrumb({
-        category: "http",
-        message: `Response ${res.statusCode}`,
-        level: res.statusCode >= 400 ? "error" : "info",
-        data: {
-          statusCode: res.statusCode,
-          duration
-        }
-      });
-    });
-    next();
-  };
-}
-function expressErrorHandler(options = {}) {
-  return (err, req, res, next) => {
-    const error2 = err instanceof Error ? err : new Error(String(err));
-    if (options.shouldHandleError && !options.shouldHandleError(error2)) {
-      return next(err);
-    }
-    const context = {
-      request: {
-        method: req.method,
-        url: req.originalUrl || req.url,
-        headers: sanitizeHeaders(req.headers),
-        query: req.query,
-        data: sanitizeBody(req.body)
-      }
-    };
-    if (req.ip) {
-      context.ip = req.ip;
-    }
-    if (req.user) {
-      Statly.setUser({
-        id: req.user.id?.toString(),
-        email: req.user.email?.toString()
-      });
-    }
-    if (req.statlyContext?.transactionName) {
-      Statly.setTag("transaction", req.statlyContext.transactionName);
-    }
-    Statly.captureException(error2, context);
-    next(err);
-  };
-}
-function sanitizeHeaders(headers) {
-  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
-  const sanitized = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (sensitiveHeaders.includes(key.toLowerCase())) {
-      sanitized[key] = "[Filtered]";
-    } else {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}
-function sanitizeBody(body) {
-  if (!body || typeof body !== "object") {
-    return body;
-  }
-  const sensitiveFields = ["password", "secret", "token", "apiKey", "api_key", "credit_card", "creditCard", "ssn"];
-  const sanitized = {};
-  for (const [key, value] of Object.entries(body)) {
-    if (sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()))) {
-      sanitized[key] = "[Filtered]";
-    } else if (typeof value === "object" && value !== null) {
-      sanitized[key] = sanitizeBody(value);
-    } else {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}
-
-// src/integrations/nextjs.ts
-function withStatlyPagesApi(handler) {
-  return async (req, res) => {
-    return Statly.trace(`${req.method} ${req.url}`, async (span) => {
-      span.setTag("component", "nextjs-pages-api");
-      span.setTag("http.method", req.method || "GET");
-      span.setTag("http.url", req.url || "unknown");
-      Statly.addBreadcrumb({
-        category: "http",
-        message: `${req.method} ${req.url}`,
-        level: "info",
-        data: {
-          method: req.method,
-          url: req.url
-        }
-      });
-      try {
-        const result = await handler(req, res);
-        return result;
-      } catch (error2) {
-        const context = {
-          request: {
-            method: req.method,
-            url: req.url,
-            headers: sanitizeHeaders2(req.headers),
-            query: req.query
-          }
-        };
-        Statly.captureException(error2, context);
-        throw error2;
-      }
-    });
-  };
-}
-function withStatly(handler) {
-  const wrappedHandler = async (request, context) => {
-    return Statly.trace(`${request.method} ${request.nextUrl?.pathname || request.url}`, async (span) => {
-      span.setTag("component", "nextjs-app-router");
-      span.setTag("http.method", request.method);
-      span.setTag("http.url", request.nextUrl?.pathname || request.url);
-      Statly.addBreadcrumb({
-        category: "http",
-        message: `${request.method} ${request.nextUrl?.pathname || request.url}`,
-        level: "info",
-        data: {
-          method: request.method,
-          url: request.nextUrl?.pathname || request.url
-        }
-      });
-      try {
-        const result = await handler(request, context);
-        if (result instanceof Response) {
-          span.setTag("http.status_code", result.status.toString());
-        }
-        return result;
-      } catch (error2) {
-        const headers = {};
-        request.headers.forEach((value, key) => {
-          headers[key] = value;
-        });
-        const errorContext = {
-          request: {
-            method: request.method,
-            url: request.nextUrl?.pathname || request.url,
-            headers: sanitizeHeaders2(headers),
-            searchParams: request.nextUrl?.searchParams?.toString()
-          }
-        };
-        if (context?.params) {
-          try {
-            errorContext.params = await context.params;
-          } catch {
-          }
-        }
-        Statly.captureException(error2, errorContext);
-        throw error2;
-      }
-    });
-  };
-  return wrappedHandler;
-}
-function captureNextJsError(error2, context) {
-  return Statly.captureException(error2, {
-    ...context,
-    digest: error2.digest,
-    source: "nextjs-error-boundary"
-  });
-}
-function withStatlyGetServerSideProps(handler) {
-  return async (context) => {
-    try {
-      return await handler(context);
-    } catch (error2) {
-      Statly.captureException(error2, {
-        source: "getServerSideProps",
-        url: context.req?.url || context.resolvedUrl
-      });
-      throw error2;
-    }
-  };
-}
-function withStatlyGetStaticProps(handler) {
-  return async (context) => {
-    try {
-      return await handler(context);
-    } catch (error2) {
-      Statly.captureException(error2, {
-        source: "getStaticProps",
-        params: context.params
-      });
-      throw error2;
-    }
-  };
-}
-function withStatlyServerAction(action, actionName) {
-  return async (...args) => {
-    return Statly.trace(`Action: ${actionName || "unknown"}`, async (span) => {
-      span.setTag("component", "nextjs-server-action");
-      span.setTag("action.name", actionName || "unknown");
-      Statly.addBreadcrumb({
-        category: "action",
-        message: `Server action: ${actionName || "unknown"}`,
-        level: "info"
-      });
-      try {
-        return await action(...args);
-      } catch (error2) {
-        Statly.captureException(error2, {
-          source: "server-action",
-          actionName
-        });
-        throw error2;
-      }
-    });
-  };
-}
-function sanitizeHeaders2(headers) {
-  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
-  const sanitized = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (sensitiveHeaders.includes(key.toLowerCase())) {
-      sanitized[key] = "[Filtered]";
-    } else {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}
-
-// src/integrations/fastify.ts
-function statlyFastifyPlugin(fastify, options, done) {
-  const {
-    captureValidationErrors = true,
-    shouldCapture,
-    skipStatusCodes = [400, 401, 403, 404]
-  } = options;
-  fastify.addHook("onRequest", (request, _reply, hookDone) => {
-    request.statlyStartTime = Date.now();
-    Statly.addBreadcrumb({
-      category: "http",
-      message: `${request.method} ${request.routerPath || request.url}`,
-      level: "info",
-      data: {
-        method: request.method,
-        url: request.url,
-        routerPath: request.routerPath,
-        requestId: request.id
-      }
-    });
-    hookDone();
-  });
-  fastify.addHook("onResponse", (request, reply, hookDone) => {
-    const startTime = request.statlyStartTime;
-    const duration = startTime ? Date.now() - startTime : void 0;
-    Statly.addBreadcrumb({
-      category: "http",
-      message: `Response ${reply.statusCode}`,
-      level: reply.statusCode >= 400 ? "error" : "info",
-      data: {
-        statusCode: reply.statusCode,
-        duration,
-        requestId: request.id
-      }
-    });
-    hookDone();
-  });
-  fastify.setErrorHandler((error2, request, reply) => {
-    const statusCode = error2.statusCode || 500;
-    if (skipStatusCodes.includes(statusCode)) {
-      throw error2;
-    }
-    if (!captureValidationErrors && error2.validation) {
-      throw error2;
-    }
-    if (shouldCapture && !shouldCapture(error2)) {
-      throw error2;
-    }
-    const context = {
-      request: {
-        id: request.id,
-        method: request.method,
-        url: request.url,
-        routerPath: request.routerPath,
-        headers: sanitizeHeaders3(request.headers),
-        query: request.query,
-        params: request.params
-      },
-      error: {
-        statusCode: error2.statusCode,
-        code: error2.code
-      }
-    };
-    if (request.ip) {
-      context.ip = request.ip;
-    }
-    if (error2.validation) {
-      context.validation = error2.validation;
-    }
-    Statly.setTag("http.method", request.method);
-    Statly.setTag("http.url", request.routerPath || request.url);
-    Statly.setTag("http.status_code", String(statusCode));
-    Statly.captureException(error2, context);
-    throw error2;
-  });
-  done();
-}
-var statlyPlugin = statlyFastifyPlugin;
-function createRequestCapture(request) {
-  return (error2, additionalContext) => {
-    const context = {
-      request: {
-        id: request.id,
-        method: request.method,
-        url: request.url,
-        routerPath: request.routerPath
-      },
-      ...additionalContext
-    };
-    return Statly.captureException(error2, context);
-  };
-}
-function sanitizeHeaders3(headers) {
-  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
-  const sanitized = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (sensitiveHeaders.includes(key.toLowerCase())) {
-      sanitized[key] = "[Filtered]";
-    } else {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}
-
-// src/logger/types.ts
-var LOG_LEVELS = {
-  trace: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-  fatal: 5,
-  audit: 6
-  // Special: always logged, never sampled
-};
-var DEFAULT_LEVELS = ["debug", "info", "warn", "error", "fatal"];
-var EXTENDED_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal", "audit"];
-
-// src/logger/scrubbing/patterns.ts
-var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
-  "password",
-  "passwd",
-  "pwd",
-  "secret",
-  "api_key",
-  "apikey",
-  "api-key",
-  "token",
-  "access_token",
-  "accesstoken",
-  "refresh_token",
-  "auth",
-  "authorization",
-  "bearer",
-  "credential",
-  "credentials",
-  "private_key",
-  "privatekey",
-  "private-key",
-  "secret_key",
-  "secretkey",
-  "secret-key",
-  "session_id",
-  "sessionid",
-  "session-id",
-  "session",
-  "cookie",
-  "x-api-key",
-  "x-auth-token",
-  "x-access-token"
-]);
-var SCRUB_PATTERNS = {
-  apiKey: {
-    regex: /(?:api[_-]?key|apikey)\s*[=:]\s*["']?([a-zA-Z0-9_\-]{20,})["']?/gi,
-    description: "API keys in various formats"
-  },
-  password: {
-    regex: /(?:password|passwd|pwd|secret)\s*[=:]\s*["']?([^"'\s]{3,})["']?/gi,
-    description: "Passwords and secrets"
-  },
-  token: {
-    regex: /(?:bearer\s+|token\s*[=:]\s*["']?)([a-zA-Z0-9_\-\.]{20,})["']?/gi,
-    description: "Bearer tokens and auth tokens"
-  },
-  creditCard: {
-    // Visa, Mastercard, Amex, Discover, etc.
-    regex: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\d{3})\d{11})\b/g,
-    description: "Credit card numbers"
-  },
-  ssn: {
-    regex: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g,
-    description: "US Social Security Numbers"
-  },
-  email: {
-    regex: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g,
-    description: "Email addresses"
-  },
-  ipAddress: {
-    regex: /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g,
-    description: "IPv4 addresses"
-  },
-  awsKey: {
-    regex: /(?:AKIA|ABIA|ACCA)[A-Z0-9]{16}/g,
-    description: "AWS Access Key IDs"
-  },
-  privateKey: {
-    regex: /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA )?PRIVATE KEY-----/g,
-    description: "Private keys in PEM format"
-  },
-  jwt: {
-    regex: /eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*/g,
-    description: "JSON Web Tokens"
-  }
-};
-var REDACTED = "[REDACTED]";
-function isSensitiveKey(key) {
-  const lowerKey = key.toLowerCase();
-  return SENSITIVE_KEYS.has(lowerKey);
-}
-
-// src/logger/scrubbing/scrubber.ts
-var Scrubber = class {
-  constructor(config = {}) {
-    this.enabled = config.enabled !== false;
-    this.patterns = /* @__PURE__ */ new Map();
-    this.customPatterns = config.customPatterns || [];
-    this.allowlist = new Set((config.allowlist || []).map((k) => k.toLowerCase()));
-    this.customScrubber = config.customScrubber;
-    const patternNames = config.patterns || [
-      "apiKey",
-      "password",
-      "token",
-      "creditCard",
-      "ssn",
-      "awsKey",
-      "privateKey",
-      "jwt"
-    ];
-    for (const name of patternNames) {
-      const pattern = SCRUB_PATTERNS[name];
-      if (pattern) {
-        this.patterns.set(name, new RegExp(pattern.regex.source, pattern.regex.flags));
-      }
-    }
-  }
-  /**
-   * Scrub sensitive data from a value
-   */
-  scrub(value) {
-    if (!this.enabled) {
-      return value;
-    }
-    return this.scrubValue(value, "");
-  }
-  /**
-   * Scrub a log message string
-   */
-  scrubMessage(message) {
-    if (!this.enabled) {
-      return message;
-    }
-    let result = message;
-    for (const [, regex] of this.patterns) {
-      result = result.replace(regex, REDACTED);
-    }
-    for (const regex of this.customPatterns) {
-      result = result.replace(regex, REDACTED);
-    }
-    return result;
-  }
-  /**
-   * Recursively scrub sensitive data
-   */
-  scrubValue(value, key) {
-    if (key && this.allowlist.has(key.toLowerCase())) {
-      return value;
-    }
-    if (this.customScrubber && key) {
-      const result = this.customScrubber(key, value);
-      if (result !== value) {
-        return result;
-      }
-    }
-    if (key && isSensitiveKey(key)) {
-      return REDACTED;
-    }
-    if (value === null || value === void 0) {
-      return value;
-    }
-    if (typeof value === "string") {
-      return this.scrubString(value);
-    }
-    if (Array.isArray(value)) {
-      return value.map((item, index) => this.scrubValue(item, String(index)));
-    }
-    if (typeof value === "object") {
-      return this.scrubObject(value);
-    }
-    return value;
-  }
-  /**
-   * Scrub sensitive patterns from a string
-   */
-  scrubString(value) {
-    let result = value;
-    for (const [, regex] of this.patterns) {
-      regex.lastIndex = 0;
-      result = result.replace(regex, REDACTED);
-    }
-    for (const regex of this.customPatterns) {
-      const newRegex = new RegExp(regex.source, regex.flags);
-      result = result.replace(newRegex, REDACTED);
-    }
-    return result;
-  }
-  /**
-   * Scrub sensitive data from an object
-   */
-  scrubObject(obj) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = this.scrubValue(value, key);
-    }
-    return result;
-  }
-  /**
-   * Add a custom pattern at runtime
-   */
-  addPattern(pattern) {
-    this.customPatterns.push(pattern);
-  }
-  /**
-   * Add a key to the allowlist
-   */
-  addToAllowlist(key) {
-    this.allowlist.add(key.toLowerCase());
-  }
-  /**
-   * Check if scrubbing is enabled
-   */
-  isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Enable or disable scrubbing
-   */
-  setEnabled(enabled) {
-    this.enabled = enabled;
-  }
-};
-
-// src/logger/formatters/console.ts
-var COLORS = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  // Foreground 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",
-  // Background colors
-  bgRed: "\x1B[41m",
-  bgYellow: "\x1B[43m"
-};
-var LEVEL_COLORS = {
-  trace: COLORS.gray,
-  debug: COLORS.cyan,
-  info: COLORS.green,
-  warn: COLORS.yellow,
-  error: COLORS.red,
-  fatal: `${COLORS.bgRed}${COLORS.white}`,
-  audit: COLORS.magenta
-};
-var LEVEL_LABELS = {
-  trace: "TRACE",
-  debug: "DEBUG",
-  info: "INFO ",
-  warn: "WARN ",
-  error: "ERROR",
-  fatal: "FATAL",
-  audit: "AUDIT"
-};
-function formatPretty(entry, options = {}) {
-  const {
-    colors = true,
-    timestamps = true,
-    showLevel = true,
-    showLogger = true,
-    showContext = true,
-    showSource = false
-  } = options;
-  const parts = [];
-  if (timestamps) {
-    const date = new Date(entry.timestamp);
-    const time = date.toISOString().replace("T", " ").replace("Z", "");
-    parts.push(colors ? `${COLORS.dim}${time}${COLORS.reset}` : time);
-  }
-  if (showLevel) {
-    const levelColor = colors ? LEVEL_COLORS[entry.level] : "";
-    const levelLabel = LEVEL_LABELS[entry.level];
-    parts.push(colors ? `${levelColor}${levelLabel}${COLORS.reset}` : levelLabel);
-  }
-  if (showLogger && entry.loggerName) {
-    parts.push(colors ? `${COLORS.blue}[${entry.loggerName}]${COLORS.reset}` : `[${entry.loggerName}]`);
-  }
-  parts.push(entry.message);
-  if (showSource && entry.source) {
-    const { file, line, function: fn } = entry.source;
-    const loc = [file, line, fn].filter(Boolean).join(":");
-    if (loc) {
-      parts.push(colors ? `${COLORS.dim}(${loc})${COLORS.reset}` : `(${loc})`);
-    }
-  }
-  let result = parts.join(" ");
-  if (showContext && entry.context && Object.keys(entry.context).length > 0) {
-    const contextStr = JSON.stringify(entry.context, null, 2);
-    result += "\n" + (colors ? `${COLORS.dim}${contextStr}${COLORS.reset}` : contextStr);
-  }
-  return result;
-}
-function formatJson(entry) {
-  return JSON.stringify(entry);
-}
-function formatJsonPretty(entry) {
-  return JSON.stringify(entry, null, 2);
-}
-function getConsoleMethod(level) {
-  switch (level) {
-    case "trace":
-      return "trace";
-    case "debug":
-      return "debug";
-    case "info":
-      return "info";
-    case "warn":
-      return "warn";
-    case "error":
-    case "fatal":
-      return "error";
-    case "audit":
-      return "info";
-    default:
-      return "log";
-  }
-}
-
-// src/logger/destinations/console.ts
-var ConsoleDestination = class {
-  constructor(config = {}) {
-    this.name = "console";
-    this.config = {
-      enabled: config.enabled !== false,
-      colors: config.colors !== false,
-      format: config.format || "pretty",
-      timestamps: config.timestamps !== false,
-      levels: config.levels || ["trace", "debug", "info", "warn", "error", "fatal", "audit"]
-    };
-    this.minLevel = 0;
-  }
-  /**
-   * Write a log entry to the console
-   */
-  write(entry) {
-    if (!this.config.enabled) {
-      return;
-    }
-    if (!this.config.levels.includes(entry.level)) {
-      return;
-    }
-    if (LOG_LEVELS[entry.level] < this.minLevel) {
-      return;
-    }
-    let output;
-    if (this.config.format === "json") {
-      output = formatJson(entry);
-    } else {
-      output = formatPretty(entry, {
-        colors: this.config.colors && this.supportsColors(),
-        timestamps: this.config.timestamps
-      });
-    }
-    const method = getConsoleMethod(entry.level);
-    console[method](output);
-  }
-  /**
-   * Check if the environment supports colors
-   */
-  supportsColors() {
-    if (typeof window !== "undefined") {
-      return true;
-    }
-    if (typeof process !== "undefined") {
-      if (process.stdout && "isTTY" in process.stdout) {
-        return Boolean(process.stdout.isTTY);
-      }
-      const env = process.env;
-      if (env.FORCE_COLOR !== void 0) {
-        return env.FORCE_COLOR !== "0";
-      }
-      if (env.NO_COLOR !== void 0) {
-        return false;
-      }
-      if (env.TERM === "dumb") {
-        return false;
-      }
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Set minimum log level
-   */
-  setMinLevel(level) {
-    this.minLevel = LOG_LEVELS[level];
-  }
-  /**
-   * Enable or disable the destination
-   */
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-  }
-  /**
-   * Set color mode
-   */
-  setColors(enabled) {
-    this.config.colors = enabled;
-  }
-  /**
-   * Set output format
-   */
-  setFormat(format) {
-    this.config.format = format;
-  }
-};
-
-// src/logger/destinations/observe.ts
-var DEFAULT_BATCH_SIZE = 50;
-var DEFAULT_FLUSH_INTERVAL = 5e3;
-var DEFAULT_SAMPLING = {
-  trace: 0.01,
-  // 1%
-  debug: 0.1,
-  // 10%
-  info: 0.5,
-  // 50%
-  warn: 1,
-  // 100%
-  error: 1,
-  // 100%
-  fatal: 1,
-  // 100%
-  audit: 1
-  // 100% - never sampled
-};
-var ObserveDestination = class {
-  constructor(dsn, config = {}) {
-    this.name = "observe";
-    this.queue = [];
-    this.isFlushing = false;
-    this.minLevel = 0;
-    this.dsn = dsn;
-    this.endpoint = this.parseEndpoint(dsn);
-    this.config = {
-      enabled: config.enabled !== false,
-      batchSize: config.batchSize || DEFAULT_BATCH_SIZE,
-      flushInterval: config.flushInterval || DEFAULT_FLUSH_INTERVAL,
-      sampling: { ...DEFAULT_SAMPLING, ...config.sampling },
-      levels: config.levels || ["trace", "debug", "info", "warn", "error", "fatal", "audit"]
-    };
-    this.startFlushTimer();
-  }
-  /**
-   * Parse DSN to construct endpoint
-   */
-  parseEndpoint(dsn) {
-    try {
-      const url = new URL(dsn);
-      return `${url.protocol}//${url.host}/api/v1/logs/ingest`;
-    } catch {
-      return "https://statly.live/api/v1/logs/ingest";
-    }
-  }
-  /**
-   * Start the flush timer
-   */
-  startFlushTimer() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-    }
-    if (typeof setInterval !== "undefined") {
-      this.flushTimer = setInterval(() => {
-        this.flush();
-      }, this.config.flushInterval);
-    }
-  }
-  /**
-   * Write a log entry (queues for batching)
-   */
-  write(entry) {
-    if (!this.config.enabled) {
-      return;
-    }
-    if (!this.config.levels.includes(entry.level)) {
-      return;
-    }
-    if (LOG_LEVELS[entry.level] < this.minLevel) {
-      return;
-    }
-    if (entry.level !== "audit") {
-      const sampleRate = this.config.sampling[entry.level] ?? 1;
-      if (Math.random() > sampleRate) {
-        return;
-      }
-    }
-    this.queue.push(entry);
-    if (this.queue.length >= this.config.batchSize) {
-      this.flush();
-    }
-  }
-  /**
-   * Flush all queued entries to the server
-   */
-  async flush() {
-    if (this.isFlushing || this.queue.length === 0) {
-      return;
-    }
-    this.isFlushing = true;
-    const entries = [...this.queue];
-    this.queue = [];
-    try {
-      await this.sendBatch(entries);
-    } catch (error2) {
-      const maxQueue = this.config.batchSize * 3;
-      this.queue = [...entries, ...this.queue].slice(0, maxQueue);
-      console.error("[Statly Logger] Failed to send logs:", error2);
-    } finally {
-      this.isFlushing = false;
-    }
-  }
-  /**
-   * Send a batch of entries to the server
-   */
-  async sendBatch(entries) {
-    if (entries.length === 0) {
-      return;
-    }
-    const response = await fetch(this.endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Statly-DSN": this.dsn
-      },
-      body: JSON.stringify({ logs: entries }),
-      keepalive: true
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-  }
-  /**
-   * Close the destination
-   */
-  async close() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-    }
-    await this.flush();
-  }
-  /**
-   * Set minimum log level
-   */
-  setMinLevel(level) {
-    this.minLevel = LOG_LEVELS[level];
-  }
-  /**
-   * Set sampling rate for a level
-   */
-  setSamplingRate(level, rate) {
-    this.config.sampling[level] = Math.max(0, Math.min(1, rate));
-  }
-  /**
-   * Enable or disable the destination
-   */
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-  }
-  /**
-   * Get the current queue size
-   */
-  getQueueSize() {
-    return this.queue.length;
-  }
-};
-
-// src/logger/destinations/file.ts
-function parseSize(size) {
-  const match = size.match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB|B)?$/i);
-  if (!match) return 10 * 1024 * 1024;
-  const value = parseFloat(match[1]);
-  const unit = (match[2] || "B").toUpperCase();
-  switch (unit) {
-    case "KB":
-      return value * 1024;
-    case "MB":
-      return value * 1024 * 1024;
-    case "GB":
-      return value * 1024 * 1024 * 1024;
-    default:
-      return value;
-  }
-}
-function formatDate(date) {
-  return date.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-}
-var FileDestination = class {
-  constructor(config) {
-    this.name = "file";
-    this.minLevel = 0;
-    this.buffer = [];
-    this.currentSize = 0;
-    this.writePromise = Promise.resolve();
-    // File system operations (injected for Node.js compatibility)
-    this.fs = null;
-    this.config = {
-      enabled: config.enabled !== false,
-      path: config.path,
-      format: config.format || "json",
-      rotation: config.rotation || { type: "size", maxSize: "10MB", maxFiles: 5 },
-      levels: config.levels || ["trace", "debug", "info", "warn", "error", "fatal", "audit"]
-    };
-    this.maxSize = parseSize(this.config.rotation.maxSize || "10MB");
-    this.lastRotation = /* @__PURE__ */ new Date();
-    this.rotationInterval = this.getRotationInterval();
-    this.initFileSystem();
-  }
-  /**
-   * Initialize file system operations
-   */
-  async initFileSystem() {
-    if (typeof process !== "undefined" && process.versions?.node) {
-      try {
-        const fs = await import("fs/promises");
-        const path = await import("path");
-        const fsOps = {
-          appendFile: fs.appendFile,
-          rename: fs.rename,
-          stat: fs.stat,
-          mkdir: (p, opts) => fs.mkdir(p, opts),
-          readdir: fs.readdir,
-          unlink: fs.unlink
-        };
-        this.fs = fsOps;
-        const dir = path.dirname(this.config.path);
-        await fsOps.mkdir(dir, { recursive: true });
-      } catch {
-        console.warn("[Statly Logger] File destination not available (not Node.js)");
-        this.config.enabled = false;
-      }
-    } else {
-      this.config.enabled = false;
-    }
-  }
-  /**
-   * Get rotation interval in milliseconds
-   */
-  getRotationInterval() {
-    const { interval } = this.config.rotation;
-    switch (interval) {
-      case "hourly":
-        return 60 * 60 * 1e3;
-      case "daily":
-        return 24 * 60 * 60 * 1e3;
-      case "weekly":
-        return 7 * 24 * 60 * 60 * 1e3;
-      default:
-        return Infinity;
-    }
-  }
-  /**
-   * Write a log entry
-   */
-  write(entry) {
-    if (!this.config.enabled || !this.fs) {
-      return;
-    }
-    if (!this.config.levels.includes(entry.level)) {
-      return;
-    }
-    if (LOG_LEVELS[entry.level] < this.minLevel) {
-      return;
-    }
-    let line;
-    if (this.config.format === "json") {
-      line = formatJson(entry);
-    } else {
-      const date = new Date(entry.timestamp).toISOString();
-      line = `${date} [${entry.level.toUpperCase()}] ${entry.loggerName ? `[${entry.loggerName}] ` : ""}${entry.message}`;
-      if (entry.context && Object.keys(entry.context).length > 0) {
-        line += ` ${JSON.stringify(entry.context)}`;
-      }
-    }
-    this.buffer.push(line + "\n");
-    this.currentSize += line.length + 1;
-    if (this.buffer.length >= 100 || this.currentSize >= 64 * 1024) {
-      this.scheduleWrite();
-    }
-  }
-  /**
-   * Schedule a buffered write
-   */
-  scheduleWrite() {
-    this.writePromise = this.writePromise.then(() => this.writeBuffer());
-  }
-  /**
-   * Write buffer to file
-   */
-  async writeBuffer() {
-    if (!this.fs || this.buffer.length === 0) {
-      return;
-    }
-    await this.checkRotation();
-    const data = this.buffer.join("");
-    this.buffer = [];
-    this.currentSize = 0;
-    try {
-      await this.fs.appendFile(this.config.path, data);
-    } catch (error2) {
-      console.error("[Statly Logger] Failed to write to file:", error2);
-    }
-  }
-  /**
-   * Check if rotation is needed
-   */
-  async checkRotation() {
-    if (!this.fs) return;
-    const { type } = this.config.rotation;
-    let shouldRotate = false;
-    if (type === "size") {
-      try {
-        const stats = await this.fs.stat(this.config.path);
-        shouldRotate = stats.size >= this.maxSize;
-      } catch {
-      }
-    } else if (type === "time") {
-      const now = /* @__PURE__ */ new Date();
-      shouldRotate = now.getTime() - this.lastRotation.getTime() >= this.rotationInterval;
-    }
-    if (shouldRotate) {
-      await this.rotate();
-    }
-  }
-  /**
-   * Rotate the log file
-   */
-  async rotate() {
-    if (!this.fs) return;
-    try {
-      const rotatedPath = `${this.config.path}.${formatDate(/* @__PURE__ */ new Date())}`;
-      await this.fs.rename(this.config.path, rotatedPath);
-      this.lastRotation = /* @__PURE__ */ new Date();
-      await this.cleanupOldFiles();
-    } catch (error2) {
-      console.error("[Statly Logger] Failed to rotate file:", error2);
-    }
-  }
-  /**
-   * Clean up old rotated files
-   */
-  async cleanupOldFiles() {
-    if (!this.fs) return;
-    const { maxFiles, retentionDays } = this.config.rotation;
-    try {
-      const path = await import("path");
-      const dir = path.dirname(this.config.path);
-      const basename = path.basename(this.config.path);
-      const files = await this.fs.readdir(dir);
-      const rotatedFiles = files.filter((f) => f.startsWith(basename + ".")).map((f) => ({ name: f, path: path.join(dir, f) })).sort((a, b) => b.name.localeCompare(a.name));
-      if (maxFiles) {
-        for (const file of rotatedFiles.slice(maxFiles)) {
-          await this.fs.unlink(file.path);
-        }
-      }
-      if (retentionDays) {
-        const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
-        for (const file of rotatedFiles) {
-          const match = file.name.match(/\.(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})$/);
-          if (match) {
-            const fileDate = new Date(match[1].replace("_", "T").replace(/-/g, ":"));
-            if (fileDate.getTime() < cutoff) {
-              await this.fs.unlink(file.path);
-            }
-          }
-        }
-      }
-    } catch (error2) {
-      console.error("[Statly Logger] Failed to cleanup old files:", error2);
-    }
-  }
-  /**
-   * Flush buffered writes
-   */
-  async flush() {
-    this.scheduleWrite();
-    await this.writePromise;
-  }
-  /**
-   * Close the destination
-   */
-  async close() {
-    await this.flush();
-  }
-  /**
-   * Set minimum log level
-   */
-  setMinLevel(level) {
-    this.minLevel = LOG_LEVELS[level];
-  }
-  /**
-   * Enable or disable the destination
-   */
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-  }
-};
-
-// src/logger/ai/index.ts
-var AIFeatures = class {
-  constructor(dsn, config = {}) {
-    this.dsn = dsn;
-    this.config = {
-      enabled: config.enabled ?? true,
-      apiKey: config.apiKey || "",
-      model: config.model || "claude-3-haiku-20240307",
-      endpoint: config.endpoint || this.parseEndpoint(dsn)
-    };
-  }
-  /**
-   * Parse DSN to construct AI endpoint
-   */
-  parseEndpoint(dsn) {
-    try {
-      const url = new URL(dsn);
-      return `${url.protocol}//${url.host}/api/v1/logs/ai`;
-    } catch {
-      return "https://statly.live/api/v1/logs/ai";
-    }
-  }
-  /**
-   * Explain an error using AI
-   */
-  async explainError(error2) {
-    if (!this.config.enabled) {
-      return {
-        summary: "AI features are disabled",
-        possibleCauses: []
-      };
-    }
-    const errorData = this.normalizeError(error2);
-    try {
-      const response = await fetch(`${this.config.endpoint}/explain`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Statly-DSN": this.dsn,
-          ...this.config.apiKey && { "X-AI-API-Key": this.config.apiKey }
-        },
-        body: JSON.stringify({
-          error: errorData,
-          model: this.config.model
-        })
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      return await response.json();
-    } catch (err) {
-      console.error("[Statly Logger AI] Failed to explain error:", err);
-      return {
-        summary: "Failed to get AI explanation",
-        possibleCauses: []
-      };
-    }
-  }
-  /**
-   * Suggest fixes for an error using AI
-   */
-  async suggestFix(error2, context) {
-    if (!this.config.enabled) {
-      return {
-        summary: "AI features are disabled",
-        suggestedFixes: []
-      };
-    }
-    const errorData = this.normalizeError(error2);
-    try {
-      const response = await fetch(`${this.config.endpoint}/suggest-fix`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Statly-DSN": this.dsn,
-          ...this.config.apiKey && { "X-AI-API-Key": this.config.apiKey }
-        },
-        body: JSON.stringify({
-          error: errorData,
-          context,
-          model: this.config.model
-        })
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      return await response.json();
-    } catch (err) {
-      console.error("[Statly Logger AI] Failed to suggest fix:", err);
-      return {
-        summary: "Failed to get AI fix suggestion",
-        suggestedFixes: []
-      };
-    }
-  }
-  /**
-   * Analyze a batch of logs for patterns
-   */
-  async analyzePatterns(logs) {
-    if (!this.config.enabled) {
-      return {
-        patterns: [],
-        summary: "AI features are disabled",
-        recommendations: []
-      };
-    }
-    try {
-      const response = await fetch(`${this.config.endpoint}/analyze-patterns`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Statly-DSN": this.dsn,
-          ...this.config.apiKey && { "X-AI-API-Key": this.config.apiKey }
-        },
-        body: JSON.stringify({
-          logs: logs.slice(0, 1e3),
-          // Limit to 1000 logs
-          model: this.config.model
-        })
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      return await response.json();
-    } catch (err) {
-      console.error("[Statly Logger AI] Failed to analyze patterns:", err);
-      return {
-        patterns: [],
-        summary: "Failed to analyze patterns",
-        recommendations: []
-      };
-    }
-  }
-  /**
-   * Normalize error input to a standard format
-   */
-  normalizeError(error2) {
-    if (typeof error2 === "string") {
-      return { message: error2 };
-    }
-    if (error2 instanceof Error) {
-      return {
-        message: error2.message,
-        stack: error2.stack,
-        type: error2.name
-      };
-    }
-    return {
-      message: error2.message,
-      type: error2.level,
-      context: error2.context
-    };
-  }
-  /**
-   * Set API key for AI features
-   */
-  setApiKey(apiKey) {
-    this.config.apiKey = apiKey;
-  }
-  /**
-   * Enable or disable AI features
-   */
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-  }
-  /**
-   * Check if AI features are enabled
-   */
-  isEnabled() {
-    return this.config.enabled;
-  }
-};
-
-// src/logger/logger.ts
-var SDK_NAME2 = "@statly/observe";
-var SDK_VERSION2 = "1.1.0";
-var Logger = class _Logger {
-  constructor(config = {}) {
-    this.destinations = [];
-    this.ai = null;
-    this.context = {};
-    this.tags = {};
-    this.name = config.loggerName || "default";
-    this.config = config;
-    this.minLevel = LOG_LEVELS[config.level || "debug"];
-    this.enabledLevels = this.parseLevelSet(config.levels || "default");
-    this.scrubber = new Scrubber(config.scrubbing);
-    this.context = config.context || {};
-    this.tags = config.tags || {};
-    this.sessionId = this.generateId();
-    this.initDestinations();
-    if (config.dsn) {
-      this.ai = new AIFeatures(config.dsn);
-    }
-  }
-  /**
-   * Parse level set configuration
-   */
-  parseLevelSet(levels) {
-    if (levels === "default") {
-      return new Set(DEFAULT_LEVELS);
-    }
-    if (levels === "extended") {
-      return new Set(EXTENDED_LEVELS);
-    }
-    return new Set(levels);
-  }
-  /**
-   * Initialize destinations from config
-   */
-  initDestinations() {
-    const { destinations } = this.config;
-    if (!destinations || destinations.console?.enabled !== false) {
-      this.destinations.push(new ConsoleDestination(destinations?.console));
-    }
-    if (destinations?.file?.enabled && destinations.file.path) {
-      this.destinations.push(new FileDestination(destinations.file));
-    }
-    if (this.config.dsn && destinations?.observe?.enabled !== false) {
-      this.destinations.push(new ObserveDestination(this.config.dsn, destinations?.observe));
-    }
-  }
-  /**
-   * Generate a unique ID
-   */
-  generateId() {
-    if (typeof crypto !== "undefined" && crypto.randomUUID) {
-      return crypto.randomUUID();
-    }
-    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);
-    });
-  }
-  /**
-   * Check if a level should be logged
-   */
-  shouldLog(level) {
-    if (level === "audit") {
-      return true;
-    }
-    if (LOG_LEVELS[level] < this.minLevel) {
-      return false;
-    }
-    return this.enabledLevels.has(level);
-  }
-  /**
-   * Get source location (if available)
-   */
-  getSource() {
-    try {
-      const err = new Error();
-      const stack = err.stack?.split("\n");
-      if (!stack || stack.length < 5) return void 0;
-      for (let i = 3; i < stack.length; i++) {
-        const frame = stack[i];
-        if (!frame.includes("logger.ts") && !frame.includes("Logger.")) {
-          const match = frame.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+)(?::\d+)?\)?/);
-          if (match) {
-            return {
-              function: match[1] || void 0,
-              file: match[2],
-              line: parseInt(match[3], 10)
-            };
-          }
-        }
-      }
-    } catch {
-    }
-    return void 0;
-  }
-  /**
-   * Create a log entry
-   */
-  createEntry(level, message, context) {
-    return {
-      level,
-      message: this.scrubber.scrubMessage(message),
-      timestamp: Date.now(),
-      loggerName: this.name,
-      context: context ? this.scrubber.scrub({ ...this.context, ...context }) : this.scrubber.scrub(this.context),
-      tags: this.tags,
-      source: this.getSource(),
-      traceId: this.traceId,
-      spanId: this.spanId,
-      sessionId: this.sessionId,
-      environment: this.config.environment,
-      release: this.config.release,
-      sdkName: SDK_NAME2,
-      sdkVersion: SDK_VERSION2
-    };
-  }
-  /**
-   * Write to all destinations
-   */
-  write(entry) {
-    for (const dest of this.destinations) {
-      try {
-        dest.write(entry);
-      } catch (error2) {
-        console.error(`[Statly Logger] Failed to write to ${dest.name}:`, error2);
-      }
-    }
-  }
-  // ==================== Public Logging Methods ====================
-  /**
-   * Log a trace message
-   */
-  trace(message, context) {
-    if (!this.shouldLog("trace")) return;
-    this.write(this.createEntry("trace", message, context));
-  }
-  /**
-   * Log a debug message
-   */
-  debug(message, context) {
-    if (!this.shouldLog("debug")) return;
-    this.write(this.createEntry("debug", message, context));
-  }
-  /**
-   * Log an info message
-   */
-  info(message, context) {
-    if (!this.shouldLog("info")) return;
-    this.write(this.createEntry("info", message, context));
-  }
-  /**
-   * Log a warning message
-   */
-  warn(message, context) {
-    if (!this.shouldLog("warn")) return;
-    this.write(this.createEntry("warn", message, context));
-  }
-  error(messageOrError, context) {
-    if (!this.shouldLog("error")) return;
-    if (messageOrError instanceof Error) {
-      const entry = this.createEntry("error", messageOrError.message, {
-        ...context,
-        stack: messageOrError.stack,
-        errorType: messageOrError.name
-      });
-      this.write(entry);
-    } else {
-      this.write(this.createEntry("error", messageOrError, context));
-    }
-  }
-  fatal(messageOrError, context) {
-    if (!this.shouldLog("fatal")) return;
-    if (messageOrError instanceof Error) {
-      const entry = this.createEntry("fatal", messageOrError.message, {
-        ...context,
-        stack: messageOrError.stack,
-        errorType: messageOrError.name
-      });
-      this.write(entry);
-    } else {
-      this.write(this.createEntry("fatal", messageOrError, context));
-    }
-  }
-  /**
-   * Log an audit message (always logged, never sampled)
-   */
-  audit(message, context) {
-    this.write(this.createEntry("audit", message, context));
-  }
-  /**
-   * Log at a specific level
-   */
-  log(level, message, context) {
-    if (!this.shouldLog(level)) return;
-    this.write(this.createEntry(level, message, context));
-  }
-  // ==================== Context & Tags ====================
-  /**
-   * Set persistent context
-   */
-  setContext(context) {
-    this.context = { ...this.context, ...context };
-  }
-  /**
-   * Clear context
-   */
-  clearContext() {
-    this.context = {};
-  }
-  /**
-   * Set a tag
-   */
-  setTag(key, value) {
-    this.tags[key] = value;
-  }
-  /**
-   * Set multiple tags
-   */
-  setTags(tags) {
-    this.tags = { ...this.tags, ...tags };
-  }
-  /**
-   * Clear tags
-   */
-  clearTags() {
-    this.tags = {};
-  }
-  // ==================== Tracing ====================
-  /**
-   * Set trace ID for distributed tracing
-   */
-  setTraceId(traceId) {
-    this.traceId = traceId;
-  }
-  /**
-   * Set span ID
-   */
-  setSpanId(spanId) {
-    this.spanId = spanId;
-  }
-  /**
-   * Clear tracing context
-   */
-  clearTracing() {
-    this.traceId = void 0;
-    this.spanId = void 0;
-  }
-  // ==================== Child Loggers ====================
-  /**
-   * Create a child logger with additional context
-   */
-  child(options = {}) {
-    const childConfig = {
-      ...this.config,
-      loggerName: options.name || `${this.name}.child`,
-      context: { ...this.context, ...options.context },
-      tags: { ...this.tags, ...options.tags }
-    };
-    const child = new _Logger(childConfig);
-    child.traceId = this.traceId;
-    child.spanId = this.spanId;
-    child.sessionId = this.sessionId;
-    return child;
-  }
-  // ==================== AI Features ====================
-  /**
-   * Explain an error using AI
-   */
-  async explainError(error2) {
-    if (!this.ai) {
-      return {
-        summary: "AI features not available (no DSN configured)",
-        possibleCauses: []
-      };
-    }
-    return this.ai.explainError(error2);
-  }
-  /**
-   * Suggest fixes for an error using AI
-   */
-  async suggestFix(error2, context) {
-    if (!this.ai) {
-      return {
-        summary: "AI features not available (no DSN configured)",
-        suggestedFixes: []
-      };
-    }
-    return this.ai.suggestFix(error2, context);
-  }
-  /**
-   * Configure AI features
-   */
-  configureAI(config) {
-    if (this.ai) {
-      if (config.apiKey) this.ai.setApiKey(config.apiKey);
-      if (config.enabled !== void 0) this.ai.setEnabled(config.enabled);
-    }
-  }
-  // ==================== Destination Management ====================
-  /**
-   * Add a custom destination
-   */
-  addDestination(destination) {
-    this.destinations.push(destination);
-  }
-  /**
-   * Remove a destination by name
-   */
-  removeDestination(name) {
-    this.destinations = this.destinations.filter((d) => d.name !== name);
-  }
-  /**
-   * Get all destinations
-   */
-  getDestinations() {
-    return [...this.destinations];
-  }
-  // ==================== Level Configuration ====================
-  /**
-   * Set minimum log level
-   */
-  setLevel(level) {
-    this.minLevel = LOG_LEVELS[level];
-  }
-  /**
-   * Get current minimum level
-   */
-  getLevel() {
-    const entries = Object.entries(LOG_LEVELS);
-    const entry = entries.find(([, value]) => value === this.minLevel);
-    return entry ? entry[0] : "debug";
-  }
-  /**
-   * Check if a level is enabled
-   */
-  isLevelEnabled(level) {
-    return this.shouldLog(level);
-  }
-  // ==================== Lifecycle ====================
-  /**
-   * Flush all destinations
-   */
-  async flush() {
-    await Promise.all(
-      this.destinations.filter((d) => d.flush).map((d) => d.flush())
-    );
-  }
-  /**
-   * Close the logger and all destinations
-   */
-  async close() {
-    await Promise.all(
-      this.destinations.filter((d) => d.close).map((d) => d.close())
-    );
-  }
-  /**
-   * Get logger name
-   */
-  getName() {
-    return this.name;
-  }
-  /**
-   * Get session ID
-   */
-  getSessionId() {
-    return this.sessionId;
-  }
-};
-
-// src/logger/index.ts
-var defaultLogger = null;
-function getDefaultLogger() {
-  if (!defaultLogger) {
-    defaultLogger = new Logger();
-  }
-  return defaultLogger;
-}
-function setDefaultLogger(logger) {
-  defaultLogger = logger;
-}
-function trace2(message, context) {
-  getDefaultLogger().trace(message, context);
-}
-function debug(message, context) {
-  getDefaultLogger().debug(message, context);
-}
-function info(message, context) {
-  getDefaultLogger().info(message, context);
-}
-function warn(message, context) {
-  getDefaultLogger().warn(message, context);
-}
-function error(messageOrError, context) {
-  if (messageOrError instanceof Error) {
-    getDefaultLogger().error(messageOrError, context);
-  } else {
-    getDefaultLogger().error(messageOrError, context);
-  }
-}
-function fatal(messageOrError, context) {
-  if (messageOrError instanceof Error) {
-    getDefaultLogger().fatal(messageOrError, context);
-  } else {
-    getDefaultLogger().fatal(messageOrError, context);
-  }
-}
-function audit(message, context) {
-  getDefaultLogger().audit(message, context);
-}
-
-// src/index.ts
-var client = null;
-function loadDsnFromEnv() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env.STATLY_DSN || process.env.NEXT_PUBLIC_STATLY_DSN || process.env.STATLY_OBSERVE_DSN;
-  }
-  return void 0;
-}
-function loadEnvironmentFromEnv() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env.STATLY_ENVIRONMENT || process.env.NODE_ENV;
-  }
-  return void 0;
-}
-function init(options) {
-  if (client) {
-    console.warn("[Statly] SDK already initialized. Call close() first to reinitialize.");
-    return;
-  }
-  const dsn = options?.dsn || loadDsnFromEnv();
-  if (!dsn) {
-    console.error("[Statly] No DSN provided. Set STATLY_DSN in your environment or pass dsn to init().");
-    console.error("[Statly] Get your DSN at https://statly.live/dashboard/observe/setup");
-    return;
-  }
-  const environment = options?.environment || loadEnvironmentFromEnv();
-  const finalOptions = {
-    ...options,
-    dsn,
-    environment
-  };
-  client = new StatlyClient(finalOptions);
-  client.init();
-}
-function captureException(error2, context) {
-  if (!client) {
-    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
-    return "";
-  }
-  return client.captureException(error2, context);
-}
-function captureMessage(message, level = "info") {
-  if (!client) {
-    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
-    return "";
-  }
-  return client.captureMessage(message, level);
-}
-function setUser(user) {
-  if (!client) {
-    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
-    return;
-  }
-  client.setUser(user);
-}
-function setTag(key, value) {
-  if (!client) {
-    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
-    return;
-  }
-  client.setTag(key, value);
-}
-function setTags(tags) {
-  if (!client) {
-    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
-    return;
-  }
-  client.setTags(tags);
-}
-function addBreadcrumb(breadcrumb) {
-  if (!client) {
-    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
-    return;
-  }
-  client.addBreadcrumb(breadcrumb);
-}
-async function flush() {
-  if (!client) {
-    return;
-  }
-  await client.flush();
-}
-async function close() {
-  if (!client) {
-    return;
-  }
-  await client.close();
-  client = null;
-}
-function getClient() {
-  return client;
-}
-async function trace3(name, operation, tags) {
-  if (!client) {
-    return operation(null);
-  }
-  return client.trace(name, operation, tags);
-}
-function startSpan(name, tags) {
-  if (!client) return null;
-  return client.startSpan(name, tags);
-}
-function captureSpan(span) {
-  if (!client) return "";
-  return client.captureSpan(span);
-}
-var Statly = {
-  init,
+import {
+  Statly,
+  StatlyClient,
+  addBreadcrumb,
   captureException,
   captureMessage,
-  setUser,
-  setTag,
-  setTags,
-  addBreadcrumb,
-  flush,
+  captureNextJsError,
+  captureSpan,
   close,
+  createRequestCapture,
+  expressErrorHandler,
+  flush,
   getClient,
-  trace: trace3,
+  init,
+  requestHandler,
+  setTag,
+  setTags,
+  setUser,
   startSpan,
-  captureSpan
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+  statlyFastifyPlugin,
+  statlyPlugin,
+  trace as trace2,
+  withStatly,
+  withStatlyGetServerSideProps,
+  withStatlyGetStaticProps,
+  withStatlyPagesApi,
+  withStatlyServerAction
+} from "./chunk-RLSLJL6N.js";
+import {
+  AIFeatures,
+  ConsoleDestination,
+  DEFAULT_LEVELS,
+  EXTENDED_LEVELS,
+  FileDestination,
+  LOG_LEVELS,
+  Logger,
+  ObserveDestination,
+  REDACTED,
+  SCRUB_PATTERNS,
+  SENSITIVE_KEYS,
+  Scrubber,
+  audit,
+  debug,
+  error,
+  fatal,
+  formatJson,
+  formatJsonPretty,
+  formatPretty,
+  getConsoleMethod,
+  getDefaultLogger,
+  info,
+  isSensitiveKey,
+  setDefaultLogger,
+  trace,
+  warn
+} from "./chunk-RUEXBTHM.js";
+import "./chunk-NKQPBSKX.js";
+export {
   AIFeatures,
   ConsoleDestination,
   DEFAULT_LEVELS,
@@ -2814,13 +87,13 @@ var Statly = {
   getDefaultLogger,
   init,
   isSensitiveKey,
-  logAudit,
-  logDebug,
-  logError,
-  logFatal,
-  logInfo,
-  logTrace,
-  logWarn,
+  audit as logAudit,
+  debug as logDebug,
+  error as logError,
+  fatal as logFatal,
+  info as logInfo,
+  trace as logTrace,
+  warn as logWarn,
   requestHandler,
   setDefaultLogger,
   setTag,
@@ -2829,10 +102,10 @@ var Statly = {
   startSpan,
   statlyFastifyPlugin,
   statlyPlugin,
-  trace,
+  trace2 as trace,
   withStatly,
   withStatlyGetServerSideProps,
   withStatlyGetStaticProps,
   withStatlyPagesApi,
   withStatlyServerAction
-});
+};