@cross-deck/web 0.10.0 → 1.0.0

package/dist/react.cjs

@@ -93,7 +93,7 @@ function typeMapForStatus(status) {
 
 // src/http.ts
 var SDK_NAME = "@cross-deck/web";
-var SDK_VERSION = "0.10.0";
+var SDK_VERSION = "1.0.0";
 var DEFAULT_BASE_URL = "https://api.cross-deck.com/v1";
 var DEFAULT_TIMEOUT_MS = 15e3;
 var HttpClient = class {
@@ -917,7 +917,8 @@ var DEFAULT_AUTO_TRACK = {
   pageViews: true,
   deviceInfo: true,
   clicks: true,
-  webVitals: true
+  webVitals: true,
+  errors: true
 };
 var SESSION_RESUME_THRESHOLD_MS = 30 * 60 * 1e3;
 var EMPTY_ACQUISITION = {
@@ -1818,6 +1819,541 @@ function scrubPiiFromProperties(properties) {
   return out;
 }
 
+// src/breadcrumbs.ts
+var BreadcrumbBuffer = class {
+  constructor(maxSize = 50) {
+    this.maxSize = maxSize;
+    this.items = [];
+  }
+  add(crumb) {
+    this.items.push(crumb);
+    if (this.items.length > this.maxSize) {
+      this.items.shift();
+    }
+  }
+  /** Defensive copy — caller can read freely without mutating buffer state. */
+  snapshot() {
+    return this.items.slice();
+  }
+  clear() {
+    this.items = [];
+  }
+  get size() {
+    return this.items.length;
+  }
+};
+
+// src/stack-parser.ts
+function parseStack(stack) {
+  if (!stack || typeof stack !== "string") return [];
+  const lines = stack.split("\n");
+  const frames = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const frame = parseLine(trimmed);
+    if (frame) frames.push(frame);
+  }
+  return frames;
+}
+function parseLine(line) {
+  let m = /^at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)$/.exec(line);
+  if (m) {
+    return buildFrame({
+      function: m[1],
+      filename: m[2],
+      lineno: parseInt(m[3], 10),
+      colno: parseInt(m[4], 10),
+      raw: line
+    });
+  }
+  m = /^at\s+(.+?):(\d+):(\d+)$/.exec(line);
+  if (m) {
+    return buildFrame({
+      function: "?",
+      filename: m[1],
+      lineno: parseInt(m[2], 10),
+      colno: parseInt(m[3], 10),
+      raw: line
+    });
+  }
+  m = /^(.*?)@(.+?):(\d+):(\d+)$/.exec(line);
+  if (m) {
+    return buildFrame({
+      function: m[1] || "?",
+      filename: m[2],
+      lineno: parseInt(m[3], 10),
+      colno: parseInt(m[4], 10),
+      raw: line
+    });
+  }
+  if (/^\w*Error/.test(line) || !line.includes(":")) {
+    return null;
+  }
+  return {
+    function: "?",
+    filename: "",
+    lineno: 0,
+    colno: 0,
+    in_app: true,
+    raw: line
+  };
+}
+function buildFrame(input) {
+  return {
+    function: input.function || "?",
+    filename: input.filename,
+    lineno: Number.isFinite(input.lineno) ? input.lineno : 0,
+    colno: Number.isFinite(input.colno) ? input.colno : 0,
+    in_app: isInAppFrame(input.filename),
+    raw: input.raw
+  };
+}
+function isInAppFrame(filename) {
+  if (!filename) return true;
+  if (/^(?:chrome|moz|safari|webkit)-extension:\/\//.test(filename)) return false;
+  if (/\bcdn\.jsdelivr\.net\b/.test(filename)) return false;
+  if (/\bunpkg\.com\b/.test(filename)) return false;
+  if (/\bgoogletagmanager\.com\b/.test(filename)) return false;
+  if (/\bgoogle-analytics\.com\b/.test(filename)) return false;
+  if (/\b@cross-deck\/web\b/.test(filename)) return false;
+  if (/\/crossdeck\.umd\.min\.js$/.test(filename)) return false;
+  return true;
+}
+function fingerprintError(message, frames) {
+  const inAppFrames = frames.filter((f) => f.in_app).slice(0, 3);
+  const key = [
+    (message || "").slice(0, 200),
+    ...inAppFrames.map((f) => `${f.function}@${f.filename}:${f.lineno}`)
+  ].join("|");
+  return djb2Hex(key);
+}
+function djb2Hex(input) {
+  let h = 5381;
+  for (let i = 0; i < input.length; i++) {
+    h = (h << 5) + h + input.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/error-capture.ts
+var DEFAULT_ERROR_CAPTURE = {
+  enabled: true,
+  onError: true,
+  onUnhandledRejection: true,
+  wrapFetch: true,
+  wrapXhr: true,
+  captureConsole: false,
+  ignoreErrors: [
+    // Classic browser noise. These aren't application bugs.
+    "ResizeObserver loop limit exceeded",
+    "ResizeObserver loop completed with undelivered notifications",
+    "Non-Error promise rejection captured",
+    // Cross-origin script errors that the browser strips — no info,
+    // no way to act on them, just noise.
+    "Script error.",
+    "Script error"
+  ],
+  allowUrls: [],
+  denyUrls: [
+    // Common third-party extensions that pollute error streams.
+    /^chrome-extension:\/\//,
+    /^moz-extension:\/\//,
+    /^safari-extension:\/\//,
+    /^webkit-extension:\/\//,
+    /^safari-web-extension:\/\//
+  ],
+  sampleRate: 1,
+  maxPerFingerprintPerMinute: 5,
+  maxPerSession: 100
+};
+var ErrorTracker = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.installed = false;
+    this.cleanups = [];
+    this._reporting = false;
+    this.sessionCount = 0;
+    this.fingerprintWindow = /* @__PURE__ */ new Map();
+  }
+  install() {
+    if (this.installed) return;
+    if (!this.opts.config.enabled) return;
+    if (typeof globalThis === "undefined" || !("window" in globalThis)) return;
+    const w = globalThis.window;
+    if (this.opts.config.onError) this.installOnErrorListener(w);
+    if (this.opts.config.onUnhandledRejection) this.installRejectionListener(w);
+    if (this.opts.config.wrapFetch) this.installFetchWrap(w);
+    if (this.opts.config.wrapXhr) this.installXhrWrap(w);
+    if (this.opts.config.captureConsole) this.installConsoleWrap();
+    this.installed = true;
+  }
+  uninstall() {
+    for (const fn of this.cleanups.splice(0)) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this.installed = false;
+  }
+  /**
+   * Manual API. Either an Error instance or any unknown value (we
+   * coerce). Returns silently — never throws.
+   */
+  captureError(error, options) {
+    if (!this.opts.isConsented()) return;
+    try {
+      const captured = this.buildFromUnknown(error, "error.handled", options?.level ?? "error");
+      if (options?.context) captured.context = { ...captured.context, ...options.context };
+      if (options?.tags) captured.tags = { ...captured.tags, ...options.tags };
+      this.maybeReport(captured);
+    } catch {
+    }
+  }
+  /**
+   * Capture a non-error event as an issue. For "we hit a soft-warning
+   * code path" / "deprecated API used" kinds of signals. Pairs with
+   * Sentry's captureMessage().
+   */
+  captureMessage(message, level = "info") {
+    if (!this.opts.isConsented()) return;
+    try {
+      const captured = {
+        timestamp: Date.now(),
+        kind: "error.message",
+        level,
+        message,
+        errorType: null,
+        frames: [],
+        rawStack: null,
+        filename: null,
+        lineno: null,
+        colno: null,
+        fingerprint: fingerprintError(message, []),
+        breadcrumbs: this.opts.breadcrumbs.snapshot(),
+        context: this.opts.getContext(),
+        tags: this.opts.getTags()
+      };
+      this.maybeReport(captured);
+    } catch {
+    }
+  }
+  // ============================================================
+  // Listener installation
+  // ============================================================
+  installOnErrorListener(w) {
+    const handler = (event) => {
+      if (this._reporting) return;
+      if (!this.opts.isConsented()) return;
+      try {
+        this._reporting = true;
+        const captured = this.buildFromErrorEvent(event);
+        this.maybeReport(captured);
+      } catch {
+      } finally {
+        this._reporting = false;
+      }
+    };
+    w.addEventListener("error", handler, true);
+    this.cleanups.push(() => w.removeEventListener("error", handler, true));
+  }
+  installRejectionListener(w) {
+    const handler = (event) => {
+      if (this._reporting) return;
+      if (!this.opts.isConsented()) return;
+      try {
+        this._reporting = true;
+        const captured = this.buildFromUnknown(
+          event.reason,
+          "error.unhandledrejection",
+          "error"
+        );
+        this.maybeReport(captured);
+      } catch {
+      } finally {
+        this._reporting = false;
+      }
+    };
+    w.addEventListener("unhandledrejection", handler);
+    this.cleanups.push(() => w.removeEventListener("unhandledrejection", handler));
+  }
+  /**
+   * Wrap fetch() so failed HTTP requests get auto-captured. We do NOT
+   * call this an "error" for 4xx (those are often expected — auth
+   * required, validation failed). Only 5xx + network failures fire.
+   */
+  installFetchWrap(w) {
+    const origFetch = w.fetch?.bind(w);
+    if (!origFetch) return;
+    const wrapped = async (...args) => {
+      const input = args[0];
+      const init = args[1] ?? {};
+      const url = typeof input === "string" ? input : input?.url ?? "";
+      const method = (init.method || "GET").toUpperCase();
+      const start = Date.now();
+      this.opts.breadcrumbs.add({
+        timestamp: start,
+        category: "http",
+        message: `${method} ${url}`,
+        data: { url, method }
+      });
+      try {
+        const response = await origFetch(...args);
+        if (response.status >= 500 && this.opts.isConsented()) {
+          if (!url.includes("api.cross-deck.com")) {
+            this.captureHttp({
+              url,
+              method,
+              status: response.status,
+              statusText: response.statusText
+            });
+          }
+        }
+        return response;
+      } catch (err) {
+        if (this.opts.isConsented() && !url.includes("api.cross-deck.com")) {
+          this.captureHttp({
+            url,
+            method,
+            status: 0,
+            statusText: err instanceof Error ? err.message : "network error"
+          });
+        }
+        throw err;
+      }
+    };
+    w.fetch = wrapped;
+    this.cleanups.push(() => {
+      if (w.fetch === wrapped) w.fetch = origFetch;
+    });
+  }
+  /**
+   * Wrap XMLHttpRequest for legacy consumers (jQuery $.ajax under the
+   * hood, older bundlers). Same capture semantics as fetch.
+   */
+  installXhrWrap(w) {
+    const xhrCtor = w.XMLHttpRequest;
+    const proto = xhrCtor?.prototype;
+    if (!proto) return;
+    const origOpen = proto.open;
+    const origSend = proto.send;
+    const tracker = this;
+    proto.open = function(method, url, ...rest) {
+      this._cdMethod = method;
+      this._cdUrl = url;
+      return origOpen.apply(this, [method, url, ...rest]);
+    };
+    proto.send = function(body) {
+      const xhr = this;
+      const onLoad = () => {
+        try {
+          if (xhr.status >= 500 && tracker.opts.isConsented()) {
+            const url = xhr._cdUrl ?? "";
+            if (!url.includes("api.cross-deck.com")) {
+              tracker.captureHttp({
+                url,
+                method: (xhr._cdMethod ?? "GET").toUpperCase(),
+                status: xhr.status,
+                statusText: xhr.statusText
+              });
+            }
+          }
+        } catch {
+        }
+      };
+      xhr.addEventListener("loadend", onLoad);
+      return origSend.apply(this, [body ?? null]);
+    };
+    this.cleanups.push(() => {
+      proto.open = origOpen;
+      proto.send = origSend;
+    });
+  }
+  installConsoleWrap() {
+    const console2 = globalThis.console;
+    if (!console2) return;
+    const orig = console2.error.bind(console2);
+    console2.error = (...args) => {
+      try {
+        if (this.opts.isConsented()) {
+          this.captureMessage(args.map((a) => safeStringify2(a)).join(" "), "error");
+        }
+      } catch {
+      }
+      return orig(...args);
+    };
+    this.cleanups.push(() => {
+      console2.error = orig;
+    });
+  }
+  // ============================================================
+  // Builders
+  // ============================================================
+  buildFromErrorEvent(event) {
+    const err = event.error;
+    const message = event.message || (err instanceof Error ? err.message : "Unknown error");
+    const stack = err instanceof Error ? err.stack ?? null : null;
+    const frames = parseStack(stack);
+    return {
+      timestamp: Date.now(),
+      kind: "error.unhandled",
+      level: "error",
+      message: String(message).slice(0, 1024),
+      errorType: err instanceof Error ? err.name : null,
+      frames,
+      rawStack: stack,
+      filename: event.filename || null,
+      lineno: typeof event.lineno === "number" ? event.lineno : null,
+      colno: typeof event.colno === "number" ? event.colno : null,
+      fingerprint: fingerprintError(message, frames),
+      breadcrumbs: this.opts.breadcrumbs.snapshot(),
+      context: this.opts.getContext(),
+      tags: this.opts.getTags()
+    };
+  }
+  buildFromUnknown(err, kind, level) {
+    if (err instanceof Error) {
+      const frames = parseStack(err.stack);
+      return {
+        timestamp: Date.now(),
+        kind,
+        level,
+        message: String(err.message).slice(0, 1024),
+        errorType: err.name,
+        frames,
+        rawStack: err.stack ?? null,
+        filename: null,
+        lineno: null,
+        colno: null,
+        fingerprint: fingerprintError(err.message, frames),
+        breadcrumbs: this.opts.breadcrumbs.snapshot(),
+        context: this.opts.getContext(),
+        tags: this.opts.getTags()
+      };
+    }
+    const message = safeStringify2(err).slice(0, 1024);
+    return {
+      timestamp: Date.now(),
+      kind,
+      level,
+      message,
+      errorType: null,
+      frames: [],
+      rawStack: null,
+      filename: null,
+      lineno: null,
+      colno: null,
+      fingerprint: fingerprintError(message, []),
+      breadcrumbs: this.opts.breadcrumbs.snapshot(),
+      context: this.opts.getContext(),
+      tags: this.opts.getTags()
+    };
+  }
+  captureHttp(info) {
+    try {
+      const message = `HTTP ${info.status} ${info.method} ${info.url}`;
+      const captured = {
+        timestamp: Date.now(),
+        kind: "error.http",
+        level: "error",
+        message,
+        errorType: `HTTPError`,
+        frames: [],
+        rawStack: null,
+        filename: info.url,
+        lineno: null,
+        colno: null,
+        fingerprint: fingerprintError(`HTTP ${info.status} ${info.method}`, []),
+        breadcrumbs: this.opts.breadcrumbs.snapshot(),
+        context: this.opts.getContext(),
+        tags: this.opts.getTags(),
+        http: info
+      };
+      this.maybeReport(captured);
+    } catch {
+    }
+  }
+  // ============================================================
+  // Reporting pipeline — filter / sample / rate-limit / send
+  // ============================================================
+  maybeReport(err) {
+    if (this.sessionCount >= this.opts.config.maxPerSession) return;
+    if (this.shouldIgnore(err)) return;
+    if (!this.passesUrlGate(err)) return;
+    if (!this.passesSample(err)) return;
+    if (!this.passesRateLimit(err)) return;
+    let finalErr = err;
+    if (this.opts.beforeSend) {
+      try {
+        finalErr = this.opts.beforeSend(err);
+      } catch {
+        finalErr = err;
+      }
+      if (!finalErr) return;
+    }
+    this.sessionCount += 1;
+    try {
+      this.opts.report(finalErr);
+    } catch {
+    }
+  }
+  shouldIgnore(err) {
+    for (const pat of this.opts.config.ignoreErrors) {
+      if (typeof pat === "string" && err.message.includes(pat)) return true;
+      if (pat instanceof RegExp && pat.test(err.message)) return true;
+    }
+    return false;
+  }
+  passesUrlGate(err) {
+    const topFrame = err.frames.find((f) => f.filename) ?? null;
+    const url = topFrame?.filename ?? err.filename ?? "";
+    if (!url) return true;
+    for (const pat of this.opts.config.denyUrls) {
+      if (typeof pat === "string" && url.includes(pat)) return false;
+      if (pat instanceof RegExp && pat.test(url)) return false;
+    }
+    if (this.opts.config.allowUrls.length > 0) {
+      for (const pat of this.opts.config.allowUrls) {
+        if (typeof pat === "string" && url.includes(pat)) return true;
+        if (pat instanceof RegExp && pat.test(url)) return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  passesSample(err) {
+    if (this.opts.config.sampleRate >= 1) return true;
+    if (this.opts.config.sampleRate <= 0) return false;
+    const hashByte = parseInt(err.fingerprint.slice(0, 2), 16);
+    return hashByte / 255 < this.opts.config.sampleRate;
+  }
+  passesRateLimit(err) {
+    const windowMs = 6e4;
+    const now = Date.now();
+    const max = this.opts.config.maxPerFingerprintPerMinute;
+    const arr = this.fingerprintWindow.get(err.fingerprint) ?? [];
+    const fresh = arr.filter((t) => now - t < windowMs);
+    if (fresh.length >= max) {
+      this.fingerprintWindow.set(err.fingerprint, fresh);
+      return false;
+    }
+    fresh.push(now);
+    this.fingerprintWindow.set(err.fingerprint, fresh);
+    return true;
+  }
+};
+function safeStringify2(v) {
+  if (v == null) return String(v);
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return Object.prototype.toString.call(v);
+  }
+}
+
 // src/crossdeck.ts
 var CrossdeckClient = class {
   constructor() {
@@ -1951,6 +2487,7 @@ var CrossdeckClient = class {
         "Do Not Track detected \u2014 all tracking dimensions denied at init."
       );
     }
+    const breadcrumbs = new BreadcrumbBuffer(50);
     this.state = {
       http,
       identity,
@@ -1958,6 +2495,11 @@ var CrossdeckClient = class {
       events,
       autoTracker: null,
       webVitals: null,
+      errors: null,
+      breadcrumbs,
+      errorContext: {},
+      errorTags: {},
+      errorBeforeSend: null,
       superProps,
       consent,
       scrubPii: options.scrubPii !== false,
@@ -1990,6 +2532,19 @@ var CrossdeckClient = class {
       this.state.webVitals = vitals;
       vitals.install();
     }
+    if (autoTrack.errors) {
+      const tracker = new ErrorTracker({
+        config: { ...DEFAULT_ERROR_CAPTURE, enabled: true },
+        breadcrumbs,
+        report: (err) => this.reportError(err),
+        getContext: () => ({ ...this.state.errorContext }),
+        getTags: () => ({ ...this.state.errorTags }),
+        beforeSend: this.state.errorBeforeSend,
+        isConsented: () => this.state.consent.errors
+      });
+      this.state.errors = tracker;
+      tracker.install();
+    }
     this.state.uninstallUnloadFlush = installUnloadFlush(() => {
       void this.flush({ keepalive: true }).catch(() => void 0);
     });
@@ -2157,6 +2712,108 @@ var CrossdeckClient = class {
     }
     return this.state.consent.get();
   }
+  // ============================================================
+  // Error capture surface (v1.0.0+)
+  // ============================================================
+  /**
+   * Manually capture an error from a try/catch block.
+   *
+   *   try { …risky… } catch (err) {
+   *     Crossdeck.captureError(err, { context: { plan: "pro" } });
+   *   }
+   *
+   * The error is shipped through the same event queue as analytics
+   * (durable, retried, rate-limited per fingerprint). Sends are gated
+   * by `consent.errors`. Returns silently — never throws, even if the
+   * SDK isn't initialised yet.
+   */
+  captureError(error, options) {
+    if (!this.state?.errors) return;
+    this.state.errors.captureError(error, options);
+  }
+  /**
+   * Capture a non-error event you want to surface as an issue
+   * ("deprecated path hit", "we entered the slow code path"). Sentry
+   * captureMessage pattern. Returns silently if not initialised.
+   */
+  captureMessage(message, level = "info") {
+    if (!this.state?.errors) return;
+    this.state.errors.captureMessage(message, level);
+  }
+  /**
+   * Attach a tag to every subsequent error report. Tags are key/value
+   * strings (Sentry pattern): `setTag("flow", "checkout")` → every
+   * error from this point on carries `tags.flow === "checkout"`.
+   */
+  setTag(key, value) {
+    if (!this.state) return;
+    this.state.errorTags[key] = value;
+  }
+  /** Bulk-set tags. Merges with existing tags. */
+  setTags(tags) {
+    if (!this.state) return;
+    Object.assign(this.state.errorTags, tags);
+  }
+  /**
+   * Attach a structured context blob to every subsequent error report.
+   * Unlike tags (flat key/value), context is a named bag of arbitrary
+   * data: `setContext("cart", { items: 3, total: 42.99 })`.
+   */
+  setContext(name, data) {
+    if (!this.state) return;
+    this.state.errorContext[name] = data;
+  }
+  /**
+   * Add a custom breadcrumb to the rolling buffer. Useful for marking
+   * domain-meaningful moments ("user opened paywall") that aren't
+   * already auto-captured. The buffer caps at 50 entries; old ones
+   * evict.
+   */
+  addBreadcrumb(crumb) {
+    if (!this.state) return;
+    this.state.breadcrumbs.add(crumb);
+  }
+  /**
+   * Install a pre-send hook for errors. Return null to drop, or a
+   * modified CapturedError to scrub / rewrite. Sentry's beforeSend
+   * pattern — the only way to redact app-specific PII (auth tokens
+   * in URLs, etc.) before the report leaves the browser.
+   */
+  setErrorBeforeSend(hook) {
+    if (!this.state) return;
+    this.state.errorBeforeSend = hook;
+  }
+  /**
+   * Internal: turn a CapturedError into a Crossdeck event and enqueue
+   * it. Goes through the same queue / persistence / consent / scrub
+   * pipeline as analytics events.
+   */
+  reportError(err) {
+    const properties = {
+      // Identifiers
+      fingerprint: err.fingerprint,
+      level: err.level,
+      // Error shape
+      errorType: err.errorType,
+      message: err.message,
+      // Stack
+      stack: err.rawStack ?? void 0,
+      frames: err.frames,
+      filename: err.filename ?? void 0,
+      lineno: err.lineno ?? void 0,
+      colno: err.colno ?? void 0,
+      // Context
+      tags: err.tags,
+      context: err.context,
+      breadcrumbs: err.breadcrumbs,
+      // HTTP (only when applicable)
+      http: err.http
+    };
+    for (const k of Object.keys(properties)) {
+      if (properties[k] === void 0) delete properties[k];
+    }
+    this.track(err.kind, properties);
+  }
   /**
    * GDPR/CCPA "right to be forgotten" — calls the backend's
    * /v1/identity/forget endpoint to schedule a server-side deletion of
@@ -2268,8 +2925,9 @@ var CrossdeckClient = class {
         message: "track(name) requires a non-empty name."
       });
     }
+    const isError = name.startsWith("error.");
     const isWebVital = name.startsWith("webvitals.");
-    const consentGateOk = isWebVital ? s.consent.errors : s.consent.analytics;
+    const consentGateOk = isError || isWebVital ? s.consent.errors : s.consent.analytics;
     if (!consentGateOk) {
       if (s.debug.enabled) {
         s.debug.emit(
@@ -2345,6 +3003,18 @@ var CrossdeckClient = class {
     };
     Object.assign(event, this.identityHintForEvent());
     s.events.enqueue(event);
+    if (!isError && !isWebVital) {
+      const category = name.startsWith("page.") ? "navigation" : name.startsWith("element.") || name === "session.started" ? "ui.click" : "custom";
+      s.breadcrumbs.add({
+        timestamp: event.timestamp,
+        category,
+        message: name,
+        // Strip the device-info / session bloat from the breadcrumb
+        // payload — only the caller-supplied properties belong in
+        // the user-readable trail.
+        data: properties ? { ...properties } : void 0
+      });
+    }
   }
   /**
    * Force-flush queued events. Useful to call from page-unload handlers.
@@ -2444,6 +3114,9 @@ var CrossdeckClient = class {
     this.state.entitlements.clear();
     this.state.events.reset();
     this.state.superProps.clear();
+    this.state.breadcrumbs.clear();
+    this.state.errorContext = {};
+    this.state.errorTags = {};
     this.state.developerUserId = null;
     if (this.state.autoTracker) {
       const tracker = new AutoTracker(
@@ -2586,7 +3259,8 @@ function resolveAutoTrack(input) {
       pageViews: false,
       deviceInfo: false,
       clicks: false,
-      webVitals: false
+      webVitals: false,
+      errors: false
     };
   }
   if (input === void 0 || input === true) {
@@ -2597,7 +3271,8 @@ function resolveAutoTrack(input) {
     pageViews: input.pageViews ?? DEFAULT_AUTO_TRACK.pageViews,
     deviceInfo: input.deviceInfo ?? DEFAULT_AUTO_TRACK.deviceInfo,
     clicks: input.clicks ?? DEFAULT_AUTO_TRACK.clicks,
-    webVitals: input.webVitals ?? DEFAULT_AUTO_TRACK.webVitals
+    webVitals: input.webVitals ?? DEFAULT_AUTO_TRACK.webVitals,
+    errors: input.errors ?? DEFAULT_AUTO_TRACK.errors
   };
 }
 function installUnloadFlush(onUnload) {