@crashsense/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1219 @@
+'use strict';
+
+var utils = require('@crashsense/utils');
+
+// src/crashsense.ts
+
+// src/config.ts
+var SDK_VERSION = "0.1.0";
+function resolveConfig(userConfig) {
+  if (!userConfig.appId) {
+    throw new Error("[CrashSense] appId is required");
+  }
+  const sampleRate = userConfig.sampleRate ?? 1;
+  if (sampleRate < 0 || sampleRate > 1) {
+    throw new Error("[CrashSense] sampleRate must be between 0 and 1");
+  }
+  const maxEventsPerMinute = userConfig.maxEventsPerMinute ?? 30;
+  if (maxEventsPerMinute <= 0) {
+    throw new Error("[CrashSense] maxEventsPerMinute must be positive");
+  }
+  return {
+    appId: userConfig.appId,
+    environment: userConfig.environment ?? "production",
+    release: userConfig.release ?? "",
+    sampleRate,
+    maxEventsPerMinute,
+    enableMemoryMonitoring: userConfig.enableMemoryMonitoring ?? true,
+    enableLongTaskMonitoring: userConfig.enableLongTaskMonitoring ?? true,
+    enableNetworkMonitoring: userConfig.enableNetworkMonitoring ?? true,
+    enableIframeTracking: userConfig.enableIframeTracking ?? true,
+    enablePreCrashWarning: userConfig.enablePreCrashWarning ?? true,
+    preCrashMemoryThreshold: userConfig.preCrashMemoryThreshold ?? 0.8,
+    piiScrubbing: userConfig.piiScrubbing ?? true,
+    debug: userConfig.debug ?? false,
+    onCrash: userConfig.onCrash ?? null
+  };
+}
+
+// src/error-interceptor.ts
+var IGNORED_MESSAGES = [
+  "ResizeObserver loop limit exceeded",
+  "ResizeObserver loop completed with undelivered notifications"
+];
+function isIgnoredError(message, filename) {
+  if (IGNORED_MESSAGES.some((m) => message.includes(m))) return true;
+  if (filename?.startsWith("chrome-extension://")) return true;
+  if (filename?.startsWith("moz-extension://")) return true;
+  if (message === "Script error." || message === "Script error") return true;
+  return false;
+}
+function createErrorInterceptor(bus) {
+  let errorHandler = null;
+  let rejectionHandler = null;
+  return {
+    install() {
+      if (typeof window === "undefined") return;
+      errorHandler = (event) => {
+        if (isIgnoredError(event.message, event.filename)) return;
+        const error = event.error instanceof Error ? event.error : new Error(event.message);
+        bus.emit("error", {
+          error,
+          timestamp: performance.now() + performance.timeOrigin
+        });
+      };
+      rejectionHandler = (event) => {
+        const reason = event.reason;
+        bus.emit("unhandled_rejection", {
+          reason,
+          timestamp: performance.now() + performance.timeOrigin
+        });
+      };
+      window.addEventListener("error", errorHandler);
+      window.addEventListener("unhandledrejection", rejectionHandler);
+    },
+    uninstall() {
+      if (typeof window === "undefined") return;
+      if (errorHandler) window.removeEventListener("error", errorHandler);
+      if (rejectionHandler) window.removeEventListener("unhandledrejection", rejectionHandler);
+      errorHandler = null;
+      rejectionHandler = null;
+    }
+  };
+}
+var SAMPLE_INTERVAL = 5e3;
+var HISTORY_SIZE = 12;
+var WARNING_THRESHOLD = 0.85;
+function computeTrend(samples) {
+  if (samples.length < 3) return "stable";
+  const recent = samples.slice(-6);
+  const first = recent[0].used;
+  const last = recent[recent.length - 1].used;
+  const growthRate = (last - first) / first;
+  if (growthRate > 0.2) return "growing";
+  if (growthRate < -0.2) return "shrinking";
+  const shortRecent = samples.slice(-3);
+  const min = Math.min(...shortRecent.map((s) => s.used));
+  const max = Math.max(...shortRecent.map((s) => s.used));
+  if (max > 0 && (max - min) / max > 0.2) return "spike";
+  return "stable";
+}
+function createMemoryMonitor(bus, _config) {
+  const history2 = new utils.RingBuffer(HISTORY_SIZE);
+  let intervalId = null;
+  function hasPerformanceMemory() {
+    return typeof performance !== "undefined" && "memory" in performance && performance.memory !== void 0;
+  }
+  function sample() {
+    if (!hasPerformanceMemory()) return;
+    const mem = performance.memory;
+    const s = {
+      used: mem.usedJSHeapSize,
+      total: mem.totalJSHeapSize,
+      limit: mem.jsHeapSizeLimit,
+      timestamp: Date.now()
+    };
+    history2.push(s);
+    const utilization = s.limit > 0 ? s.used / s.limit : 0;
+    if (utilization > WARNING_THRESHOLD) {
+      const samples = history2.drain();
+      bus.emit("memory_warning", {
+        utilization,
+        trend: computeTrend(samples),
+        timestamp: performance.now() + performance.timeOrigin
+      });
+    }
+  }
+  return {
+    start() {
+      if (!hasPerformanceMemory()) return;
+      sample();
+      intervalId = setInterval(sample, SAMPLE_INTERVAL);
+    },
+    stop() {
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+    },
+    getSnapshot() {
+      if (!hasPerformanceMemory()) {
+        return {
+          usedJSHeapSize: null,
+          totalJSHeapSize: null,
+          heapSizeLimit: null,
+          trend: "stable",
+          utilizationPercent: null
+        };
+      }
+      const mem = performance.memory;
+      const samples = history2.drain();
+      const utilization = mem.jsHeapSizeLimit > 0 ? mem.usedJSHeapSize / mem.jsHeapSizeLimit : null;
+      return {
+        usedJSHeapSize: mem.usedJSHeapSize,
+        totalJSHeapSize: mem.totalJSHeapSize,
+        heapSizeLimit: mem.jsHeapSizeLimit,
+        trend: computeTrend(samples),
+        utilizationPercent: utilization !== null ? Math.round(utilization * 100) : null
+      };
+    }
+  };
+}
+var LONG_TASK_THRESHOLD = 100;
+var HISTORY_SIZE2 = 200;
+function createEventLoopMonitor(bus, _config) {
+  const taskHistory = new utils.RingBuffer(HISTORY_SIZE2);
+  let observer = null;
+  let rafId = null;
+  let lastFrameTime = 0;
+  let fps = 60;
+  function supportsLongTasks() {
+    if (typeof PerformanceObserver === "undefined") return false;
+    try {
+      const supported = PerformanceObserver.supportedEntryTypes;
+      return Array.isArray(supported) && supported.includes("longtask");
+    } catch {
+      return false;
+    }
+  }
+  function measureFps(timestamp) {
+    if (lastFrameTime > 0) {
+      const delta = timestamp - lastFrameTime;
+      if (delta > 0) {
+        const instantFps = 1e3 / delta;
+        fps = fps * 0.9 + instantFps * 0.1;
+      }
+    }
+    lastFrameTime = timestamp;
+    rafId = requestAnimationFrame(measureFps);
+  }
+  return {
+    start() {
+      if (typeof window === "undefined") return;
+      if (supportsLongTasks()) {
+        observer = new PerformanceObserver((list) => {
+          for (const entry of list.getEntries()) {
+            const task = {
+              duration: entry.duration,
+              startTime: entry.startTime
+            };
+            taskHistory.push(task);
+            if (entry.duration > LONG_TASK_THRESHOLD) {
+              bus.emit("long_task", {
+                duration: entry.duration,
+                startTime: entry.startTime,
+                timestamp: performance.now() + performance.timeOrigin
+              });
+            }
+          }
+        });
+        observer.observe({ entryTypes: ["longtask"] });
+      }
+      if (typeof requestAnimationFrame !== "undefined") {
+        rafId = requestAnimationFrame(measureFps);
+      }
+    },
+    stop() {
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+      if (rafId !== null && typeof cancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+    },
+    getCpuSnapshot() {
+      const now = performance.now();
+      const tasks = taskHistory.drain();
+      const recentTasks = tasks.filter((t) => now - t.startTime < 3e4);
+      const durations = recentTasks.map((t) => t.duration);
+      const totalBlocking = durations.filter((d) => d > 50).reduce((sum, d) => sum + (d - 50), 0);
+      return {
+        longTasksLast30s: recentTasks.length,
+        avgLongTaskDuration: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+        maxLongTaskDuration: durations.length > 0 ? Math.max(...durations) : 0,
+        estimatedBlockingTime: totalBlocking
+      };
+    },
+    getEventLoopSnapshot() {
+      const cpuState = this.getCpuSnapshot();
+      return {
+        isBlocked: cpuState.maxLongTaskDuration > 1e3,
+        blockDuration: cpuState.maxLongTaskDuration > 0 ? cpuState.maxLongTaskDuration : null,
+        fps: Math.round(fps)
+      };
+    }
+  };
+}
+var HISTORY_SIZE3 = 100;
+function createNetworkMonitor(bus, _config) {
+  const history2 = new utils.RingBuffer(HISTORY_SIZE3);
+  let originalFetch = null;
+  let pendingCount = 0;
+  function wrapFetch() {
+    if (typeof window === "undefined" || typeof fetch === "undefined") return;
+    originalFetch = window.fetch;
+    window.fetch = async function patchedFetch(input, init) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      const method = init?.method ?? "GET";
+      const startTime = performance.now();
+      pendingCount++;
+      try {
+        const response = await originalFetch.call(window, input, init);
+        const duration = performance.now() - startTime;
+        pendingCount--;
+        const request = {
+          url,
+          method,
+          status: response.status,
+          duration,
+          startTime,
+          error: null,
+          responseSize: null
+        };
+        history2.push(request);
+        if (response.status >= 500 || response.status === 0) {
+          bus.emit("network_failure", {
+            url,
+            status: response.status,
+            error: `HTTP ${response.status}`,
+            timestamp: performance.now() + performance.timeOrigin
+          });
+        }
+        return response;
+      } catch (err) {
+        const duration = performance.now() - startTime;
+        pendingCount--;
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const request = {
+          url,
+          method,
+          status: 0,
+          duration,
+          startTime,
+          error: errorMsg,
+          responseSize: null
+        };
+        history2.push(request);
+        bus.emit("network_failure", {
+          url,
+          status: 0,
+          error: errorMsg,
+          timestamp: performance.now() + performance.timeOrigin
+        });
+        throw err;
+      }
+    };
+  }
+  return {
+    start() {
+      wrapFetch();
+    },
+    stop() {
+      if (originalFetch && typeof window !== "undefined") {
+        window.fetch = originalFetch;
+        originalFetch = null;
+      }
+    },
+    getSnapshot() {
+      const now = performance.now();
+      const requests = history2.drain();
+      const recentRequests = requests.filter((r) => now - r.startTime < 6e4);
+      const failedCount = recentRequests.filter(
+        (r) => r.status === 0 || r.status >= 500 || r.error !== null
+      ).length;
+      const latencies = recentRequests.filter((r) => r.error === null).map((r) => r.duration);
+      const avgLatency = latencies.length > 0 ? latencies.reduce((a, b) => a + b, 0) / latencies.length : 0;
+      let connectionType = null;
+      if (typeof navigator !== "undefined" && "connection" in navigator) {
+        const conn = navigator.connection;
+        connectionType = conn?.effectiveType ?? null;
+      }
+      return {
+        pendingRequests: pendingCount,
+        failedRequestsLast60s: failedCount,
+        avgLatencyLast60s: Math.round(avgLatency),
+        connectionType,
+        isOnline: typeof navigator !== "undefined" ? navigator.onLine : true
+      };
+    }
+  };
+}
+var BUFFER_SIZE = 50;
+function createBreadcrumbTracker(bus) {
+  const buffer = new utils.RingBuffer(BUFFER_SIZE);
+  let clickHandler = null;
+  let originalPushState = null;
+  let originalReplaceState = null;
+  function addBreadcrumb(bc) {
+    const crumb = {
+      ...bc,
+      timestamp: performance.now() + performance.timeOrigin
+    };
+    buffer.push(crumb);
+    bus.emit("breadcrumb", crumb);
+  }
+  function getElementDescription(target) {
+    if (!target || !(target instanceof Element)) return "unknown";
+    const tag = target.tagName.toLowerCase();
+    const id = target.id ? `#${target.id}` : "";
+    const cls = target.className && typeof target.className === "string" ? `.${target.className.split(" ").slice(0, 2).join(".")}` : "";
+    const text = target.textContent?.trim().slice(0, 30) ?? "";
+    return `${tag}${id}${cls}${text ? ` "${text}"` : ""}`;
+  }
+  return {
+    install() {
+      if (typeof window === "undefined") return;
+      clickHandler = (e) => {
+        addBreadcrumb({
+          type: "click",
+          message: `Click on ${getElementDescription(e.target)}`
+        });
+      };
+      document.addEventListener("click", clickHandler, { capture: true, passive: true });
+      originalPushState = history.pushState;
+      history.pushState = function(...args) {
+        addBreadcrumb({
+          type: "navigation",
+          message: `pushState to ${String(args[2] ?? "")}`
+        });
+        return originalPushState.apply(this, args);
+      };
+      originalReplaceState = history.replaceState;
+      history.replaceState = function(...args) {
+        addBreadcrumb({
+          type: "navigation",
+          message: `replaceState to ${String(args[2] ?? "")}`
+        });
+        return originalReplaceState.apply(this, args);
+      };
+      bus.on("error", (data) => {
+        addBreadcrumb({
+          type: "console",
+          message: `Error: ${data.error.message}`
+        });
+      });
+      bus.on("network_failure", (data) => {
+        addBreadcrumb({
+          type: "network",
+          message: `Network failure: ${data.url} (${data.error})`
+        });
+      });
+    },
+    uninstall() {
+      if (typeof window === "undefined") return;
+      if (clickHandler) {
+        document.removeEventListener("click", clickHandler, { capture: true });
+        clickHandler = null;
+      }
+      if (originalPushState) {
+        history.pushState = originalPushState;
+        originalPushState = null;
+      }
+      if (originalReplaceState) {
+        history.replaceState = originalReplaceState;
+        originalReplaceState = null;
+      }
+    },
+    getBreadcrumbs() {
+      return buffer.drain();
+    },
+    addBreadcrumb
+  };
+}
+
+// src/iframe-tracker.ts
+var HISTORY_WINDOW = 6e4;
+function extractOrigin(src) {
+  try {
+    return new URL(src, location.href).origin;
+  } catch {
+    return "unknown";
+  }
+}
+function isCrossOrigin(origin) {
+  if (typeof location === "undefined") return false;
+  return origin !== "unknown" && origin !== location.origin;
+}
+function createIframeTracker(bus, _config) {
+  const events = [];
+  let observer = null;
+  let currentCount = 0;
+  function pruneOldEvents() {
+    const cutoff = Date.now() - HISTORY_WINDOW;
+    while (events.length > 0 && events[0].timestamp < cutoff) {
+      events.shift();
+    }
+  }
+  function countCurrentIframes() {
+    if (typeof document === "undefined") return 0;
+    return document.querySelectorAll("iframe").length;
+  }
+  function handleAddedIframe(iframe) {
+    const src = iframe.src || iframe.getAttribute("src") || "";
+    const origin = extractOrigin(src);
+    const crossOrigin = isCrossOrigin(origin);
+    currentCount = countCurrentIframes();
+    const now = Date.now();
+    events.push({ src, origin, crossOrigin, timestamp: now, action: "added" });
+    bus.emit("iframe_added", {
+      src,
+      origin,
+      crossOrigin,
+      totalCount: currentCount,
+      timestamp: performance.now() + performance.timeOrigin
+    });
+  }
+  function handleRemovedIframe(iframe) {
+    const src = iframe.src || iframe.getAttribute("src") || "";
+    currentCount = countCurrentIframes();
+    events.push({ src, origin: extractOrigin(src), crossOrigin: false, timestamp: Date.now(), action: "removed" });
+    bus.emit("iframe_removed", {
+      src,
+      totalCount: currentCount,
+      timestamp: performance.now() + performance.timeOrigin
+    });
+  }
+  function processNodes(nodes, action) {
+    for (const node of Array.from(nodes)) {
+      if (node instanceof HTMLIFrameElement) {
+        if (action === "added") handleAddedIframe(node);
+        else handleRemovedIframe(node);
+      }
+      if (node instanceof Element) {
+        const nested = node.querySelectorAll("iframe");
+        for (const iframe of Array.from(nested)) {
+          if (action === "added") handleAddedIframe(iframe);
+          else handleRemovedIframe(iframe);
+        }
+      }
+    }
+  }
+  return {
+    start() {
+      if (typeof window === "undefined" || typeof MutationObserver === "undefined") return;
+      currentCount = countCurrentIframes();
+      observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          if (mutation.addedNodes.length > 0) processNodes(mutation.addedNodes, "added");
+          if (mutation.removedNodes.length > 0) processNodes(mutation.removedNodes, "removed");
+        }
+      });
+      observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true
+      });
+    },
+    stop() {
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+    },
+    getSnapshot() {
+      pruneOldEvents();
+      const addedLast60s = events.filter((e) => e.action === "added").length;
+      const removedLast60s = events.filter((e) => e.action === "removed").length;
+      const originsSet = /* @__PURE__ */ new Set();
+      let crossOriginCount = 0;
+      if (typeof document !== "undefined") {
+        const iframes = document.querySelectorAll("iframe");
+        for (const iframe of Array.from(iframes)) {
+          const src = iframe.src || iframe.getAttribute("src") || "";
+          const origin = extractOrigin(src);
+          originsSet.add(origin);
+          if (isCrossOrigin(origin)) crossOriginCount++;
+        }
+      }
+      return {
+        totalCount: currentCount,
+        addedLast60s,
+        removedLast60s,
+        origins: Array.from(originsSet),
+        crossOriginCount
+      };
+    }
+  };
+}
+
+// src/pre-crash-warning.ts
+var CHECK_INTERVAL = 3e3;
+var TREND_WINDOW = 5;
+function createPreCrashWarning(bus, config, memoryMonitor, iframeTracker) {
+  let intervalId = null;
+  let lastLevel = null;
+  const recentReadings = [];
+  function getMemoryUtilization() {
+    const snap = memoryMonitor.getSnapshot();
+    return snap.utilizationPercent !== null ? snap.utilizationPercent / 100 : null;
+  }
+  function isGrowingTrend() {
+    if (recentReadings.length < 3) return false;
+    const recent = recentReadings.slice(-TREND_WINDOW);
+    let increases = 0;
+    for (let i = 1; i < recent.length; i++) {
+      if (recent[i].utilization > recent[i - 1].utilization) increases++;
+    }
+    return increases >= Math.floor(recent.length * 0.6);
+  }
+  function computeLevel(memUtil, iframeCount) {
+    const threshold = config.preCrashMemoryThreshold;
+    if (memUtil !== null && memUtil > 0.95) {
+      return { level: "imminent", reason: `Memory at ${(memUtil * 100).toFixed(0)}% \u2014 crash likely` };
+    }
+    if (memUtil !== null && memUtil > threshold + 0.15 && isGrowingTrend()) {
+      return { level: "imminent", reason: `Memory at ${(memUtil * 100).toFixed(0)}% with growing trend` };
+    }
+    if (memUtil !== null && memUtil > threshold + 0.05) {
+      if (isGrowingTrend()) {
+        return { level: "critical", reason: `Memory at ${(memUtil * 100).toFixed(0)}% with growing trend` };
+      }
+      if (iframeCount > 5) {
+        return { level: "critical", reason: `Memory at ${(memUtil * 100).toFixed(0)}% with ${iframeCount} iframes` };
+      }
+    }
+    if (memUtil !== null && memUtil > threshold && iframeCount > 3) {
+      return { level: "elevated", reason: `Memory at ${(memUtil * 100).toFixed(0)}% with ${iframeCount} iframes` };
+    }
+    if (memUtil !== null && memUtil > threshold && isGrowingTrend()) {
+      return { level: "elevated", reason: `Memory at ${(memUtil * 100).toFixed(0)}% with growing trend` };
+    }
+    return null;
+  }
+  const LEVEL_SEVERITY = {
+    elevated: 1,
+    critical: 2,
+    imminent: 3
+  };
+  function check() {
+    const memUtil = getMemoryUtilization();
+    if (memUtil !== null) {
+      recentReadings.push({ utilization: memUtil, timestamp: Date.now() });
+      while (recentReadings.length > TREND_WINDOW * 2) {
+        recentReadings.shift();
+      }
+    }
+    const iframeSnap = iframeTracker.getSnapshot();
+    const result = computeLevel(memUtil, iframeSnap.totalCount);
+    if (!result) {
+      lastLevel = null;
+      return;
+    }
+    if (lastLevel === null || LEVEL_SEVERITY[result.level] > LEVEL_SEVERITY[lastLevel]) {
+      lastLevel = result.level;
+      bus.emit("pre_crash_warning", {
+        level: result.level,
+        memoryUtilization: memUtil,
+        iframeCount: iframeSnap.totalCount,
+        reason: result.reason,
+        timestamp: performance.now() + performance.timeOrigin
+      });
+    }
+  }
+  return {
+    start() {
+      if (typeof window === "undefined") return;
+      check();
+      intervalId = setInterval(check, CHECK_INTERVAL);
+    },
+    stop() {
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      lastLevel = null;
+      recentReadings.length = 0;
+    }
+  };
+}
+
+// src/crash-classifier.ts
+function evaluateRuntimeError(event) {
+  const type = event.error.type;
+  const knownTypes = ["TypeError", "ReferenceError", "RangeError", "SyntaxError", "URIError", "EvalError"];
+  if (knownTypes.includes(type)) {
+    return {
+      category: "runtime_error",
+      subcategory: type.toLowerCase(),
+      confidence: 0.95,
+      factors: [{
+        factor: "known_error_type",
+        weight: 0.95,
+        evidence: `Error type: ${type}`
+      }]
+    };
+  }
+  if (event.error.message) {
+    return {
+      category: "runtime_error",
+      subcategory: "custom_error",
+      confidence: 0.7,
+      factors: [{
+        factor: "unhandled_error",
+        weight: 0.7,
+        evidence: `Custom error: ${event.error.message.slice(0, 100)}`
+      }]
+    };
+  }
+  return {
+    category: "runtime_error",
+    subcategory: "unknown",
+    confidence: 0.5,
+    factors: []
+  };
+}
+function evaluateMemoryIssue(event) {
+  const mem = event.system.memory;
+  if (!mem) return { category: "memory_issue", subcategory: "unknown", confidence: 0, factors: [] };
+  const factors = [];
+  let confidence = 0;
+  if (mem.utilizationPercent !== void 0 && mem.utilizationPercent !== null && mem.utilizationPercent > 85) {
+    confidence += 0.35;
+    factors.push({
+      factor: "high_memory_utilization",
+      weight: 0.35,
+      evidence: `Memory utilization: ${mem.utilizationPercent}%`
+    });
+  }
+  if (mem.trend === "growing") {
+    confidence += 0.25;
+    factors.push({
+      factor: "growing_memory_trend",
+      weight: 0.25,
+      evidence: "Memory usage is growing over time"
+    });
+  }
+  if (mem.trend === "spike") {
+    confidence += 0.15;
+    factors.push({
+      factor: "memory_spike",
+      weight: 0.15,
+      evidence: "Memory usage spiked recently"
+    });
+  }
+  const msg = event.error.message.toLowerCase();
+  if (msg.includes("out of memory") || msg.includes("allocation failed") || msg.includes("arraybuffer")) {
+    confidence += 0.25;
+    factors.push({
+      factor: "memory_error_message",
+      weight: 0.25,
+      evidence: `Error message suggests memory issue: ${event.error.message.slice(0, 80)}`
+    });
+  }
+  const subcategory = mem.trend === "growing" ? "memory_leak" : mem.trend === "spike" ? "heap_spike" : (mem.utilizationPercent ?? 0) > 95 ? "heap_overflow" : "memory_pressure";
+  return {
+    category: "memory_issue",
+    subcategory,
+    confidence: Math.min(confidence, 1),
+    factors
+  };
+}
+function evaluateEventLoopBlocking(event) {
+  const cpu = event.system.cpu;
+  if (!cpu) return { category: "event_loop_blocking", subcategory: "unknown", confidence: 0, factors: [] };
+  const factors = [];
+  let confidence = 0;
+  if (cpu.maxLongTaskDuration > 1e3) {
+    confidence += 0.4;
+    factors.push({
+      factor: "critical_blocking",
+      weight: 0.4,
+      evidence: `Max long task: ${Math.round(cpu.maxLongTaskDuration)}ms`
+    });
+  } else if (cpu.maxLongTaskDuration > 200) {
+    confidence += 0.2;
+    factors.push({
+      factor: "long_task_detected",
+      weight: 0.2,
+      evidence: `Max long task: ${Math.round(cpu.maxLongTaskDuration)}ms`
+    });
+  }
+  if (cpu.longTasksLast30s > 10) {
+    confidence += 0.3;
+    factors.push({
+      factor: "frequent_long_tasks",
+      weight: 0.3,
+      evidence: `${cpu.longTasksLast30s} long tasks in last 30s`
+    });
+  }
+  if (cpu.estimatedBlockingTime > 5e3) {
+    confidence += 0.3;
+    factors.push({
+      factor: "high_tbt",
+      weight: 0.3,
+      evidence: `Estimated blocking time: ${Math.round(cpu.estimatedBlockingTime)}ms`
+    });
+  }
+  const subcategory = cpu.maxLongTaskDuration > 5e3 ? "infinite_loop" : cpu.maxLongTaskDuration > 1e3 ? "critical_blocking" : cpu.longTasksLast30s > 10 ? "frequent_blocking" : "long_task";
+  return {
+    category: "event_loop_blocking",
+    subcategory,
+    confidence: Math.min(confidence, 1),
+    factors
+  };
+}
+function evaluateReactFramework(event) {
+  if (event.framework.name !== "react") {
+    return { category: "framework_react", subcategory: "unknown", confidence: 0, factors: [] };
+  }
+  const msg = event.error.message.toLowerCase();
+  const factors = [];
+  let confidence = 0;
+  let subcategory = "component_error";
+  if (msg.includes("hydrat")) {
+    confidence = 0.95;
+    subcategory = "hydration_mismatch";
+    factors.push({
+      factor: "hydration_error",
+      weight: 0.95,
+      evidence: "Error message indicates hydration mismatch"
+    });
+  } else if (msg.includes("maximum update depth") || msg.includes("too many re-renders")) {
+    confidence = 0.95;
+    subcategory = "infinite_rerender";
+    factors.push({
+      factor: "infinite_render_loop",
+      weight: 0.95,
+      evidence: "React detected infinite re-render loop"
+    });
+  } else if (msg.includes("rendered fewer hooks") || msg.includes("rendered more hooks")) {
+    confidence = 0.9;
+    subcategory = "hook_violation";
+    factors.push({
+      factor: "hook_rule_violation",
+      weight: 0.9,
+      evidence: "Hook ordering violation detected"
+    });
+  } else if (event.framework.lifecycleStage) {
+    confidence = 0.85;
+    subcategory = `lifecycle_error_${event.framework.lifecycleStage}`;
+    factors.push({
+      factor: "react_lifecycle_error",
+      weight: 0.85,
+      evidence: `Error during React ${event.framework.lifecycleStage} phase`
+    });
+  } else {
+    confidence = 0.7;
+    factors.push({
+      factor: "react_context",
+      weight: 0.7,
+      evidence: "Error occurred in React application context"
+    });
+  }
+  return {
+    category: "framework_react",
+    subcategory,
+    confidence,
+    factors
+  };
+}
+function evaluateVueFramework(event) {
+  if (event.framework.name !== "vue") {
+    return { category: "framework_vue", subcategory: "unknown", confidence: 0, factors: [] };
+  }
+  const msg = event.error.message.toLowerCase();
+  const factors = [];
+  let confidence = 0;
+  let subcategory = "component_error";
+  if (msg.includes("maximum recursive") || msg.includes("infinite") && msg.includes("computed")) {
+    confidence = 0.95;
+    subcategory = "reactivity_loop";
+    factors.push({
+      factor: "vue_reactivity_loop",
+      weight: 0.95,
+      evidence: "Detected infinite reactivity loop"
+    });
+  } else if (event.framework.lifecycleStage) {
+    confidence = 0.85;
+    subcategory = `lifecycle_error_${event.framework.lifecycleStage}`;
+    factors.push({
+      factor: "vue_lifecycle_error",
+      weight: 0.85,
+      evidence: `Error during Vue ${event.framework.lifecycleStage} phase`
+    });
+  } else {
+    confidence = 0.7;
+    factors.push({
+      factor: "vue_context",
+      weight: 0.7,
+      evidence: "Error occurred in Vue application context"
+    });
+  }
+  return {
+    category: "framework_vue",
+    subcategory,
+    confidence,
+    factors
+  };
+}
+function evaluateNetworkInduced(event) {
+  const network = event.system.network;
+  if (!network) return { category: "network_induced", subcategory: "unknown", confidence: 0, factors: [] };
+  const factors = [];
+  let confidence = 0;
+  if (network.failedRequestsLast60s !== void 0 && network.failedRequestsLast60s > 0) {
+    confidence += 0.3;
+    factors.push({
+      factor: "recent_network_failures",
+      weight: 0.3,
+      evidence: `${network.failedRequestsLast60s} failed requests in last 60s`
+    });
+  }
+  if (network.isOnline === false) {
+    confidence += 0.3;
+    factors.push({
+      factor: "offline",
+      weight: 0.3,
+      evidence: "Device is offline"
+    });
+  }
+  const msg = event.error.message.toLowerCase();
+  if (msg.includes("fetch") || msg.includes("network") || msg.includes("cors") || msg.includes("xhr")) {
+    confidence += 0.3;
+    factors.push({
+      factor: "network_error_message",
+      weight: 0.3,
+      evidence: `Error message suggests network issue: ${event.error.message.slice(0, 80)}`
+    });
+  }
+  const subcategory = network.isOnline === false ? "offline" : msg.includes("cors") ? "cors_block" : msg.includes("timeout") ? "timeout" : (network.failedRequestsLast60s ?? 0) > 0 ? "failed_request" : "network_error";
+  return {
+    category: "network_induced",
+    subcategory,
+    confidence: Math.min(confidence, 1),
+    factors
+  };
+}
+function evaluateIframeOverload(event) {
+  const iframe = event.system.iframe;
+  if (!iframe) return { category: "iframe_overload", subcategory: "unknown", confidence: 0, factors: [] };
+  const factors = [];
+  let confidence = 0;
+  if (iframe.totalCount > 10) {
+    confidence += 0.3;
+    factors.push({
+      factor: "excessive_iframes",
+      weight: 0.3,
+      evidence: `${iframe.totalCount} iframes active`
+    });
+  } else if (iframe.totalCount > 5) {
+    confidence += 0.15;
+    factors.push({
+      factor: "many_iframes",
+      weight: 0.15,
+      evidence: `${iframe.totalCount} iframes active`
+    });
+  }
+  if (iframe.addedLast60s > 5) {
+    confidence += 0.25;
+    factors.push({
+      factor: "rapid_iframe_creation",
+      weight: 0.25,
+      evidence: `${iframe.addedLast60s} iframes added in last 60s`
+    });
+  }
+  if (iframe.crossOriginCount > 3) {
+    confidence += 0.2;
+    factors.push({
+      factor: "cross_origin_iframes",
+      weight: 0.2,
+      evidence: `${iframe.crossOriginCount} cross-origin iframes`
+    });
+  }
+  const mem = event.system.memory;
+  if (mem && mem.trend === "growing" && (mem.utilizationPercent ?? 0) > 70) {
+    confidence += 0.25;
+    factors.push({
+      factor: "iframe_memory_correlation",
+      weight: 0.25,
+      evidence: `Memory growing at ${mem.utilizationPercent}% with ${iframe.totalCount} iframes`
+    });
+  }
+  const subcategory = iframe.addedLast60s > 5 ? "rapid_creation" : iframe.crossOriginCount > 3 ? "cross_origin_overload" : iframe.totalCount > 10 ? "excessive_count" : "iframe_pressure";
+  return {
+    category: "iframe_overload",
+    subcategory,
+    confidence: Math.min(confidence, 1),
+    factors
+  };
+}
+function classifyCrash(event) {
+  const evaluators = [
+    evaluateReactFramework,
+    evaluateVueFramework,
+    evaluateIframeOverload,
+    evaluateMemoryIssue,
+    evaluateEventLoopBlocking,
+    evaluateNetworkInduced,
+    evaluateRuntimeError
+  ];
+  let best = {
+    category: "runtime_error",
+    subcategory: "unknown",
+    confidence: 0.1};
+  const allFactors = [];
+  for (const evaluate of evaluators) {
+    const result = evaluate(event);
+    if (result.confidence > 0.2) {
+      allFactors.push(...result.factors);
+    }
+    if (result.confidence > best.confidence) {
+      best = result;
+    }
+  }
+  return {
+    category: best.category,
+    subcategory: best.subcategory,
+    confidence: best.confidence,
+    contributingFactors: allFactors
+  };
+}
+
+// src/crashsense.ts
+function createCrashSense(userConfig) {
+  const config = resolveConfig(userConfig);
+  const bus = utils.createEventBus();
+  const sessionId = utils.generateId();
+  const rateLimiter = utils.createRateLimiter(config.maxEventsPerMinute);
+  const deviceInfo = utils.collectDeviceInfo();
+  const plugins = [];
+  let userContext = {};
+  let destroyed = false;
+  const errorInterceptor = createErrorInterceptor(bus);
+  const memoryMonitor = createMemoryMonitor(bus);
+  const eventLoopMonitor = createEventLoopMonitor(bus);
+  const networkMonitor = createNetworkMonitor(bus);
+  const breadcrumbTracker = createBreadcrumbTracker(bus);
+  const iframeTracker = createIframeTracker(bus);
+  const preCrashWarning = createPreCrashWarning(bus, config, memoryMonitor, iframeTracker);
+  function buildRawEvent(error, source) {
+    const stack = error.stack ? utils.parseStackTrace(error.stack) : [];
+    return {
+      id: utils.generateId(),
+      timestamp: performance.now() + performance.timeOrigin,
+      sessionId,
+      error: {
+        type: error.constructor.name || error.name || "Error",
+        message: config.piiScrubbing ? utils.scrubPII(error.message) : error.message,
+        stack,
+        raw: config.piiScrubbing ? utils.scrubPII(error.stack || "") : error.stack || ""
+      },
+      system: {
+        memory: memoryMonitor.getSnapshot(),
+        cpu: eventLoopMonitor.getCpuSnapshot(),
+        eventLoop: eventLoopMonitor.getEventLoopSnapshot(),
+        network: networkMonitor.getSnapshot(),
+        iframe: config.enableIframeTracking ? iframeTracker.getSnapshot() : void 0
+      },
+      device: deviceInfo,
+      framework: {},
+      breadcrumbs: breadcrumbTracker.getBreadcrumbs(),
+      meta: {
+        appId: config.appId,
+        environment: config.environment,
+        release: config.release || void 0,
+        userId: userContext.id,
+        tags: { source },
+        sdkVersion: SDK_VERSION
+      }
+    };
+  }
+  function processRawEvent(rawEvent) {
+    if (destroyed) return;
+    if (Math.random() > config.sampleRate) return;
+    if (!rateLimiter.tryAcquire()) return;
+    const classification = classifyCrash(rawEvent);
+    let crashEvent = {
+      id: rawEvent.id,
+      fingerprint: utils.generateFingerprint(
+        rawEvent.error.type,
+        rawEvent.error.message,
+        rawEvent.error.stack
+      ),
+      timestamp: rawEvent.timestamp,
+      sessionId: rawEvent.sessionId,
+      category: classification.category,
+      subcategory: classification.subcategory,
+      severity: classification.confidence > 0.8 ? "critical" : "error",
+      confidence: classification.confidence,
+      error: rawEvent.error,
+      system: {
+        memory: rawEvent.system.memory ?? memoryMonitor.getSnapshot(),
+        cpu: rawEvent.system.cpu ?? eventLoopMonitor.getCpuSnapshot(),
+        eventLoop: rawEvent.system.eventLoop ?? eventLoopMonitor.getEventLoopSnapshot(),
+        network: rawEvent.system.network ?? networkMonitor.getSnapshot(),
+        iframe: rawEvent.system.iframe ?? (config.enableIframeTracking ? iframeTracker.getSnapshot() : void 0)
+      },
+      device: rawEvent.device,
+      framework: {
+        name: rawEvent.framework.name ?? "vanilla",
+        version: rawEvent.framework.version ?? "",
+        adapter: rawEvent.framework.adapter ?? SDK_VERSION,
+        componentTree: rawEvent.framework.componentTree,
+        currentRoute: rawEvent.framework.currentRoute,
+        storeState: rawEvent.framework.storeState,
+        lifecycleStage: rawEvent.framework.lifecycleStage,
+        renderCount: rawEvent.framework.renderCount
+      },
+      breadcrumbs: rawEvent.breadcrumbs,
+      contributingFactors: classification.contributingFactors,
+      meta: rawEvent.meta
+    };
+    for (const plugin of plugins) {
+      if (plugin.onCrashEvent) {
+        const modified = plugin.onCrashEvent(crashEvent);
+        if (modified === null) return;
+        crashEvent = modified;
+      }
+    }
+    const report = {
+      event: crashEvent,
+      analysis: null,
+      timestamp: Date.now()
+    };
+    bus.emit("crash_detected", { event: crashEvent });
+    if (config.onCrash) {
+      try {
+        config.onCrash(report);
+      } catch (_) {
+      }
+    }
+    if (config.debug) {
+      logCrashReport(report);
+    }
+  }
+  function logCrashReport(report) {
+    const e = report.event;
+    const header = `[CrashSense] ${e.category}/${e.subcategory} (confidence: ${(e.confidence * 100).toFixed(0)}%)`;
+    const details = [
+      `Error: ${e.error.type}: ${e.error.message}`,
+      `Device: ${e.device.userAgent.slice(0, 80)}`,
+      `Memory: ${e.system.memory.utilizationPercent ?? "N/A"}% used`,
+      `Long Tasks (30s): ${e.system.cpu.longTasksLast30s}`,
+      `FPS: ${e.system.eventLoop.fps}`
+    ];
+    if (typeof console !== "undefined") {
+      console.groupCollapsed?.(header) ?? console.log(header);
+      for (const d of details) console.log(d);
+      if (e.contributingFactors.length > 0) {
+        console.log("Contributing factors:");
+        for (const f of e.contributingFactors) {
+          console.log(`  - ${f.factor} (${(f.weight * 100).toFixed(0)}%): ${f.evidence}`);
+        }
+      }
+      console.groupEnd?.();
+    }
+  }
+  bus.on("error", (data) => {
+    const rawEvent = buildRawEvent(data.error, "window.onerror");
+    processRawEvent(rawEvent);
+  });
+  bus.on("unhandled_rejection", (data) => {
+    const error = data.reason instanceof Error ? data.reason : new Error(String(data.reason));
+    const rawEvent = buildRawEvent(error, "unhandledrejection");
+    processRawEvent(rawEvent);
+  });
+  bus.on("iframe_added", (data) => {
+    breadcrumbTracker.addBreadcrumb({
+      type: "custom",
+      message: `Iframe added: ${data.origin} (total: ${data.totalCount})`,
+      data: { src: data.src, crossOrigin: data.crossOrigin }
+    });
+  });
+  bus.on("iframe_removed", (data) => {
+    breadcrumbTracker.addBreadcrumb({
+      type: "custom",
+      message: `Iframe removed (total: ${data.totalCount})`,
+      data: { src: data.src }
+    });
+  });
+  bus.on("pre_crash_warning", (data) => {
+    breadcrumbTracker.addBreadcrumb({
+      type: "custom",
+      message: `Pre-crash warning [${data.level}]: ${data.reason}`,
+      data: { level: data.level, memoryUtilization: data.memoryUtilization, iframeCount: data.iframeCount }
+    });
+  });
+  errorInterceptor.install();
+  breadcrumbTracker.install();
+  if (config.enableMemoryMonitoring) memoryMonitor.start();
+  if (config.enableLongTaskMonitoring) eventLoopMonitor.start();
+  if (config.enableNetworkMonitoring) networkMonitor.start();
+  if (config.enableIframeTracking) iframeTracker.start();
+  if (config.enablePreCrashWarning) preCrashWarning.start();
+  const core = {
+    get config() {
+      return config;
+    },
+    get sessionId() {
+      return sessionId;
+    },
+    use(plugin) {
+      plugins.push(plugin);
+      plugin.setup(core);
+    },
+    captureException(error, context) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      const rawEvent = buildRawEvent(err, "manual");
+      if (context) {
+        rawEvent.meta.tags = { ...rawEvent.meta.tags, ...Object.fromEntries(
+          Object.entries(context).map(([k, v]) => [k, String(v)])
+        ) };
+      }
+      processRawEvent(rawEvent);
+    },
+    captureMessage(message, severity = "info") {
+      const rawEvent = buildRawEvent(new Error(message), "message");
+      rawEvent.error.type = "Message";
+      rawEvent.meta.tags.severity = severity;
+      processRawEvent(rawEvent);
+    },
+    addBreadcrumb(bc) {
+      breadcrumbTracker.addBreadcrumb(bc);
+    },
+    setUser(user) {
+      userContext = user;
+    },
+    setContext(key, value) {
+    },
+    getSystemState() {
+      return {
+        memory: memoryMonitor.getSnapshot(),
+        cpu: eventLoopMonitor.getCpuSnapshot(),
+        eventLoop: eventLoopMonitor.getEventLoopSnapshot(),
+        network: networkMonitor.getSnapshot(),
+        iframe: config.enableIframeTracking ? iframeTracker.getSnapshot() : void 0
+      };
+    },
+    getDeviceInfo() {
+      return deviceInfo;
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      errorInterceptor.uninstall();
+      breadcrumbTracker.uninstall();
+      memoryMonitor.stop();
+      eventLoopMonitor.stop();
+      networkMonitor.stop();
+      iframeTracker.stop();
+      preCrashWarning.stop();
+      for (const plugin of plugins) {
+        plugin.teardown();
+      }
+    },
+    _reportRawEvent(event) {
+      processRawEvent(event);
+    },
+    _getEventBus() {
+      return bus;
+    }
+  };
+  return core;
+}
+
+exports.classifyCrash = classifyCrash;
+exports.createCrashSense = createCrashSense;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map