reportli 1.0.3 → 1.0.4

package/dist/index.js

@@ -24,331 +24,668 @@ __export(src_exports, {
   default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-var ENDPOINT = "https://fahikyfmgdyzejdfftox.supabase.co/functions/v1/rapid-processor";
-var initialized = false;
-var _config;
-var queue = [];
-var flushTimer = null;
-var isFlushing = false;
-function scheduleFlush() {
-  if (flushTimer)
-    return;
-  flushTimer = setTimeout(() => {
-    flushTimer = null;
-    flush();
-  }, 2e3);
-}
-async function flush() {
-  if (isFlushing || queue.length === 0)
-    return;
-  isFlushing = true;
-  const batch = queue.splice(0, 10);
-  for (const payload of batch) {
-    await sendNow(payload);
+var REPORTLI_BASE_URL = "https://ais-dev-ohcojup63zslqou25sisle-541405064838.asia-east1.run.app";
+var ReportliTracker = class _ReportliTracker {
+  constructor() {
+    this.config = null;
+    this.isInitialized = false;
+    /**
+     * Express error handler middleware
+     */
+    this.expressErrorHandler = (err, req, res, next) => {
+      if (this.isInitialized && this.config) {
+        try {
+          const errorObject = this.normalizeError(err);
+          const { errorType, severity } = this.classifyError(errorObject, "express");
+          const payload = {
+            apiKey: this.config.apiKey,
+            projectId: this.config.projectId || "express-server",
+            projectName: this.config.projectName || "Express App",
+            errorType: errorType || "Route handler error",
+            errorMessage: `${req.method} ${req.url} - ${errorObject.message}`,
+            errorStack: errorObject.stack || "",
+            framework: this.config.framework || "Express",
+            user_email: this.config.userEmail || req.user?.email || "anonymous",
+            severity: severity || "high",
+            status: "open"
+          };
+          this.sendCrashReport(payload);
+        } catch (e) {
+          console.error("[Reportli SDK] Failed to process express exception:", e);
+        }
+      }
+      next(err);
+    };
+  }
+  /**
+   * Initializes the Reportli tracker with your secure project credentials.
+   */
+  init(config) {
+    if (!config || !config.apiKey) {
+      console.error("[Reportli SDK] Initialization failed: 'apiKey' is required.");
+      return;
+    }
+    if (this.isInitialized) {
+      return;
+    }
+    this.config = {
+      environment: "production",
+      captureUnhandledRejections: true,
+      autoCreateGitHubIssues: true,
+      ...config
+    };
+    this.isInitialized = true;
+    const isBrowser = typeof window !== "undefined";
+    const isNode = typeof process !== "undefined" && process.versions && process.versions.node;
+    if (_ReportliTracker._registrationSent) {
+      return;
+    }
+    this.sendRegistrationWebhook(isBrowser);
+    _ReportliTracker._registrationSent = true;
+    if (isBrowser) {
+      this.setupBrowserListeners();
+    } else if (isNode) {
+      this.setupNodeListeners();
+    }
+    console.log("[Reportli SDK] Exception listener successfully initialized.");
   }
-  isFlushing = false;
-  if (queue.length > 0)
-    flush();
-}
-async function sendNow(payload, attempts = 3) {
-  for (let i = 0; i < attempts; i++) {
+  /**
+   * Manually captures and files a custom application exception with custom severity.
+   */
+  captureException(error, severityInput) {
+    if (!this.isInitialized || !this.config) {
+      console.warn("[Reportli SDK] Capture failed: SDK is not initialized yet.");
+      return;
+    }
+    const errorObject = this.normalizeError(error);
+    const { errorType, severity } = this.classifyError(errorObject);
+    const payload = {
+      apiKey: this.config.apiKey,
+      projectId: this.config.projectId || "proj-sandbox",
+      projectName: this.config.projectName || "SaaS App",
+      errorType,
+      errorMessage: errorObject.message || "Manual trace reported",
+      errorStack: errorObject.stack || "",
+      framework: this.config.framework || (typeof window !== "undefined" ? "React/Next.js Client" : "Node.js Server"),
+      user_email: this.config.userEmail || "anonymous",
+      severity: severityInput || severity,
+      status: "open"
+    };
+    this.sendCrashReport(payload);
+  }
+  /**
+   * Registers global window listeners for DOM-based exceptions.
+   */
+  setupBrowserListeners() {
+    if (typeof window === "undefined")
+      return;
+    window.addEventListener("error", (event) => {
+      if (event.filename && event.filename.includes("rapid-processor"))
+        return;
+      try {
+        const error = event.error || {
+          message: event.message,
+          filename: event.filename,
+          lineno: event.lineno,
+          colno: event.colno,
+          stack: `${event.message} at ${event.filename}:${event.lineno}:${event.colno}`
+        };
+        const errorObject = this.normalizeError(error);
+        const { errorType, severity } = this.classifyError(errorObject);
+        const payload = {
+          apiKey: this.config?.apiKey || "",
+          projectId: this.config?.projectId || "proj-sandbox",
+          projectName: this.config?.projectName || "SaaS App",
+          errorType,
+          errorMessage: errorObject.message,
+          errorStack: errorObject.stack || "",
+          framework: this.config?.framework || "React/Next.js Client",
+          user_email: this.config?.userEmail || "anonymous",
+          severity,
+          status: "open"
+        };
+        this.sendCrashReport(payload);
+      } catch (err) {
+        console.error("[Reportli SDK] Inner listener exception:", err);
+      }
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      try {
+        const reason = event.reason;
+        const errorObject = this.normalizeError(reason);
+        const { errorType, severity } = this.classifyError(errorObject, "unhandledrejection");
+        const payload = {
+          apiKey: this.config?.apiKey || "",
+          projectId: this.config?.projectId || "proj-sandbox",
+          projectName: this.config?.projectName || "SaaS App",
+          errorType,
+          errorMessage: `Unhandled Promise: ${errorObject.message}`,
+          errorStack: errorObject.stack || "",
+          framework: this.config?.framework || "React/Next.js Client",
+          user_email: this.config?.userEmail || "anonymous",
+          severity,
+          status: "open"
+        };
+        this.sendCrashReport(payload);
+      } catch (err) {
+        console.error("[Reportli SDK] Promise rejection listener exception:", err);
+      }
+    });
+    window.addEventListener(
+      "error",
+      (event) => {
+        try {
+          const target = event.target || event.srcElement;
+          if (!target)
+            return;
+          const tagName = target.tagName;
+          if (!tagName)
+            return;
+          let resourceType = "";
+          let sourceUrl = "";
+          if (tagName === "IMG") {
+            resourceType = "Image failed to load";
+            sourceUrl = target.src;
+          } else if (tagName === "SCRIPT") {
+            resourceType = "Script failed to load";
+            sourceUrl = target.src;
+          } else if (tagName === "LINK") {
+            resourceType = "CSS failed to load";
+            sourceUrl = target.href;
+          } else if (tagName === "VIDEO" || tagName === "AUDIO") {
+            resourceType = "Video failed to load";
+            sourceUrl = target.src;
+          }
+          if (resourceType) {
+            const payload = {
+              apiKey: this.config?.apiKey || "",
+              projectId: this.config?.projectId || "proj-sandbox",
+              projectName: this.config?.projectName || "SaaS App",
+              errorType: resourceType,
+              errorMessage: `Failed to load static resource asset: ${sourceUrl}`,
+              errorStack: `HTML Tag: <${tagName.toLowerCase()}> failed to download at location ${window.location.href}`,
+              framework: this.config?.framework || "React/Next.js Client",
+              user_email: this.config?.userEmail || "anonymous",
+              severity: "low",
+              status: "open"
+            };
+            this.sendCrashReport(payload);
+          }
+        } catch (err) {
+          console.error("[Reportli SDK] Resource load listener failure:", err);
+        }
+      },
+      true
+      // capture phase is required for element errors
+    );
+    this.interceptFetch();
+    this.interceptXhr();
+  }
+  /**
+   * Registers node process listeners for server instances.
+   */
+  setupNodeListeners() {
+    if (typeof process === "undefined")
+      return;
+    process.on("uncaughtException", (error) => {
+      try {
+        const errorObject = this.normalizeError(error);
+        const { errorType, severity } = this.classifyError(errorObject, "uncaughtexception");
+        const payload = {
+          apiKey: this.config?.apiKey || "",
+          projectId: this.config?.projectId || "node-server",
+          projectName: this.config?.projectName || "Node Server",
+          errorType,
+          errorMessage: `Uncaught Exception: ${errorObject.message}`,
+          errorStack: errorObject.stack || "",
+          framework: this.config?.framework || "NodeJS backend",
+          user_email: this.config?.userEmail || "anonymous",
+          severity,
+          status: "open"
+        };
+        this.sendCrashReport(payload);
+      } catch (err) {
+        console.error("[Reportli SDK] Node fatal uncaughtexception logging failed:", err);
+      }
+    });
+    process.on("unhandledRejection", (reason) => {
+      try {
+        const errorObject = this.normalizeError(reason);
+        const { errorType, severity } = this.classifyError(errorObject, "unhandledrejection");
+        const payload = {
+          apiKey: this.config?.apiKey || "",
+          projectId: this.config?.projectId || "node-server",
+          projectName: this.config?.projectName || "Node Server",
+          errorType,
+          errorMessage: `Unhandled Rejection: ${errorObject.message}`,
+          errorStack: errorObject.stack || "",
+          framework: this.config?.framework || "NodeJS backend",
+          user_email: this.config?.userEmail || "anonymous",
+          severity,
+          status: "open"
+        };
+        this.sendCrashReport(payload);
+      } catch (err) {
+        console.error("[Reportli SDK] Node fatal unhandledrejection logging failed:", err);
+      }
+    });
+  }
+  /**
+   * Safe payload sender with retry limits.
+   */
+  async sendCrashReport(payload) {
     try {
-      const res = await fetch(ENDPOINT, {
+      if (payload.errorMessage && (payload.errorMessage.includes("rapid-processor") || payload.errorMessage.includes("api/error") || payload.errorMessage.includes("supabase"))) {
+        return;
+      }
+      let destinationUrl = this.config?.endpoint || `${REPORTLI_BASE_URL}/api/error`;
+      const response = await fetch(destinationUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "x-api-key": _config?.apiKey ?? ""
+          "x-api-key": this.config?.apiKey || ""
         },
         body: JSON.stringify(payload)
       });
-      if (res.ok)
-        return;
-    } catch {
+    } catch (err) {
+      console.warn("[Reportli SDK] Failed to synchronize crash traces to diagnostics server:", err);
     }
-    await sleep(1e3 * (i + 1));
   }
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function enqueue(payload) {
-  if (queue.length >= 100)
-    return;
-  queue.push(payload);
-  scheduleFlush();
-}
-function sendImmediate(payload) {
-  sendNow(payload).catch(() => {
-  });
-}
-function getUrl() {
-  if (typeof window !== "undefined")
-    return window.location.href;
-  try {
-    return require("os").hostname();
-  } catch {
-    return "server";
-  }
-}
-function getBrowser() {
-  if (typeof navigator !== "undefined")
-    return navigator.userAgent;
-  return `Node.js ${typeof process !== "undefined" ? process.version : "unknown"}`;
-}
-function getEnvironment() {
-  return _config?.environment ?? (typeof window !== "undefined" ? "browser" : "server");
-}
-function parseStack(stack) {
-  if (!stack)
-    return { file: "unknown", line: 0, column: 0 };
-  const match = stack.match(/at .+ \((.+):(\d+):(\d+)\)/) || stack.match(/at (.+):(\d+):(\d+)/);
-  return {
-    file: match?.[1]?.split("/")?.pop() || "unknown",
-    line: parseInt(match?.[2] || "0"),
-    column: parseInt(match?.[3] || "0")
-  };
-}
-function getErrorCode(error) {
-  return error?.code || error?.status?.toString() || error?.statusCode?.toString() || error?.name || "ERR_UNKNOWN";
-}
-function classifyError(error, context) {
-  const msg = String(error?.message || error || "").toLowerCase();
-  const name = String(error?.name || "").toLowerCase();
-  if (msg.includes("stripe") || msg.includes("payment") || msg.includes("card declined") || msg.includes("checkout") || msg.includes("refund"))
-    return { category: "Payment Error", severity: "critical" };
-  if (msg.includes("jwt") || msg.includes("token expired") || msg.includes("unauthorized") || msg.includes("session") || msg.includes("oauth") || msg.includes("login failed"))
-    return { category: "Auth Error", severity: "high" };
-  if (msg.includes("supabase") || msg.includes("database") || msg.includes("query") || msg.includes("connection lost") || msg.includes("transaction") || msg.includes("duplicate key") || msg.includes("foreign key"))
-    return { category: "Database Error", severity: "critical" };
-  if (msg.includes("hydration") || msg.includes("does not match server"))
-    return { category: "Hydration Error", severity: "high" };
-  if (msg.includes("invalid hook") || msg.includes("rules of hooks"))
-    return { category: "Hook Error", severity: "critical" };
-  if (msg.includes("render") || msg.includes("error boundary"))
-    return { category: "Render Error", severity: "critical" };
-  if (msg.includes("dynamic import") || msg.includes("failed to fetch dynamically"))
-    return { category: "Import Error", severity: "high" };
-  if (msg.includes("cors") || msg.includes("cross-origin"))
-    return { category: "CORS Error", severity: "high" };
-  if (msg.includes("fetch failed") || msg.includes("failed to fetch") || name === "fetcherror")
-    return { category: "Network Error", severity: "high" };
-  if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("etimedout"))
-    return { category: "Timeout Error", severity: "medium" };
-  if (msg.includes("websocket"))
-    return { category: "WebSocket Error", severity: "high" };
-  if (msg.includes("http 401") || msg.includes("xhr 401"))
-    return { category: "Auth Error", severity: "high" };
-  if (msg.includes("http 403") || msg.includes("xhr 403"))
-    return { category: "Auth Error", severity: "high" };
-  if (msg.includes("http 404") || msg.includes("xhr 404"))
-    return { category: "Not Found Error", severity: "medium" };
-  if (msg.includes("http 500") || msg.includes("xhr 500"))
-    return { category: "Server Error", severity: "critical" };
-  if (msg.includes("http 503") || msg.includes("xhr 503"))
-    return { category: "Server Error", severity: "critical" };
-  if (msg.includes("maximum call stack") || msg.includes("out of memory") || msg.includes("heap limit"))
-    return { category: "Memory Error", severity: "critical" };
-  if (msg.includes("cannot find module") || msg.includes("module not found"))
-    return { category: "Module Error", severity: "critical" };
-  if (msg.includes("econnrefused") || msg.includes("connection refused"))
-    return { category: "Connection Error", severity: "critical" };
-  if (msg.includes("email") || msg.includes("smtp") || msg.includes("sendgrid"))
-    return { category: "Email Error", severity: "high" };
-  if (msg.includes("cron") || msg.includes("webhook") || msg.includes("queue"))
-    return { category: "Job Error", severity: "high" };
-  if (msg.includes("upload") || msg.includes("file size") || msg.includes("invalid file"))
-    return { category: "File Error", severity: "medium" };
-  if (msg.includes("quota exceeded") || msg.includes("localstorage") || msg.includes("indexeddb"))
-    return { category: "Storage Error", severity: "medium" };
-  if (name === "typeerror")
-    return { category: "TypeError", severity: "high" };
-  if (name === "referenceerror")
-    return { category: "ReferenceError", severity: "critical" };
-  if (name === "rangeerror")
-    return { category: "RangeError", severity: "high" };
-  if (name === "syntaxerror")
-    return { category: "SyntaxError", severity: "high" };
-  if (context === "unhandledrejection")
-    return { category: "Promise Error", severity: "medium" };
-  if (context === "express")
-    return { category: "Server Error", severity: "high" };
-  if (context === "resource")
-    return { category: "Resource Error", severity: "low" };
-  return { category: "Unknown Error", severity: "medium" };
-}
-function buildErrorPayload(error, context) {
-  const message = error?.message || String(error) || "Unknown error";
-  const stack = error?.stack || "";
-  const { file, line, column } = parseStack(stack);
-  const { category, severity } = classifyError(error, context);
-  return {
-    type: "ERROR",
-    apiKey: _config?.apiKey,
-    message,
-    code: getErrorCode(error),
-    stack,
-    file,
-    line,
-    column,
-    url: getUrl(),
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    environment: getEnvironment(),
-    browser: getBrowser(),
-    error_category: category,
-    severity,
-    status: "open",
-    context: context || "auto"
-  };
-}
-function activateBrowserListeners() {
-  window.addEventListener("error", (event) => {
-    const target = event.target;
-    if (target && target.tagName && ["IMG", "SCRIPT", "LINK", "VIDEO", "AUDIO"].includes(target.tagName)) {
-      const src = target.src || target.href || "unknown";
-      enqueue(buildErrorPayload({ name: "ResourceError", message: `${target.tagName} failed to load: ${src}`, stack: "" }, "resource"));
+  /**
+   * Sends registration verification to user edge function on first install.
+   */
+  sendRegistrationWebhook(isBrowser) {
+    if (!this.config)
       return;
+    const key = `reportli_initialized_success_${this.config.apiKey}`;
+    if (isBrowser && typeof localStorage !== "undefined") {
+      if (localStorage.getItem(key)) {
+        return;
+      }
+      localStorage.setItem(key, "true");
     }
-    const err = event.error || {
-      name: "Error",
-      message: event.message,
-      stack: `at ${event.filename}:${event.lineno}:${event.colno}`
+    const deviceDetails = isBrowser ? typeof navigator !== "undefined" ? navigator.userAgent : "Browser sandbox" : typeof process !== "undefined" ? `NodeJS environment: ${process.version}` : "Cloud instance";
+    const welcomePayload = {
+      apiKey: this.config.apiKey,
+      projectId: this.config.projectId || "proj-sandbox",
+      projectName: this.config.projectName || "SaaS App Component",
+      errorType: "SDK_INITIALIZED",
+      errorMessage: "Reportli SDK successfully initialized! Error listener is active.",
+      errorStack: `SDK Active Diagnostics: Success registration from execution agent. Device context: ${deviceDetails}`,
+      framework: this.config.framework || (isBrowser ? "React/Next.js Client" : "Node.js Server"),
+      user_email: this.config.userEmail || "anonymous",
+      severity: "low",
+      status: "info"
     };
-    enqueue(buildErrorPayload(err, "window"));
-  }, true);
-  window.addEventListener("unhandledrejection", (event) => {
-    const err = event.reason instanceof Error ? event.reason : { name: "UnhandledRejection", message: String(event.reason || "Unhandled Promise Rejection"), stack: "" };
-    enqueue(buildErrorPayload(err, "unhandledrejection"));
-  });
-  const originalFetch = window.fetch;
-  window.fetch = async function(...args) {
-    const url = typeof args[0] === "string" ? args[0] : args[0] instanceof URL ? args[0].toString() : args[0]?.url ?? "";
-    if (url.includes("rapid-processor"))
-      return originalFetch(...args);
-    try {
-      const response = await originalFetch(...args);
-      if (!response.ok) {
-        enqueue(buildErrorPayload({
-          name: `HTTP_${response.status}`,
-          message: `HTTP ${response.status}: ${args[1]?.method || "GET"} ${url}`,
-          stack: `${args[1]?.method || "GET"} ${url} \u2192 ${response.status} ${response.statusText}`,
-          status: response.status
-        }, "fetch"));
+    this.sendCrashReport(welcomePayload);
+  }
+  /**
+   * Capture fetch network status deviations.
+   */
+  interceptFetch() {
+    if (typeof window === "undefined" || typeof window.fetch !== "function")
+      return;
+    const originalFetch = window.fetch;
+    const self = this;
+    window.fetch = async function(input, init) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      if (url.includes("rapid-processor") || url.includes("api/error") || url.includes("supabase.co/functions")) {
+        return originalFetch.apply(this, arguments);
       }
-      return response;
-    } catch (err) {
-      enqueue(buildErrorPayload({
-        name: "FetchError",
-        message: `Fetch failed: ${args[1]?.method || "GET"} ${url} \u2014 ${err.message}`,
-        stack: err.stack
-      }, "fetch"));
-      throw err;
-    }
-  };
-  const originalOpen = XMLHttpRequest.prototype.open;
-  const originalSend = XMLHttpRequest.prototype.send;
-  XMLHttpRequest.prototype.open = function(method, url, ...rest) {
-    this._r_method = method;
-    this._r_url = url;
-    return originalOpen.call(this, method, url, ...rest);
-  };
-  XMLHttpRequest.prototype.send = function(...args) {
-    const url = this._r_url || "";
-    const method = this._r_method || "GET";
-    if (!url.includes("rapid-processor")) {
-      this.addEventListener("loadend", () => {
-        if (this.status >= 400 || this.status === 0) {
-          enqueue(buildErrorPayload({
-            name: `XHR_${this.status}`,
-            message: `XHR ${this.status}: ${method} ${url}`,
-            stack: `${method} ${url} \u2192 ${this.status} ${this.statusText}`,
-            status: this.status
-          }, "xhr"));
+      try {
+        const response = await originalFetch.apply(this, arguments);
+        if (response && !response.ok) {
+          self.logNetworkError(url, response.status, response.statusText, init?.method || "GET");
+        }
+        return response;
+      } catch (err) {
+        self.logNetworkFailure(url, err, init?.method || "GET");
+        throw err;
+      }
+    };
+  }
+  /**
+   * Trace XHR status failures.
+   */
+  interceptXhr() {
+    if (typeof window === "undefined" || typeof XMLHttpRequest === "undefined")
+      return;
+    const originalOpen = XMLHttpRequest.prototype.open;
+    const originalSend = XMLHttpRequest.prototype.send;
+    const self = this;
+    XMLHttpRequest.prototype.open = function(method, url) {
+      this._reportli_method = method;
+      this._reportli_url = url;
+      return originalOpen.apply(this, arguments);
+    };
+    XMLHttpRequest.prototype.send = function() {
+      const xhrInstance = this;
+      xhrInstance.addEventListener("loadend", () => {
+        try {
+          const url = xhrInstance._reportli_url || "";
+          const method = xhrInstance._reportli_method || "GET";
+          const status = xhrInstance.status;
+          if (url.includes("rapid-processor") || url.includes("supabase.co/functions")) {
+            return;
+          }
+          if (status >= 400 || status === 0) {
+            if (status === 0) {
+              self.logNetworkFailure(url, new Error("CORS or Connection Refused"), method);
+            } else {
+              self.logNetworkError(url, status, xhrInstance.statusText || "XHR Error", method);
+            }
+          }
+        } catch (e) {
+          console.error("[Reportli SDK] Failed to extract XHR statistics:", e);
         }
       });
+      return originalSend.apply(this, arguments);
+    };
+  }
+  logNetworkError(url, status, statusText, method) {
+    let errorType = `API ${status} Error`;
+    let severity = "medium";
+    if (status === 400)
+      errorType = "API 400 Bad Request";
+    else if (status === 401) {
+      errorType = "API 401 Unauthorized";
+      severity = "high";
+    } else if (status === 403) {
+      errorType = "API 403 Forbidden";
+      severity = "high";
+    } else if (status === 404)
+      errorType = "API 404 Not Found";
+    else if (status === 500) {
+      errorType = "API 500 Internal Server Error";
+      severity = "high";
+    } else if (status === 503) {
+      errorType = "API 503 Service Unavailable";
+      severity = "high";
     }
-    return originalSend.apply(this, args);
-  };
-  window.addEventListener("beforeunload", () => {
-    try {
-      navigator.sendBeacon(
-        ENDPOINT,
-        JSON.stringify({
-          type: "SDK_DISCONNECTED",
-          apiKey: _config?.apiKey,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          environment: getEnvironment(),
-          url: getUrl()
-        })
-      );
-    } catch {
-    }
-  });
-}
-function activateServerListeners() {
-  process.on("uncaughtException", (error) => {
-    enqueue(buildErrorPayload(error, "uncaughtException"));
-    flush();
-  });
-  process.on("unhandledRejection", (reason) => {
-    enqueue(buildErrorPayload(
-      reason instanceof Error ? reason : { name: "UnhandledRejection", message: String(reason), stack: "" },
-      "unhandledrejection"
-    ));
-  });
-  const shutdown = async (signal) => {
-    await sendNow({
-      type: "SDK_DISCONNECTED",
-      apiKey: _config?.apiKey,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      environment: getEnvironment(),
-      url: getUrl(),
-      signal
-    });
-    process.exit(0);
-  };
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-}
-var Reportli = {
-  init(cfg) {
-    if (initialized)
-      return;
-    if (!cfg?.apiKey)
-      return;
-    _config = cfg;
-    initialized = true;
-    sendImmediate({
-      type: "SDK_INITIALIZED",
-      apiKey: cfg.apiKey,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      environment: getEnvironment(),
-      url: getUrl(),
-      browser: getBrowser()
-    });
-    if (typeof window !== "undefined") {
-      activateBrowserListeners();
-    } else if (typeof process !== "undefined" && process.versions?.node) {
-      activateServerListeners();
-    }
-  },
-  capture(error) {
-    if (!initialized)
-      return;
-    const err = error instanceof Error ? error : { name: "ManualCapture", message: String(error), stack: new Error().stack };
-    enqueue(buildErrorPayload(err, "manual"));
-  },
-  captureMessage(message) {
-    if (!initialized)
-      return;
-    enqueue(buildErrorPayload({ name: "Message", message, stack: "" }, "manual"));
-  },
-  errorHandler() {
-    return function(err, _req, _res, next) {
-      enqueue(buildErrorPayload(err, "express"));
-      next(err);
+    const payload = {
+      apiKey: this.config?.apiKey || "",
+      projectId: this.config?.projectId || "proj-sandbox",
+      projectName: this.config?.projectName || "SaaS App",
+      errorType,
+      errorMessage: `HTTP API failed with code ${status}: ${method} ${url}`,
+      errorStack: `Network Request Header Context: [Method: ${method}] Url: ${url} Response Description: ${statusText || "Dev server returned error."}`,
+      framework: this.config?.framework || "React/Next.js Client",
+      user_email: this.config?.userEmail || "anonymous",
+      severity,
+      status: "open"
+    };
+    this.sendCrashReport(payload);
+  }
+  logNetworkFailure(url, error, method) {
+    const errorMsg = String(error.message || error || "");
+    let errorType = "Fetch failed error";
+    let severity = "high";
+    if (errorMsg.includes("timeout") || errorMsg.includes("abort")) {
+      errorType = "Request timeout error";
+      severity = "medium";
+    } else if (errorMsg.includes("CORS") || errorMsg.includes("origin") || errorMsg.includes("Access-Control")) {
+      errorType = "CORS error";
+    }
+    const payload = {
+      apiKey: this.config?.apiKey || "",
+      projectId: this.config?.projectId || "proj-sandbox",
+      projectName: this.config?.projectName || "SaaS App",
+      errorType,
+      errorMessage: `Failed to complete HTTP request: [${method}] ${url}`,
+      errorStack: `Network crash context: ${errorMsg}
+Connection status: Failed to resolve.`,
+      framework: this.config?.framework || "React/Next.js Client",
+      user_email: this.config?.userEmail || "anonymous",
+      severity,
+      status: "open"
+    };
+    this.sendCrashReport(payload);
+  }
+  /**
+   * Helper to safely format raw objects / strings into structured Errors
+   */
+  normalizeError(err) {
+    if (err instanceof Error) {
+      return {
+        name: err.name,
+        message: err.message,
+        stack: err.stack
+      };
+    }
+    if (typeof err === "string") {
+      return {
+        name: "Error",
+        message: err,
+        stack: new Error(err).stack
+      };
+    }
+    if (err && typeof err === "object") {
+      return {
+        name: err.name || err.code || "Error",
+        message: err.message || err.reason || JSON.stringify(err),
+        stack: err.stack || err.traceback || new Error(err.message).stack
+      };
+    }
+    return {
+      name: "Error",
+      message: "An unhandled execution trace slipped past standard boundaries.",
+      stack: new Error().stack
     };
   }
+  /**
+   * Comprehensive classification rules checking substring and classifications
+   */
+  classifyError(error, context) {
+    const msg = String(error.message || error || "").toLowerCase();
+    const name = String(error.name || "").toLowerCase();
+    if (name.includes("quotaexceeded") || msg.includes("quota exceeded") || msg.includes("localstorage") || msg.includes("sessionstorage") || msg.includes("indexeddb")) {
+      return { errorType: "localStorage quota exceeded", severity: "medium" };
+    }
+    if (msg.includes("hydration") || msg.includes("does not match server") || msg.includes("text content did not match")) {
+      return { errorType: "React hydration error", severity: "high" };
+    }
+    if (msg.includes("invalid hook call") || msg.includes("rules of hooks")) {
+      return { errorType: "Invalid hook call error", severity: "critical" };
+    }
+    if (msg.includes("failed prop type") || msg.includes("invalid prop")) {
+      return { errorType: "Props type error", severity: "low" };
+    }
+    if (msg.includes("render") || msg.includes("react error boundary") || msg.includes("component render")) {
+      return { errorType: "Component render error", severity: "critical" };
+    }
+    if (msg.includes("route not found") || msg.includes("cannot find route") || msg.includes("404 route")) {
+      return { errorType: "Route not found error", severity: "medium" };
+    }
+    if (msg.includes("failed to fetch dynamically imported") || msg.includes("dynamic import")) {
+      return { errorType: "Dynamic import error", severity: "high" };
+    }
+    if (msg.includes("suspense") || msg.includes("fallback")) {
+      return { errorType: "Suspense boundary error", severity: "medium" };
+    }
+    if (name === "typeerror" || msg.startsWith("typeerror")) {
+      return { errorType: "TypeError", severity: "high" };
+    }
+    if (name === "referenceerror" || msg.startsWith("referenceerror")) {
+      return { errorType: "ReferenceError", severity: "critical" };
+    }
+    if (name === "rangeerror" || msg.startsWith("rangeerror")) {
+      if (msg.includes("maximum call stack") || msg.includes("stack overflow")) {
+        return { errorType: "Stack overflow error", severity: "critical" };
+      }
+      return { errorType: "RangeError", severity: "high" };
+    }
+    if (name === "syntaxerror" || msg.startsWith("syntaxerror")) {
+      return { errorType: "SyntaxError", severity: "high" };
+    }
+    if (name === "evalerror") {
+      return { errorType: "EvalError", severity: "medium" };
+    }
+    if (name === "urierror") {
+      return { errorType: "URIError", severity: "medium" };
+    }
+    if (msg.includes("stripe") && (msg.includes("key") || msg.includes("init") || msg.includes("key is required") || msg.includes("is not defined"))) {
+      return { errorType: "Stripe initialization error", severity: "critical" };
+    }
+    if (msg.includes("stripe") && (msg.includes("payment") || msg.includes("processing") || msg.includes("charge"))) {
+      return { errorType: "Payment processing error", severity: "critical" };
+    }
+    if (msg.includes("card declined") || msg.includes("card_declined") || msg.includes("declined")) {
+      return { errorType: "Card declined error", severity: "high" };
+    }
+    if (msg.includes("checkout session") || msg.includes("create checkout")) {
+      return { errorType: "Checkout session error", severity: "high" };
+    }
+    if (msg.includes("refund failed") || msg.includes("refund_failed")) {
+      return { errorType: "Refund failed error", severity: "high" };
+    }
+    if (msg.includes("supabase query") || msg.includes("postgresterror")) {
+      return { errorType: "Supabase query error", severity: "critical" };
+    }
+    if (msg.includes("unique constraint") || msg.includes("duplicate key")) {
+      return { errorType: "Unique constraint error", severity: "high" };
+    }
+    if (msg.includes("foreign key")) {
+      return { errorType: "Foreign key error", severity: "high" };
+    }
+    if (msg.includes("transaction failed") || msg.includes("rollback")) {
+      return { errorType: "Transaction failed error", severity: "critical" };
+    }
+    if (msg.includes("connection lost") || msg.includes("db connection") || msg.includes("connection refused") || msg.includes("econnrefused")) {
+      return { errorType: "Connection lost error", severity: "critical" };
+    }
+    if (msg.includes("query timeout") || msg.includes("statement timeout")) {
+      return { errorType: "Query timeout error", severity: "high" };
+    }
+    if (msg.includes("jwt expired") || msg.includes("token expired") || msg.includes("jsonwebtokenexpired")) {
+      return { errorType: "JWT expired error", severity: "high" };
+    }
+    if (msg.includes("jwt verification") || msg.includes("invalid signature") || msg.includes("jwt malformed")) {
+      return { errorType: "JWT verification error", severity: "high" };
+    }
+    if (msg.includes("firebase-admin") || msg.includes("firebase admin")) {
+      return { errorType: "Firebase admin error", severity: "critical" };
+    }
+    if (msg.includes("session creation") || msg.includes("create session")) {
+      return { errorType: "Session creation error", severity: "high" };
+    }
+    if (msg.includes("password hash") || msg.includes("bcrypt") || msg.includes("argon2")) {
+      return { errorType: "Password hash error", severity: "critical" };
+    }
+    if (msg.includes("auth/id-token-expired") || msg.includes("id token expired")) {
+      return { errorType: "Token expired error", severity: "high" };
+    }
+    if (msg.includes("invalid-credential") || msg.includes("auth/invalid-credential") || msg.includes("invalid token")) {
+      return { errorType: "Invalid token error", severity: "high" };
+    }
+    if (msg.includes("session ended") || msg.includes("session expired")) {
+      return { errorType: "Session ended error", severity: "medium" };
+    }
+    if (msg.includes("oauth callback") || msg.includes("oauth error")) {
+      return { errorType: "OAuth callback error", severity: "high" };
+    }
+    if (msg.includes("login failed") || msg.includes("invalid credentials")) {
+      return { errorType: "Login failed error", severity: "medium" };
+    }
+    if (msg.includes("unauthorized") || msg.includes("permission denied") || msg.includes("forbidden") || msg.includes("unauthorized access") || msg.includes("permission_denied")) {
+      return { errorType: "Unauthorized access error", severity: "high" };
+    }
+    if (msg.includes("cron job") || msg.includes("cron_failed") || msg.includes("cron failed")) {
+      return { errorType: "Cron job failed", severity: "high" };
+    }
+    if (msg.includes("queue processing") || msg.includes("bullmq") || msg.includes("redis queue") || msg.includes("celery error")) {
+      return { errorType: "Queue processing error", severity: "high" };
+    }
+    if (msg.includes("webhook delivery") || msg.includes("webhook_failed") || msg.includes("webhook failed")) {
+      return { errorType: "Webhook delivery failed", severity: "high" };
+    }
+    if (msg.includes("retry limit exceeded") || msg.includes("max retries")) {
+      return { errorType: "Retry limit exceeded", severity: "high" };
+    }
+    if (msg.includes("out of memory") || msg.includes("oom") || msg.includes("heap limit") || msg.includes("heap out of memory")) {
+      return { errorType: "Out of memory error", severity: "critical" };
+    }
+    if (msg.includes("cannot find module") || msg.includes("module_not_found") || msg.includes("module not found")) {
+      return { errorType: "Module not found error", severity: "critical" };
+    }
+    if (msg.includes("process crash") || msg.includes("sigterm") || msg.includes("sigint") || msg.includes("process.exit")) {
+      return { errorType: "Process crash error", severity: "critical" };
+    }
+    if (context === "express" || msg.includes("route handler") || msg.includes("api router")) {
+      return { errorType: "Route handler error", severity: "high" };
+    }
+    if (msg.includes("middleware")) {
+      return { errorType: "Middleware error", severity: "high" };
+    }
+    if (msg.includes("validation error") || msg.includes("zoderror") || msg.includes("joi validation")) {
+      return { errorType: "Request validation error", severity: "medium" };
+    }
+    if (msg.includes("body parser") || msg.includes("multer") || msg.includes("multipart") || msg.includes("body-parser")) {
+      return { errorType: "Body parser error", severity: "high" };
+    }
+    if (msg.includes("too many requests") || msg.includes("rate limit") || msg.includes("429")) {
+      return { errorType: "Rate limit error", severity: "high" };
+    }
+    if (msg.includes("file upload") || msg.includes("upload failed") || msg.includes("cloudinary") || msg.includes("s3 upload") || msg.includes("multipart upload")) {
+      return { errorType: "File upload failed", severity: "high" };
+    }
+    if (msg.includes("file size exceeded") || msg.includes("payload too large") || msg.includes("size validation")) {
+      return { errorType: "File size exceeded", severity: "medium" };
+    }
+    if (msg.includes("invalid file type") || msg.includes("mime type mismatch") || msg.includes("file format")) {
+      return { errorType: "Invalid file type", severity: "medium" };
+    }
+    if (msg.includes("storage quota exceeded") || msg.includes("bucket quota") || msg.includes("exhausted quota")) {
+      return { errorType: "Storage quota exceeded", severity: "high" };
+    }
+    if (msg.includes("cdn ") || msg.includes("upload to cdn") || msg.includes("cdn distribution")) {
+      return { errorType: "CDN upload failed", severity: "high" };
+    }
+    if (msg.includes("email sending failed") || msg.includes("sendgrid") || msg.includes("nodemailer") || msg.includes("resend")) {
+      return { errorType: "Email sending failed", severity: "high" };
+    }
+    if (msg.includes("smtp connection") || msg.includes("smtp error") || msg.includes("mail connection")) {
+      return { errorType: "SMTP connection error", severity: "high" };
+    }
+    if (msg.includes("template rendering") || msg.includes("mjml") || msg.includes("pug render")) {
+      return { errorType: "Template rendering error", severity: "medium" };
+    }
+    if (msg.includes("onesignal") || msg.includes("push notification") || msg.includes("fcm payload")) {
+      return { errorType: "OneSignal API error", severity: "high" };
+    }
+    if (msg.includes("cors") || msg.includes("cross-origin") || msg.includes("preflight") || msg.includes("access-control-allow")) {
+      return { errorType: "CORS error", severity: "high" };
+    }
+    if (msg.includes("fetch failed") || msg.includes("failed to fetch")) {
+      return { errorType: "Fetch failed error", severity: "high" };
+    }
+    if (msg.includes("timeout") || msg.includes("aborted") || msg.includes("timed out") || msg.includes("etimedout")) {
+      return { errorType: "Request timeout error", severity: "medium" };
+    }
+    if (msg.includes("websocket connection") || msg.includes("ws connection failed") || msg.includes("ws://") || msg.includes("wss://")) {
+      return { errorType: "WebSocket connection error", severity: "high" };
+    }
+    if (msg.includes("websocket closed") || msg.includes("websocket disconnected") || msg.includes("ws.close")) {
+      return { errorType: "WebSocket disconnect error", severity: "medium" };
+    }
+    if (context === "unhandledrejection") {
+      return { errorType: "Unhandled promise rejection", severity: "medium" };
+    }
+    if (msg.includes("async") && msg.includes("await")) {
+      return { errorType: "Async await failure", severity: "high" };
+    }
+    if (msg.includes("promise chain") || msg.includes("promise.all") || msg.includes("promise.race")) {
+      return { errorType: "Promise chain error", severity: "high" };
+    }
+    if (msg.includes("promise timed out") || msg.includes("promise timeout")) {
+      return { errorType: "Promise timeout error", severity: "medium" };
+    }
+    if (context === "uncaughtexception") {
+      return { errorType: "Uncaught exception", severity: "high" };
+    }
+    return { errorType: "Uncaught exception", severity: "medium" };
+  }
 };
+var Reportli = new ReportliTracker();
 var src_default = Reportli;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {