@bbearai/core 0.5.4 → 0.7.0

package/dist/index.js

@@ -22,13 +22,24 @@ var index_exports = {};
 __export(index_exports, {
   BUG_CATEGORIES: () => BUG_CATEGORIES,
   BugBearClient: () => BugBearClient,
+  DedupWindow: () => DedupWindow,
+  ErrorMonitor: () => ErrorMonitor,
   LocalStorageAdapter: () => LocalStorageAdapter,
   OfflineQueue: () => OfflineQueue,
+  RNApiFailureHandler: () => RNApiFailureHandler,
+  RNCrashHandler: () => RNCrashHandler,
+  RNRageClickHandler: () => RNRageClickHandler,
+  RageClickDetector: () => RageClickDetector,
+  WebApiFailureHandler: () => WebApiFailureHandler,
+  WebCrashHandler: () => WebCrashHandler,
+  WebRageClickHandler: () => WebRageClickHandler,
   captureError: () => captureError,
   contextCapture: () => contextCapture,
   createBugBear: () => createBugBear,
+  generateFingerprint: () => generateFingerprint,
   isBugCategory: () => isBugCategory,
-  isNetworkError: () => isNetworkError
+  isNetworkError: () => isNetworkError,
+  scrubUrl: () => scrubUrl
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -52,6 +63,7 @@ var ContextCaptureManager = class {
     this.networkRequests = [];
     this.navigationHistory = [];
     this.originalConsole = {};
+    this.fetchHost = null;
     this.isCapturing = false;
   }
   /**
@@ -74,8 +86,9 @@ var ContextCaptureManager = class {
     if (this.originalConsole.warn) console.warn = this.originalConsole.warn;
     if (this.originalConsole.error) console.error = this.originalConsole.error;
     if (this.originalConsole.info) console.info = this.originalConsole.info;
-    if (this.originalFetch && typeof window !== "undefined") {
-      window.fetch = this.originalFetch;
+    if (this.originalFetch && this.fetchHost) {
+      this.fetchHost.fetch = this.originalFetch;
+      this.fetchHost = null;
     }
     if (typeof window !== "undefined" && typeof history !== "undefined") {
       if (this.originalPushState) {
@@ -184,15 +197,19 @@ var ContextCaptureManager = class {
     });
   }
   captureFetch() {
-    if (typeof window === "undefined" || typeof fetch === "undefined" || typeof document === "undefined") return;
-    this.originalFetch = window.fetch;
+    if (typeof fetch === "undefined") return;
+    const host = typeof window !== "undefined" && typeof window.fetch === "function" ? window : typeof globalThis !== "undefined" && typeof globalThis.fetch === "function" ? globalThis : null;
+    if (!host) return;
+    const canCloneResponse = typeof document !== "undefined";
+    this.fetchHost = host;
+    this.originalFetch = host.fetch;
     const self = this;
-    window.fetch = async function(input, init) {
+    host.fetch = async function(input, init) {
       const startTime = Date.now();
       const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
       const method = init?.method || "GET";
       try {
-        const response = await self.originalFetch.call(window, input, init);
+        const response = await self.originalFetch.call(host, input, init);
         const requestEntry = {
           method,
           url: url.slice(0, 200),
@@ -201,7 +218,7 @@ var ContextCaptureManager = class {
           duration: Date.now() - startTime,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        if (response.status >= 400) {
+        if (canCloneResponse && response.status >= 400) {
           try {
             const cloned = response.clone();
             const body = await cloned.text();
@@ -443,12 +460,442 @@ function isNetworkError(error) {
   msg.includes("the internet connection appears to be offline") || msg.includes("a]server with the specified hostname could not be found");
 }
 
+// src/monitoring/fingerprint.ts
+function generateFingerprint(source, message, route) {
+  const input = `${source}|${message}|${route}`;
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + input.charCodeAt(i) & 4294967295;
+  }
+  return `bb_${(hash >>> 0).toString(36)}`;
+}
+var DedupWindow = class {
+  constructor(windowMs) {
+    this.windowMs = windowMs;
+    this.seen = /* @__PURE__ */ new Map();
+  }
+  /** Returns true if this fingerprint should be reported (not a recent duplicate). */
+  shouldReport(fingerprint) {
+    const now = Date.now();
+    const lastSeen = this.seen.get(fingerprint);
+    if (lastSeen !== void 0 && now - lastSeen < this.windowMs) {
+      return false;
+    }
+    this.seen.set(fingerprint, now);
+    this.cleanup(now);
+    return true;
+  }
+  /** Remove expired entries to prevent memory leaks in long sessions. */
+  cleanup(now) {
+    if (this.seen.size > 100) {
+      for (const [fp, ts] of this.seen) {
+        if (now - ts >= this.windowMs) {
+          this.seen.delete(fp);
+        }
+      }
+    }
+  }
+};
+
+// src/monitoring/scrub.ts
+var SENSITIVE_PARAMS = /^(token|key|password|secret|auth|credential|api_key|access_token|secret_key|apikey|session)$/i;
+function scrubUrl(url) {
+  try {
+    const parsed = new URL(url);
+    let changed = false;
+    for (const [key] of parsed.searchParams) {
+      if (SENSITIVE_PARAMS.test(key)) {
+        parsed.searchParams.set(key, "[REDACTED]");
+        changed = true;
+      }
+    }
+    return changed ? parsed.toString() : url;
+  } catch {
+    return url;
+  }
+}
+
+// src/monitoring/error-monitor.ts
+var SOURCE_TO_REPORT_SOURCE = {
+  crash: "auto_crash",
+  api_failure: "auto_api",
+  rage_click: "auto_rage_click"
+};
+var SEVERITY_ORDER = ["low", "medium", "high", "critical"];
+var ErrorMonitor = class {
+  constructor(config, deps) {
+    this.deps = deps;
+    this.sessionReportCount = 0;
+    this.pendingSentryData = null;
+    this.config = {
+      sampleRate: 1,
+      maxReportsPerSession: 10,
+      dedupWindowMs: 3e5,
+      severityThreshold: "low",
+      scrubUrls: true,
+      ...config
+    };
+    this.dedup = new DedupWindow(this.config.dedupWindowMs);
+  }
+  async handleEvent(event) {
+    if (!this.dedup.shouldReport(event.fingerprint)) return;
+    if (Math.random() >= this.config.sampleRate) return;
+    if (this.sessionReportCount >= this.config.maxReportsPerSession) return;
+    const severity = this.getSeverity(event);
+    if (SEVERITY_ORDER.indexOf(severity) < SEVERITY_ORDER.indexOf(this.config.severityThreshold)) return;
+    if (this.config.beforeCapture && !this.config.beforeCapture(event)) return;
+    const scrubbedUrl = this.config.scrubUrls && event.requestUrl ? scrubUrl(event.requestUrl) : event.requestUrl;
+    if (this.pendingSentryData) {
+      event.sentryEventId = this.pendingSentryData.sentryEventId;
+      event.sentryBreadcrumbs = this.pendingSentryData.sentryBreadcrumbs;
+      this.pendingSentryData = null;
+    }
+    this.sessionReportCount++;
+    await this.deps.submitReport({
+      type: "bug",
+      reportSource: SOURCE_TO_REPORT_SOURCE[event.source],
+      title: this.generateTitle(event),
+      description: event.message,
+      severity,
+      category: event.source === "crash" ? "crash" : "functional",
+      appContext: {
+        currentRoute: event.route,
+        errorMessage: event.error?.message,
+        errorStack: event.error?.stack,
+        custom: {
+          monitoringSource: event.source,
+          fingerprint: event.fingerprint,
+          ...event.statusCode ? { statusCode: event.statusCode } : {},
+          ...scrubbedUrl ? { requestUrl: scrubbedUrl } : {},
+          ...event.requestMethod ? { requestMethod: event.requestMethod } : {},
+          ...event.clickCount ? { clickCount: event.clickCount } : {},
+          ...event.targetSelector ? { targetSelector: event.targetSelector } : {},
+          ...event.sentryEventId ? { sentryEventId: event.sentryEventId } : {}
+        }
+      },
+      enhancedContext: this.deps.getEnhancedContext(),
+      deviceInfo: this.deps.getDeviceInfo()
+    });
+  }
+  enrichWithSentry(data) {
+    this.pendingSentryData = data;
+  }
+  getSeverity(event) {
+    if (event.source === "crash") return "critical";
+    if (event.source === "api_failure") return event.statusCode && event.statusCode >= 500 ? "high" : "medium";
+    return "medium";
+  }
+  generateTitle(event) {
+    switch (event.source) {
+      case "crash":
+        return `[Auto] Crash on ${event.route}: ${event.message.slice(0, 80)}`;
+      case "api_failure":
+        return `[Auto] ${event.requestMethod || "API"} ${event.statusCode || "error"} on ${event.route}`;
+      case "rage_click":
+        return `[Auto] Rage click on ${event.route} (${event.targetSelector || "unknown"})`;
+    }
+  }
+  destroy() {
+    this.sessionReportCount = 0;
+    this.pendingSentryData = null;
+  }
+};
+
+// src/monitoring/rage-click-detector.ts
+var RageClickDetector = class {
+  constructor(onRageClick) {
+    this.onRageClick = onRageClick;
+    this.clicks = [];
+    this.threshold = 3;
+    this.windowMs = 2e3;
+    this.destroyed = false;
+  }
+  recordClick(x, y, targetSelector) {
+    if (this.destroyed) return;
+    const now = Date.now();
+    this.clicks = this.clicks.filter((c) => now - c.time < this.windowMs);
+    this.clicks.push({ time: now, target: targetSelector, x, y });
+    const sameTarget = this.clicks.filter((c) => c.target === targetSelector);
+    if (sameTarget.length >= this.threshold) {
+      this.onRageClick({
+        clickCount: sameTarget.length,
+        targetSelector,
+        x,
+        y
+      });
+      this.clicks = [];
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    this.clicks = [];
+  }
+};
+
+// src/monitoring/web-handlers.ts
+function getSelector(el) {
+  if (el.id) return `#${el.id}`;
+  const tag = el.tagName.toLowerCase();
+  const classes = Array.from(el.classList).slice(0, 2);
+  return classes.length > 0 ? `${tag}.${classes.join(".")}` : tag;
+}
+function currentRoute() {
+  try {
+    return typeof window !== "undefined" && window.location ? window.location.pathname : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var WebCrashHandler = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+    this.prevOnError = null;
+    this.rejectionHandler = null;
+  }
+  start() {
+    this.prevOnError = window.onerror;
+    window.onerror = (message, source, lineno, colno, error) => {
+      const msg = typeof message === "string" ? message : "Unknown error";
+      const route = currentRoute();
+      this.onEvent({
+        source: "crash",
+        fingerprint: generateFingerprint("crash", msg, route),
+        message: msg,
+        route,
+        timestamp: Date.now(),
+        error: error ?? new Error(msg)
+      });
+      if (typeof this.prevOnError === "function") {
+        return this.prevOnError(message, source, lineno, colno, error);
+      }
+      return false;
+    };
+    this.rejectionHandler = (e) => {
+      const reason = e.reason;
+      const error = reason instanceof Error ? reason : new Error(String(reason));
+      const msg = error.message || "Unhandled promise rejection";
+      const route = currentRoute();
+      this.onEvent({
+        source: "crash",
+        fingerprint: generateFingerprint("crash", msg, route),
+        message: msg,
+        route,
+        timestamp: Date.now(),
+        error
+      });
+    };
+    window.addEventListener("unhandledrejection", this.rejectionHandler);
+  }
+  destroy() {
+    window.onerror = this.prevOnError;
+    if (this.rejectionHandler) {
+      window.removeEventListener("unhandledrejection", this.rejectionHandler);
+      this.rejectionHandler = null;
+    }
+  }
+};
+var WebApiFailureHandler = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+    this.originalFetch = null;
+  }
+  start() {
+    this.originalFetch = window.fetch;
+    const original = this.originalFetch;
+    const onEvent = this.onEvent;
+    window.fetch = async function patchedFetch(input, init) {
+      const response = await original.call(window, input, init);
+      if (response.status >= 400) {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        const method = (init?.method ?? "GET").toUpperCase();
+        const route = currentRoute();
+        const msg = `${method} ${url} failed with ${response.status}`;
+        onEvent({
+          source: "api_failure",
+          fingerprint: generateFingerprint("api_failure", msg, route),
+          message: msg,
+          route,
+          timestamp: Date.now(),
+          requestUrl: url,
+          requestMethod: method,
+          statusCode: response.status
+        });
+      }
+      return response;
+    };
+  }
+  destroy() {
+    if (this.originalFetch) {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+  }
+};
+var WebRageClickHandler = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+    this.clickHandler = null;
+    this.detector = new RageClickDetector((rageEvent) => {
+      const route = currentRoute();
+      this.onEvent({
+        source: "rage_click",
+        fingerprint: generateFingerprint("rage_click", rageEvent.targetSelector, route),
+        message: `Rage click detected on ${rageEvent.targetSelector}`,
+        route,
+        timestamp: Date.now(),
+        clickCount: rageEvent.clickCount,
+        targetSelector: rageEvent.targetSelector
+      });
+    });
+  }
+  start() {
+    this.clickHandler = (e) => {
+      const target = e.target;
+      if (!(target instanceof Element)) return;
+      const selector = getSelector(target);
+      this.detector.recordClick(e.clientX, e.clientY, selector);
+    };
+    document.addEventListener("click", this.clickHandler, true);
+  }
+  destroy() {
+    if (this.clickHandler) {
+      document.removeEventListener("click", this.clickHandler, true);
+      this.clickHandler = null;
+    }
+    this.detector.destroy();
+  }
+};
+
+// src/monitoring/rn-handlers.ts
+var RNCrashHandler = class {
+  constructor(onEvent, getCurrentRoute) {
+    this.onEvent = onEvent;
+    this.getCurrentRoute = getCurrentRoute;
+    this.originalHandler = null;
+    this.started = false;
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    const errorUtils = globalThis.ErrorUtils;
+    if (!errorUtils) return;
+    this.originalHandler = errorUtils.getGlobalHandler();
+    const self = this;
+    errorUtils.setGlobalHandler((error, isFatal) => {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      const route = self.getCurrentRoute();
+      self.onEvent({
+        source: "crash",
+        fingerprint: generateFingerprint("crash", normalizedError.message, route),
+        message: normalizedError.message,
+        route,
+        timestamp: Date.now(),
+        error: normalizedError
+      });
+      if (self.originalHandler) {
+        self.originalHandler(error, isFatal);
+      }
+    });
+  }
+  destroy() {
+    if (!this.started) return;
+    this.started = false;
+    const errorUtils = globalThis.ErrorUtils;
+    if (errorUtils && this.originalHandler) {
+      errorUtils.setGlobalHandler(this.originalHandler);
+    }
+    this.originalHandler = null;
+  }
+};
+var RNApiFailureHandler = class {
+  constructor(onEvent, getCurrentRoute) {
+    this.onEvent = onEvent;
+    this.getCurrentRoute = getCurrentRoute;
+    this.originalFetch = null;
+    this.started = false;
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.originalFetch = globalThis.fetch;
+    const self = this;
+    globalThis.fetch = async function patchedFetch(input, init) {
+      const response = await self.originalFetch.call(globalThis, input, init);
+      if (response.status >= 400) {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        const method = init?.method ?? "GET";
+        const route = self.getCurrentRoute();
+        self.onEvent({
+          source: "api_failure",
+          fingerprint: generateFingerprint("api_failure", `${method} ${response.status}`, route),
+          message: `${method} ${url} failed with ${response.status}`,
+          route,
+          timestamp: Date.now(),
+          requestUrl: url,
+          requestMethod: method,
+          statusCode: response.status
+        });
+      }
+      return response;
+    };
+  }
+  destroy() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.originalFetch) {
+      globalThis.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+  }
+};
+var RNRageClickHandler = class {
+  constructor(onEvent, getCurrentRoute) {
+    this.onEvent = onEvent;
+    this.getCurrentRoute = getCurrentRoute;
+    this.detector = null;
+  }
+  start() {
+    if (this.detector) return;
+    const self = this;
+    this.detector = new RageClickDetector((rageEvent) => {
+      const route = self.getCurrentRoute();
+      self.onEvent({
+        source: "rage_click",
+        fingerprint: generateFingerprint("rage_click", rageEvent.targetSelector, route),
+        message: `Rage click detected on ${rageEvent.targetSelector}`,
+        route,
+        timestamp: Date.now(),
+        clickCount: rageEvent.clickCount,
+        targetSelector: rageEvent.targetSelector
+      });
+    });
+  }
+  /**
+   * Record a touch event. Call this from the BugBearProvider's onTouchEnd handler.
+   * @param x - Touch x coordinate
+   * @param y - Touch y coordinate
+   * @param viewId - Identifier for the touched view (e.g., testID, accessibilityLabel, or nativeID)
+   */
+  recordTouch(x, y, viewId) {
+    this.detector?.recordClick(x, y, viewId);
+  }
+  destroy() {
+    if (this.detector) {
+      this.detector.destroy();
+      this.detector = null;
+    }
+  }
+};
+
 // src/client.ts
 var formatPgError = (e) => {
   if (!e || typeof e !== "object") return { raw: e };
   const { message, code, details, hint } = e;
   return { message, code, details, hint };
 };
+var DEFAULT_API_BASE_URL = "https://app.bugbear.ai";
+var CONFIG_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var CONFIG_CACHE_PREFIX = "bugbear_config_";
 var BugBearClient = class {
   constructor(config) {
     this.navigationHistory = [];
@@ -458,23 +905,148 @@ var BugBearClient = class {
     /** Active Realtime channel references for cleanup. */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.realtimeChannels = [];
-    if (!config.supabaseUrl) {
-      throw new Error("BugBear: supabaseUrl is required. Get it from your BugBear project settings.");
-    }
-    if (!config.supabaseAnonKey) {
-      throw new Error("BugBear: supabaseAnonKey is required. Get it from your BugBear project settings.");
-    }
+    /** Error monitor instance — created when config.monitoring is present. */
+    this.monitor = null;
+    /** Whether the client has been successfully initialized. */
+    this.initialized = false;
+    /** Initialization error, if any. */
+    this.initError = null;
     this.config = config;
-    this.supabase = (0, import_supabase_js.createClient)(config.supabaseUrl, config.supabaseAnonKey);
-    if (config.offlineQueue?.enabled) {
+    if (config.apiKey) {
+      this.pendingInit = this.resolveFromApiKey(config.apiKey);
+    } else if (config.supabaseUrl && config.supabaseAnonKey) {
+      if (!config.projectId) {
+        throw new Error(
+          "BugBear: projectId is required when using explicit Supabase credentials. Tip: Use apiKey instead for simpler setup \u2014 it resolves everything automatically."
+        );
+      }
+      this.supabase = (0, import_supabase_js.createClient)(config.supabaseUrl, config.supabaseAnonKey);
+      this.initialized = true;
+      this.pendingInit = Promise.resolve();
+      this.initOfflineQueue();
+      this.initMonitoring();
+    } else {
+      throw new Error(
+        "BugBear: Missing configuration. Provide either:\n  \u2022 apiKey (recommended) \u2014 resolves everything automatically\n  \u2022 projectId + supabaseUrl + supabaseAnonKey \u2014 explicit credentials\n\nGet your API key at https://app.bugbear.ai/settings/projects"
+      );
+    }
+  }
+  /** Whether the client is ready for requests. */
+  get isReady() {
+    return this.initialized;
+  }
+  /** Wait until the client is ready. Throws if initialization failed. */
+  async ready() {
+    await this.pendingInit;
+    if (this.initError) throw this.initError;
+  }
+  /**
+   * Resolve Supabase credentials from a BugBear API key.
+   * Checks localStorage cache first, falls back to /api/v1/config.
+   */
+  async resolveFromApiKey(apiKey) {
+    try {
+      const cached = this.readConfigCache(apiKey);
+      if (cached) {
+        this.applyResolvedConfig(cached);
+        return;
+      }
+      const baseUrl = (this.config.apiBaseUrl || DEFAULT_API_BASE_URL).replace(/\/$/, "");
+      const response = await fetch(`${baseUrl}/api/v1/config`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({}));
+        const message = body.error || `HTTP ${response.status}`;
+        throw new Error(
+          `BugBear: Invalid API key \u2014 ${message}. Get yours at https://app.bugbear.ai/settings/projects`
+        );
+      }
+      const data = await response.json();
+      this.writeConfigCache(apiKey, data);
+      this.applyResolvedConfig(data);
+    } catch (err) {
+      this.initError = err instanceof Error ? err : new Error(String(err));
+      this.config.onError?.(this.initError, { context: "apikey_resolution_failed" });
+      throw this.initError;
+    }
+  }
+  /** Apply resolved credentials and create the Supabase client. */
+  applyResolvedConfig(resolved) {
+    this.config = {
+      ...this.config,
+      projectId: resolved.projectId,
+      supabaseUrl: resolved.supabaseUrl,
+      supabaseAnonKey: resolved.supabaseAnonKey
+    };
+    this.supabase = (0, import_supabase_js.createClient)(resolved.supabaseUrl, resolved.supabaseAnonKey);
+    this.initialized = true;
+    this.initOfflineQueue();
+    this.initMonitoring();
+  }
+  /** Initialize offline queue if configured. Shared by both init paths. */
+  initOfflineQueue() {
+    if (this.config.offlineQueue?.enabled) {
       this._queue = new OfflineQueue({
         enabled: true,
-        maxItems: config.offlineQueue.maxItems,
-        maxRetries: config.offlineQueue.maxRetries
+        maxItems: this.config.offlineQueue.maxItems,
+        maxRetries: this.config.offlineQueue.maxRetries
       });
       this.registerQueueHandlers();
     }
   }
+  /** Initialize error monitoring if configured. Shared by both init paths. */
+  initMonitoring() {
+    const mc = this.config.monitoring;
+    if (!mc || !mc.crashes && !mc.apiFailures && !mc.rageClicks) return;
+    this.monitor = new ErrorMonitor(mc, {
+      submitReport: (report) => this.submitReport(report),
+      getCurrentRoute: () => contextCapture.getCurrentRoute(),
+      getEnhancedContext: () => contextCapture.getEnhancedContext(),
+      getDeviceInfo: () => this.getDeviceInfo()
+    });
+  }
+  /** Read cached config from localStorage if available and not expired. */
+  readConfigCache(apiKey) {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const key = CONFIG_CACHE_PREFIX + this.hashKey(apiKey);
+      const raw = localStorage.getItem(key);
+      if (!raw) return null;
+      const cached = JSON.parse(raw);
+      if (Date.now() - cached.cachedAt > CONFIG_CACHE_TTL_MS) {
+        localStorage.removeItem(key);
+        return null;
+      }
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+  /** Write resolved config to localStorage cache. */
+  writeConfigCache(apiKey, data) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const key = CONFIG_CACHE_PREFIX + this.hashKey(apiKey);
+      const cached = { ...data, cachedAt: Date.now() };
+      localStorage.setItem(key, JSON.stringify(cached));
+    } catch {
+    }
+  }
+  /** Simple string hash for cache keys — avoids storing raw API keys. */
+  hashKey(apiKey) {
+    let hash = 0;
+    for (let i = 0; i < apiKey.length; i++) {
+      hash = (hash << 5) - hash + apiKey.charCodeAt(i) | 0;
+    }
+    return hash.toString(36);
+  }
+  /** Ensure the client is initialized before making requests. */
+  async ensureReady() {
+    if (this.initialized) return;
+    await this.pendingInit;
+    if (this.initError) throw this.initError;
+  }
   // ── Offline Queue ─────────────────────────────────────────
   /**
    * Access the offline queue (if enabled).
@@ -630,6 +1202,7 @@ var BugBearClient = class {
    * Get current user info from host app or BugBear's own auth
    */
   async getCurrentUserInfo() {
+    await this.ensureReady();
     if (this.config.getCurrentUser) {
       return await this.config.getCurrentUser();
     }
@@ -688,7 +1261,9 @@ var BugBearClient = class {
         navigation_history: this.getNavigationHistory(),
         enhanced_context: report.enhancedContext || contextCapture.getEnhancedContext(),
         assignment_id: report.assignmentId,
-        test_case_id: report.testCaseId
+        test_case_id: report.testCaseId,
+        report_source: report.reportSource || "manual",
+        error_fingerprint: report.appContext?.custom?.fingerprint || null
       };
       const { data, error } = await this.supabase.from("reports").insert(fullReport).select("id").single();
       if (error) {
@@ -770,7 +1345,7 @@ var BugBearClient = class {
         `;
       const [pendingResult, completedResult] = await Promise.all([
         this.supabase.from("test_assignments").select(selectFields).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["pending", "in_progress"]).order("created_at", { ascending: true }).range(from, to),
-        this.supabase.from("test_assignments").select(selectFields).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["passed", "failed", "skipped", "blocked"]).order("completed_at", { ascending: false }).limit(100)
+        this.supabase.from("test_assignments").select(selectFields).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["passed", "failed", "skipped", "blocked"]).or("is_verification.eq.false,is_verification.is.null").order("completed_at", { ascending: false }).limit(100)
       ]);
       if (pendingResult.error) {
         console.error("BugBear: Failed to fetch assignments", formatPgError(pendingResult.error));
@@ -849,6 +1424,7 @@ var BugBearClient = class {
    */
   async getAssignment(assignmentId) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.from("test_assignments").select(`
           id,
           status,
@@ -920,6 +1496,7 @@ var BugBearClient = class {
    */
   async updateAssignmentStatus(assignmentId, status, options) {
     try {
+      await this.ensureReady();
       const { data: currentAssignment, error: fetchError } = await this.supabase.from("test_assignments").select("status, started_at").eq("id", assignmentId).single();
       if (fetchError || !currentAssignment) {
         console.error("BugBear: Assignment not found", {
@@ -1006,6 +1583,7 @@ var BugBearClient = class {
    */
   async reopenAssignment(assignmentId) {
     try {
+      await this.ensureReady();
       const { data: current, error: fetchError } = await this.supabase.from("test_assignments").select("status").eq("id", assignmentId).single();
       if (fetchError || !current) {
         return { success: false, error: "Assignment not found" };
@@ -1045,6 +1623,7 @@ var BugBearClient = class {
       actualNotes = notes;
     }
     try {
+      await this.ensureReady();
       const updateData = {
         status: "skipped",
         skip_reason: actualReason,
@@ -1214,6 +1793,7 @@ var BugBearClient = class {
    */
   async getTesterInfo() {
     try {
+      await this.ensureReady();
       const userInfo = await this.getCurrentUserInfo();
       if (!userInfo?.email) return null;
       if (!this.isValidEmail(userInfo.email)) {
@@ -1234,7 +1814,8 @@ var BugBearClient = class {
         avatarUrl: tester.avatar_url || void 0,
         platforms: tester.platforms || [],
         assignedTests: tester.assigned_count || 0,
-        completedTests: tester.completed_count || 0
+        completedTests: tester.completed_count || 0,
+        role: tester.role || "tester"
       };
     } catch (err) {
       console.error("BugBear: getTesterInfo error", err);
@@ -1505,6 +2086,7 @@ var BugBearClient = class {
    */
   async isQAEnabled() {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.rpc("check_qa_enabled", {
         p_project_id: this.config.projectId
       });
@@ -1521,21 +2103,85 @@ var BugBearClient = class {
     }
   }
   /**
-   * Check if the widget should be visible
-   * (QA mode enabled AND current user is a tester)
+   * Check if the widget should be visible.
+   * Behavior depends on the configured mode:
+   * - 'qa': QA enabled AND user is a registered tester
+   * - 'feedback': Any authenticated user
+   * - 'auto': Either QA tester OR authenticated non-tester
    */
   async shouldShowWidget() {
-    const [qaEnabled, isTester] = await Promise.all([
+    const mode = this.config.mode || "qa";
+    if (mode === "qa") {
+      const [qaEnabled2, tester] = await Promise.all([
+        this.isQAEnabled(),
+        this.isTester()
+      ]);
+      return qaEnabled2 && tester;
+    }
+    if (mode === "feedback") {
+      const userInfo2 = await this.getCurrentUserInfo();
+      return userInfo2 !== null;
+    }
+    const [qaEnabled, testerInfo, userInfo] = await Promise.all([
+      this.isQAEnabled(),
+      this.getTesterInfo(),
+      this.getCurrentUserInfo()
+    ]);
+    if (qaEnabled && testerInfo && testerInfo.role !== "feedback") return true;
+    if (userInfo) return true;
+    return false;
+  }
+  /**
+   * Resolve the effective widget mode for the current user.
+   * - 'qa' or 'feedback' config → returned as-is
+   * - 'auto' → checks if user is a QA tester (role='tester') → 'qa', otherwise 'feedback'
+   */
+  async getEffectiveMode() {
+    const mode = this.config.mode || "qa";
+    if (mode === "qa") return "qa";
+    if (mode === "feedback") return "feedback";
+    const [qaEnabled, testerInfo] = await Promise.all([
       this.isQAEnabled(),
-      this.isTester()
+      this.getTesterInfo()
     ]);
-    return qaEnabled && isTester;
+    if (qaEnabled && testerInfo && testerInfo.role !== "feedback") return "qa";
+    return "feedback";
+  }
+  /**
+   * Auto-provision a feedback user record in the testers table.
+   * Called during initialization when mode is 'feedback' or 'auto' for non-testers.
+   * Idempotent — safe to call multiple times. Returns the tester info for the user.
+   */
+  async ensureFeedbackUser() {
+    try {
+      await this.ensureReady();
+      const userInfo = await this.getCurrentUserInfo();
+      if (!userInfo?.email) return null;
+      const { error } = await this.supabase.rpc("ensure_feedback_user", {
+        p_project_id: this.config.projectId,
+        p_user_id: userInfo.id,
+        p_email: userInfo.email,
+        p_name: userInfo.name || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to ensure feedback user", error.message);
+        this.config.onError?.(new Error(`ensure_feedback_user failed: ${error.message}`), {
+          context: "feedback_user_provisioning"
+        });
+        return null;
+      }
+      return this.getTesterInfo();
+    } catch (err) {
+      console.error("BugBear: Error ensuring feedback user", err);
+      return null;
+    }
   }
   /**
    * Upload a screenshot (web - uses File/Blob)
    */
   async uploadScreenshot(file, filename, bucket = "screenshots") {
     try {
+      await this.ensureReady();
       const contentType = file.type || "image/png";
       const ext = contentType.includes("png") ? "png" : "jpg";
       const name = filename || `screenshot-${Date.now()}.${ext}`;
@@ -1576,6 +2222,7 @@ var BugBearClient = class {
    */
   async uploadImageFromUri(uri, filename, bucket = "screenshots") {
     try {
+      await this.ensureReady();
       const response = await fetch(uri);
       const blob = await response.blob();
       const contentType = blob.type || "image/jpeg";
@@ -1670,6 +2317,7 @@ var BugBearClient = class {
    */
   async getFixRequests(options) {
     try {
+      await this.ensureReady();
       let query = this.supabase.from("fix_requests").select("*").eq("project_id", this.config.projectId).order("created_at", { ascending: false }).limit(options?.limit || 20);
       if (options?.status) {
         query = query.eq("status", options.status);
@@ -1741,6 +2389,7 @@ var BugBearClient = class {
    */
   async getThreadMessages(threadId) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.from("discussion_messages").select(`
           id,
           thread_id,
@@ -1943,6 +2592,7 @@ var BugBearClient = class {
    */
   async endSession(sessionId, options = {}) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.rpc("end_qa_session", {
         p_session_id: sessionId,
         p_notes: options.notes || null,
@@ -1980,6 +2630,7 @@ var BugBearClient = class {
    */
   async getSession(sessionId) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("id", sessionId).single();
       if (error || !data) return null;
       return this.transformSession(data);
@@ -2011,6 +2662,7 @@ var BugBearClient = class {
    */
   async addFinding(sessionId, options) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.rpc("add_session_finding", {
         p_session_id: sessionId,
         p_type: options.type,
@@ -2041,6 +2693,7 @@ var BugBearClient = class {
    */
   async getSessionFindings(sessionId) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.from("qa_findings").select("*").eq("session_id", sessionId).order("created_at", { ascending: true }).limit(100);
       if (error) {
         console.error("BugBear: Failed to fetch findings", formatPgError(error));
@@ -2057,6 +2710,7 @@ var BugBearClient = class {
    */
   async convertFindingToBug(findingId) {
     try {
+      await this.ensureReady();
       const { data, error } = await this.supabase.rpc("convert_finding_to_bug", {
         p_finding_id: findingId
       });
@@ -2076,6 +2730,7 @@ var BugBearClient = class {
    */
   async dismissFinding(findingId, reason) {
     try {
+      await this.ensureReady();
       const { error } = await this.supabase.from("qa_findings").update({
         dismissed: true,
         dismissed_reason: reason || null,
@@ -2150,11 +2805,22 @@ function createBugBear(config) {
 0 && (module.exports = {
   BUG_CATEGORIES,
   BugBearClient,
+  DedupWindow,
+  ErrorMonitor,
   LocalStorageAdapter,
   OfflineQueue,
+  RNApiFailureHandler,
+  RNCrashHandler,
+  RNRageClickHandler,
+  RageClickDetector,
+  WebApiFailureHandler,
+  WebCrashHandler,
+  WebRageClickHandler,
   captureError,
   contextCapture,
   createBugBear,
+  generateFingerprint,
   isBugCategory,
-  isNetworkError
+  isNetworkError,
+  scrubUrl
 });