blinker-sdk 1.0.1 → 2.0.1

package/dist/index.esm.js

@@ -1,364 +1,2288 @@
-// src/sender.ts
-async function sendEvent(api, token, event, debug = false) {
-  const endpoint = `${api.replace(/\/$/, "")}/events`;
+// src/core/config.ts
+var BLINKER_API = "https://api.blinker.live";
+var SDK_VERSION = "2.0.1";
+var STORAGE_KEYS = {
+  EVENT_QUEUE: "blinker_event_queue",
+  SESSION: "blinker_session",
+  USER_CONTEXT: "blinker_user_context"
+};
+var DEFAULTS = {
+  endpoint: BLINKER_API,
+  enabled: true,
+  captureErrors: true,
+  captureRejections: true,
+  enableBatching: true,
+  batchSize: 10,
+  flushInterval: 5e3,
+  enableOfflineStorage: true,
+  maxStoredEvents: 100,
+  enableDeduplication: true,
+  deduplicationWindow: 6e4,
+  maxEventsPerMinute: 100,
+  sampleRate: 1,
+  debug: false
+};
+var TIMING = {
+  OFFLINE_RETRY_TIMEOUT: 3e4,
+  MIN_FLUSH_INTERVAL: 1e3,
+  MAX_FLUSH_INTERVAL: 6e4
+};
+
+// src/filters/defaults.ts
+var DEFAULT_FILTERS = {
+  ignoreHttpCodes: [401, 403],
+  ignoreErrorTypes: [],
+  ignoreMessagePatterns: [
+    "ResizeObserver loop",
+    "Script error",
+    "ResizeObserver loop completed"
+  ],
+  captureAll: false
+};
+
+// src/utils/logger.ts
+var PREFIX = "[Blinker]";
+function createLogger(debug) {
+  const noop = () => {
+  };
+  if (!debug) {
+    return {
+      log: noop,
+      warn: noop,
+      error: noop
+    };
+  }
+  return {
+    log: (...args) => console.log(PREFIX, ...args),
+    warn: (...args) => console.warn(PREFIX, ...args),
+    error: (...args) => console.error(PREFIX, ...args)
+  };
+}
+var globalLogger = createLogger(false);
+function setGlobalLogger(debug) {
+  globalLogger = createLogger(debug);
+}
+function getLogger() {
+  return globalLogger;
+}
+
+// src/filters/FilterEngine.ts
+var FilterEngine = class {
+  constructor(userFilters) {
+    var _a, _b, _c, _d;
+    this.filters = {
+      ignoreHttpCodes: (_a = userFilters == null ? void 0 : userFilters.ignoreHttpCodes) != null ? _a : DEFAULT_FILTERS.ignoreHttpCodes,
+      ignoreErrorTypes: (_b = userFilters == null ? void 0 : userFilters.ignoreErrorTypes) != null ? _b : DEFAULT_FILTERS.ignoreErrorTypes,
+      ignoreMessagePatterns: (_c = userFilters == null ? void 0 : userFilters.ignoreMessagePatterns) != null ? _c : DEFAULT_FILTERS.ignoreMessagePatterns,
+      captureAll: (_d = userFilters == null ? void 0 : userFilters.captureAll) != null ? _d : DEFAULT_FILTERS.captureAll
+    };
+  }
+  shouldCapture(message, errorType, httpCode) {
+    const logger = getLogger();
+    if (this.filters.captureAll) {
+      return true;
+    }
+    if (httpCode !== void 0 && this.filters.ignoreHttpCodes.includes(httpCode)) {
+      logger.log("Event filtered out by HTTP code:", httpCode);
+      return false;
+    }
+    if (errorType && this.filters.ignoreErrorTypes.includes(errorType)) {
+      logger.log("Event filtered out by error type:", errorType);
+      return false;
+    }
+    for (const pattern of this.filters.ignoreMessagePatterns) {
+      if (message.toLowerCase().includes(pattern.toLowerCase())) {
+        logger.log("Event filtered out by message pattern:", pattern);
+        return false;
+      }
+    }
+    if (httpCode === void 0) {
+      const httpCodeMatch = message.match(/(?:HTTP\s*|status[:\s]*)?(\d{3})(?:\s|$|:)/i);
+      if (httpCodeMatch) {
+        const extractedCode = parseInt(httpCodeMatch[1], 10);
+        if (extractedCode >= 100 && extractedCode < 600) {
+          if (this.filters.ignoreHttpCodes.includes(extractedCode)) {
+            logger.log("Event filtered out by extracted HTTP code:", extractedCode);
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+  getFilters() {
+    return { ...this.filters };
+  }
+  updateFilters(newFilters) {
+    var _a, _b, _c, _d;
+    this.filters = {
+      ignoreHttpCodes: (_a = newFilters.ignoreHttpCodes) != null ? _a : this.filters.ignoreHttpCodes,
+      ignoreErrorTypes: (_b = newFilters.ignoreErrorTypes) != null ? _b : this.filters.ignoreErrorTypes,
+      ignoreMessagePatterns: (_c = newFilters.ignoreMessagePatterns) != null ? _c : this.filters.ignoreMessagePatterns,
+      captureAll: (_d = newFilters.captureAll) != null ? _d : this.filters.captureAll
+    };
+  }
+};
+
+// src/utils/browser.ts
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function isLocalStorageAvailable() {
+  if (!isBrowser()) return false;
+  try {
+    const testKey = "__blinker_test__";
+    localStorage.setItem(testKey, "test");
+    localStorage.removeItem(testKey);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isSessionStorageAvailable() {
+  if (!isBrowser()) return false;
+  try {
+    const testKey = "__blinker_test__";
+    sessionStorage.setItem(testKey, "test");
+    sessionStorage.removeItem(testKey);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isOnline() {
+  var _a;
+  if (!isBrowser()) return true;
+  return (_a = navigator.onLine) != null ? _a : true;
+}
+function getCurrentUrl() {
+  if (!isBrowser()) return void 0;
+  return window.location.href;
+}
+function getCurrentPath() {
+  if (!isBrowser()) return "unknown";
+  return window.location.pathname;
+}
+function getUserAgent() {
+  if (!isBrowser()) return void 0;
+  return navigator.userAgent;
+}
+function getReferrer() {
+  if (!isBrowser()) return void 0;
+  return document.referrer || void 0;
+}
+
+// src/queue/storage.ts
+var OfflineStorage = class {
+  constructor(maxEvents = 100) {
+    this.storageKey = STORAGE_KEYS.EVENT_QUEUE;
+    this.maxEvents = maxEvents;
+    this.available = isLocalStorageAvailable();
+  }
+  isAvailable() {
+    return this.available;
+  }
+  store(event) {
+    if (!this.available) return false;
+    const logger = getLogger();
+    try {
+      const events = this.getAll();
+      const storedEvent = {
+        event,
+        storedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        retries: 0
+      };
+      events.push(storedEvent);
+      while (events.length > this.maxEvents) {
+        events.shift();
+      }
+      localStorage.setItem(this.storageKey, JSON.stringify(events));
+      logger.log(`Event stored offline. Total stored: ${events.length}`);
+      return true;
+    } catch (error) {
+      logger.error("Failed to store event offline:", error);
+      return false;
+    }
+  }
+  storeMany(eventsToStore) {
+    if (!this.available || eventsToStore.length === 0) return 0;
+    const logger = getLogger();
+    let stored = 0;
+    try {
+      const events = this.getAll();
+      for (const event of eventsToStore) {
+        const storedEvent = {
+          event,
+          storedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          retries: 0
+        };
+        events.push(storedEvent);
+        stored++;
+      }
+      while (events.length > this.maxEvents) {
+        events.shift();
+      }
+      localStorage.setItem(this.storageKey, JSON.stringify(events));
+      logger.log(`Stored ${stored} events offline. Total stored: ${events.length}`);
+      return stored;
+    } catch (error) {
+      logger.error("Failed to store events offline:", error);
+      return stored;
+    }
+  }
+  getAll() {
+    if (!this.available) return [];
+    try {
+      const data = localStorage.getItem(this.storageKey);
+      if (!data) return [];
+      return JSON.parse(data);
+    } catch (e) {
+      return [];
+    }
+  }
+  retrieveAll() {
+    if (!this.available) return [];
+    const logger = getLogger();
+    try {
+      const stored = this.getAll();
+      if (stored.length === 0) return [];
+      localStorage.removeItem(this.storageKey);
+      logger.log(`Retrieved ${stored.length} stored events`);
+      return stored.map((s) => s.event);
+    } catch (error) {
+      logger.error("Failed to retrieve stored events:", error);
+      return [];
+    }
+  }
+  count() {
+    return this.getAll().length;
+  }
+  clear() {
+    if (!this.available) return;
+    try {
+      localStorage.removeItem(this.storageKey);
+    } catch (e) {
+    }
+  }
+};
+
+// src/transport/sender.ts
+async function sendBatch(apiUrl, token, events) {
+  const logger = getLogger();
+  const endpoint = `${apiUrl.replace(/\/$/, "")}/events`;
+  if (events.length === 0) {
+    return { success: true, count: 0 };
+  }
   const sendRequest = async () => {
     try {
+      const body = events.length === 1 ? formatEventForApi(events[0]) : { events: events.map(formatEventForApi) };
       const response = await fetch(endpoint, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
           "x-blinker-token": token
         },
-        body: JSON.stringify({
-          type: event.type,
-          message: event.message,
-          payload: event.payload || {},
-          timestamp: event.timestamp,
-          url: event.url,
-          userAgent: event.userAgent
-        })
+        body: JSON.stringify(body)
       });
       if (!response.ok) {
         const errorText = await response.text().catch(() => "Unknown error");
-        if (debug) {
-          console.error(`[Blinker] Failed to send event: ${response.status} - ${errorText}`);
-        }
+        logger.error(`Failed to send events: ${response.status} - ${errorText}`);
         return { success: false, error: `HTTP ${response.status}: ${errorText}` };
       }
-      if (debug) {
-        console.log(`[Blinker] Event sent successfully:`, event.type);
-      }
-      return { success: true };
+      logger.log(`Events sent successfully: ${events.length} event(s)`);
+      return { success: true, count: events.length };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (debug) {
-        console.error(`[Blinker] Error sending event:`, errorMessage);
-      }
+      logger.error("Error sending events:", errorMessage);
       return { success: false, error: errorMessage };
     }
-  };
-  const result = await sendRequest();
-  if (!result.success && typeof navigator !== "undefined" && !navigator.onLine) {
-    if (debug) {
-      console.log(`[Blinker] Offline, waiting for connection to retry...`);
-    }
-    const waitForOnline = new Promise((resolve) => {
-      const timeout = setTimeout(() => resolve(false), 3e4);
-      const onlineHandler = () => {
-        clearTimeout(timeout);
-        if (typeof window !== "undefined") {
-          window.removeEventListener("online", onlineHandler);
-        }
-        resolve(true);
-      };
-      if (typeof window !== "undefined") {
-        window.addEventListener("online", onlineHandler);
-      } else {
-        resolve(false);
-      }
-    });
-    const isOnline = await waitForOnline;
-    if (isOnline) {
-      if (debug) {
-        console.log(`[Blinker] Back online, retrying...`);
-      }
-      return sendRequest();
+  };
+  const result = await sendRequest();
+  if (!result.success && isBrowser() && !isOnline()) {
+    logger.log("Offline, waiting for connection to retry...");
+    const isBackOnline = await waitForOnline(TIMING.OFFLINE_RETRY_TIMEOUT);
+    if (isBackOnline) {
+      logger.log("Back online, retrying...");
+      return sendRequest();
+    }
+  }
+  return result;
+}
+function formatEventForApi(event) {
+  return {
+    type: event.type,
+    message: event.message,
+    payload: event.payload || {},
+    timestamp: event.timestamp,
+    url: event.url,
+    userAgent: event.userAgent,
+    sessionId: event.sessionId,
+    userId: event.userId,
+    userTraits: event.userTraits,
+    context: event.context,
+    count: event.count
+  };
+}
+function waitForOnline(timeout) {
+  return new Promise((resolve) => {
+    if (!isBrowser()) {
+      resolve(false);
+      return;
+    }
+    const timeoutId = setTimeout(() => resolve(false), timeout);
+    const onlineHandler = () => {
+      clearTimeout(timeoutId);
+      window.removeEventListener("online", onlineHandler);
+      resolve(true);
+    };
+    window.addEventListener("online", onlineHandler);
+  });
+}
+
+// src/queue/EventQueue.ts
+var EventQueue = class {
+  constructor(token, config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isFlushing = false;
+    this.handleOnline = () => {
+      const logger = getLogger();
+      logger.log("Back online, flushing stored events");
+      this.flush();
+    };
+    var _a, _b, _c, _d, _e, _f;
+    this.token = token;
+    this.config = {
+      endpoint: (_a = config == null ? void 0 : config.endpoint) != null ? _a : DEFAULTS.endpoint,
+      enableBatching: (_b = config == null ? void 0 : config.enableBatching) != null ? _b : DEFAULTS.enableBatching,
+      batchSize: (_c = config == null ? void 0 : config.batchSize) != null ? _c : DEFAULTS.batchSize,
+      flushInterval: Math.max(
+        TIMING.MIN_FLUSH_INTERVAL,
+        Math.min((_d = config == null ? void 0 : config.flushInterval) != null ? _d : DEFAULTS.flushInterval, TIMING.MAX_FLUSH_INTERVAL)
+      ),
+      enableOfflineStorage: (_e = config == null ? void 0 : config.enableOfflineStorage) != null ? _e : DEFAULTS.enableOfflineStorage,
+      maxStoredEvents: (_f = config == null ? void 0 : config.maxStoredEvents) != null ? _f : DEFAULTS.maxStoredEvents,
+      onError: config == null ? void 0 : config.onError
+    };
+    this.storage = new OfflineStorage(this.config.maxStoredEvents);
+    if (this.config.enableBatching) {
+      this.startFlushTimer();
+    }
+    if (isBrowser() && this.config.enableOfflineStorage) {
+      window.addEventListener("online", this.handleOnline);
+    }
+  }
+  async add(event) {
+    const logger = getLogger();
+    if (!this.config.enableBatching) {
+      return this.sendImmediately([event]);
+    }
+    this.queue.push(event);
+    logger.log(`Event queued. Queue size: ${this.queue.length}`);
+    if (this.queue.length >= this.config.batchSize) {
+      return this.flush();
+    }
+    return { success: true };
+  }
+  async flush() {
+    const logger = getLogger();
+    if (this.isFlushing) {
+      logger.log("Flush already in progress, skipping");
+      return { success: true };
+    }
+    const events = [...this.queue];
+    this.queue = [];
+    if (this.config.enableOfflineStorage && isOnline()) {
+      const storedEvents = this.storage.retrieveAll();
+      if (storedEvents.length > 0) {
+        events.unshift(...storedEvents);
+        logger.log(`Including ${storedEvents.length} stored offline events`);
+      }
+    }
+    if (events.length === 0) {
+      return { success: true, count: 0 };
+    }
+    this.isFlushing = true;
+    try {
+      const result = await this.sendImmediately(events);
+      if (!result.success && this.config.enableOfflineStorage && !isOnline()) {
+        logger.log("Send failed while offline, storing events");
+        this.storage.storeMany(events);
+      }
+      return result;
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  async sendImmediately(events) {
+    const logger = getLogger();
+    if (!isOnline() && this.config.enableOfflineStorage) {
+      logger.log("Offline, storing events for later");
+      const stored = this.storage.storeMany(events);
+      return { success: true, count: stored };
+    }
+    const result = await sendBatch(this.config.endpoint, this.token, events);
+    if (!result.success && this.config.onError) {
+      this.config.onError(result.error || "Unknown error sending events");
+    }
+    return result;
+  }
+  getStats() {
+    const queueSize = this.queue.length;
+    const storedSize = this.storage.count();
+    return {
+      queueSize,
+      storedSize,
+      totalPending: queueSize + storedSize
+    };
+  }
+  size() {
+    return this.queue.length;
+  }
+  startFlushTimer() {
+    if (this.flushTimer) return;
+    this.flushTimer = setInterval(() => {
+      if (this.queue.length > 0) {
+        this.flush();
+      }
+    }, this.config.flushInterval);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  destroy() {
+    this.stopFlushTimer();
+    if (isBrowser()) {
+      window.removeEventListener("online", this.handleOnline);
+    }
+    if (this.queue.length > 0 && isOnline()) {
+      this.flush();
+    } else if (this.queue.length > 0 && this.config.enableOfflineStorage) {
+      this.storage.storeMany(this.queue);
+    }
+    this.queue = [];
+  }
+};
+
+// src/utils/hash.ts
+function simpleHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16);
+}
+function generateErrorFingerprint(message, stack) {
+  let input = message;
+  if (stack) {
+    const stackLines = stack.split("\n").slice(1, 4);
+    const cleanedStack = stackLines.map((line) => line.replace(/:\d+:\d+\)?$/, "").trim()).join("|");
+    input += "|" + cleanedStack;
+  }
+  return simpleHash(input);
+}
+function generateUniqueId() {
+  const timestamp = Date.now().toString(36);
+  const randomPart = Math.random().toString(36).substring(2, 10);
+  return `${timestamp}-${randomPart}`;
+}
+
+// src/context/SessionManager.ts
+var SessionManager = class {
+  constructor() {
+    this.session = null;
+    this.storageKey = STORAGE_KEYS.SESSION;
+    this.storageAvailable = isSessionStorageAvailable();
+    this.initSession();
+  }
+  initSession() {
+    const logger = getLogger();
+    if (this.storageAvailable) {
+      try {
+        const stored = sessionStorage.getItem(this.storageKey);
+        if (stored) {
+          this.session = JSON.parse(stored);
+          logger.log("Session restored:", this.session.id);
+          return;
+        }
+      } catch (e) {
+      }
+    }
+    this.session = {
+      id: generateUniqueId(),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pageViews: 0,
+      lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.persist();
+    logger.log("New session created:", this.session.id);
+  }
+  getSessionId() {
+    var _a, _b;
+    return (_b = (_a = this.session) == null ? void 0 : _a.id) != null ? _b : generateUniqueId();
+  }
+  getSession() {
+    if (!this.session) {
+      this.initSession();
+    }
+    return { ...this.session };
+  }
+  recordPageView() {
+    if (this.session) {
+      this.session.pageViews++;
+      this.session.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.persist();
+    }
+  }
+  touch() {
+    if (this.session) {
+      this.session.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.persist();
+    }
+  }
+  getDuration() {
+    if (!this.session) return 0;
+    const start = new Date(this.session.startedAt).getTime();
+    return Date.now() - start;
+  }
+  persist() {
+    if (!this.storageAvailable || !this.session) return;
+    try {
+      sessionStorage.setItem(this.storageKey, JSON.stringify(this.session));
+    } catch (e) {
+    }
+  }
+  endSession() {
+    if (this.storageAvailable) {
+      try {
+        sessionStorage.removeItem(this.storageKey);
+      } catch (e) {
+      }
+    }
+    this.session = null;
+  }
+};
+
+// src/context/UserContext.ts
+var UserContext = class {
+  constructor(sessionManager) {
+    this.user = null;
+    this.customContext = {};
+    this.sessionManager = sessionManager;
+  }
+  identify(userId, traits) {
+    const logger = getLogger();
+    this.user = {
+      userId,
+      traits: traits ? { ...traits } : void 0,
+      identifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    logger.log("User identified:", userId);
+  }
+  getUserId() {
+    var _a;
+    return (_a = this.user) == null ? void 0 : _a.userId;
+  }
+  getUserTraits() {
+    var _a;
+    return ((_a = this.user) == null ? void 0 : _a.traits) ? { ...this.user.traits } : void 0;
+  }
+  isIdentified() {
+    return this.user !== null;
+  }
+  setContext(key, value) {
+    const logger = getLogger();
+    this.customContext[key] = value;
+    logger.log("Context set:", key);
+  }
+  getContextValue(key) {
+    return this.customContext[key];
+  }
+  getCustomContext() {
+    return { ...this.customContext };
+  }
+  getEventContext() {
+    var _a, _b;
+    return {
+      sessionId: this.sessionManager.getSessionId(),
+      userId: (_a = this.user) == null ? void 0 : _a.userId,
+      userTraits: ((_b = this.user) == null ? void 0 : _b.traits) ? { ...this.user.traits } : void 0,
+      custom: { ...this.customContext }
+    };
+  }
+  clearIdentity() {
+    const logger = getLogger();
+    this.user = null;
+    logger.log("User identity cleared");
+  }
+  clearAll() {
+    const logger = getLogger();
+    this.user = null;
+    this.customContext = {};
+    logger.log("All context cleared");
+  }
+};
+
+// src/sampling/RateLimiter.ts
+var MINUTE_MS = 60 * 1e3;
+var RateLimiter = class {
+  constructor(maxEventsPerMinute) {
+    this.maxPerMinute = maxEventsPerMinute != null ? maxEventsPerMinute : DEFAULTS.maxEventsPerMinute;
+    this.state = {
+      count: 0,
+      windowStart: Date.now(),
+      dropped: 0
+    };
+  }
+  allow() {
+    const logger = getLogger();
+    if (this.maxPerMinute === 0) {
+      return true;
+    }
+    const now = Date.now();
+    if (now - this.state.windowStart >= MINUTE_MS) {
+      if (this.state.dropped > 0) {
+        logger.warn(`Rate limit: ${this.state.dropped} events dropped in last minute`);
+      }
+      this.state = {
+        count: 0,
+        windowStart: now,
+        dropped: 0
+      };
+    }
+    if (this.state.count < this.maxPerMinute) {
+      this.state.count++;
+      return true;
+    }
+    this.state.dropped++;
+    if (this.state.dropped === 1) {
+      logger.warn(`Rate limit reached: ${this.maxPerMinute} events/minute`);
+    }
+    return false;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getRemaining() {
+    if (this.maxPerMinute === 0) return Infinity;
+    if (Date.now() - this.state.windowStart >= MINUTE_MS) {
+      return this.maxPerMinute;
+    }
+    return Math.max(0, this.maxPerMinute - this.state.count);
+  }
+  reset() {
+    this.state = {
+      count: 0,
+      windowStart: Date.now(),
+      dropped: 0
+    };
+  }
+  setLimit(maxEventsPerMinute) {
+    this.maxPerMinute = maxEventsPerMinute;
+  }
+};
+
+// src/sampling/Sampler.ts
+var Sampler = class {
+  constructor(sampleRate) {
+    this.sampled = 0;
+    this.dropped = 0;
+    this.sampleRate = Math.max(0, Math.min(1, sampleRate != null ? sampleRate : DEFAULTS.sampleRate));
+  }
+  shouldSample(isError = false) {
+    const logger = getLogger();
+    if (isError) {
+      this.sampled++;
+      return true;
+    }
+    if (this.sampleRate >= 1) {
+      this.sampled++;
+      return true;
+    }
+    if (this.sampleRate <= 0) {
+      this.dropped++;
+      return false;
+    }
+    if (Math.random() < this.sampleRate) {
+      this.sampled++;
+      return true;
+    }
+    this.dropped++;
+    logger.log("Event sampled out");
+    return false;
+  }
+  getStats() {
+    return {
+      sampled: this.sampled,
+      dropped: this.dropped,
+      rate: this.sampleRate
+    };
+  }
+  setRate(rate) {
+    this.sampleRate = Math.max(0, Math.min(1, rate));
+  }
+  getRate() {
+    return this.sampleRate;
+  }
+  resetStats() {
+    this.sampled = 0;
+    this.dropped = 0;
+  }
+};
+
+// src/capture/deduplication.ts
+var Deduplicator = class {
+  constructor(enabled, windowMs) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.cleanupTimer = null;
+    this.enabled = enabled != null ? enabled : DEFAULTS.enableDeduplication;
+    this.windowMs = windowMs != null ? windowMs : DEFAULTS.deduplicationWindow;
+    if (this.enabled) {
+      this.startCleanup();
+    }
+  }
+  check(message, stack) {
+    const fingerprint = generateErrorFingerprint(message, stack);
+    if (!this.enabled) {
+      return {
+        shouldSend: true,
+        fingerprint,
+        count: 1,
+        isDuplicate: false
+      };
+    }
+    const logger = getLogger();
+    const now = Date.now();
+    const existing = this.entries.get(fingerprint);
+    if (existing) {
+      if (now - existing.firstSeen < this.windowMs) {
+        existing.count++;
+        existing.lastSeen = now;
+        logger.log(`Duplicate error detected (count: ${existing.count}):`, message.substring(0, 50));
+        return {
+          shouldSend: false,
+          fingerprint,
+          count: existing.count,
+          isDuplicate: true
+        };
+      }
+      this.entries.delete(fingerprint);
+    }
+    this.entries.set(fingerprint, {
+      fingerprint,
+      firstSeen: now,
+      count: 1,
+      lastSeen: now
+    });
+    return {
+      shouldSend: true,
+      fingerprint,
+      count: 1,
+      isDuplicate: false
+    };
+  }
+  getCount(fingerprint) {
+    var _a, _b;
+    return (_b = (_a = this.entries.get(fingerprint)) == null ? void 0 : _a.count) != null ? _b : 1;
+  }
+  flush() {
+    const duplicates = Array.from(this.entries.values()).filter((e) => e.count > 1);
+    this.entries.clear();
+    return duplicates;
+  }
+  startCleanup() {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, this.windowMs);
+  }
+  cleanup() {
+    const now = Date.now();
+    const logger = getLogger();
+    let removed = 0;
+    for (const [fingerprint, entry] of this.entries) {
+      if (now - entry.firstSeen >= this.windowMs) {
+        this.entries.delete(fingerprint);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      logger.log(`Deduplication cleanup: removed ${removed} expired entries`);
+    }
+  }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.entries.clear();
+  }
+  getStats() {
+    return {
+      entries: this.entries.size,
+      enabled: this.enabled,
+      windowMs: this.windowMs
+    };
+  }
+};
+
+// src/capture/errorHandler.ts
+var originalOnError = null;
+var originalOnUnhandledRejection = null;
+var isSetup = false;
+function setupErrorHandlers(callback, options = {}) {
+  const { captureErrors = true, captureRejections = true } = options;
+  const logger = getLogger();
+  if (isSetup) {
+    logger.warn("Error handlers already set up");
+    return;
+  }
+  if (!isBrowser()) {
+    logger.log("Not in browser environment, skipping error handlers");
+    return;
+  }
+  if (captureErrors) {
+    originalOnError = window.onerror;
+    window.onerror = function(message, source, lineno, colno, error) {
+      const errorMessage = typeof message === "string" ? message : message.type || "Unknown error";
+      const payload = {
+        source,
+        lineno,
+        colno,
+        stack: error == null ? void 0 : error.stack,
+        errorType: error == null ? void 0 : error.name
+      };
+      logger.log("Captured error:", errorMessage);
+      callback("error", errorMessage, payload);
+      if (typeof originalOnError === "function") {
+        return originalOnError.call(window, message, source, lineno, colno, error);
+      }
+      return false;
+    };
+  }
+  if (captureRejections) {
+    originalOnUnhandledRejection = window.onunhandledrejection;
+    window.onunhandledrejection = function(event) {
+      let message = "Unhandled Rejection";
+      const payload = {};
+      const reason = event.reason;
+      if (reason instanceof Error) {
+        message = reason.message || message;
+        payload.stack = reason.stack;
+        payload.errorType = reason.name;
+      } else if (typeof reason === "string") {
+        message = reason;
+      } else if (reason !== void 0 && reason !== null) {
+        try {
+          message = JSON.stringify(reason);
+        } catch (e) {
+          message = String(reason);
+        }
+      }
+      logger.log("Captured unhandled rejection:", message);
+      callback("error", message, payload);
+      if (typeof originalOnUnhandledRejection === "function") {
+        originalOnUnhandledRejection.call(window, event);
+      }
+    };
+  }
+  isSetup = true;
+  logger.log("Error handlers set up");
+}
+function teardownErrorHandlers() {
+  const logger = getLogger();
+  if (!isBrowser()) {
+    return;
+  }
+  if (originalOnError !== void 0) {
+    window.onerror = originalOnError;
+  }
+  if (originalOnUnhandledRejection !== void 0) {
+    window.onunhandledrejection = originalOnUnhandledRejection;
+  }
+  originalOnError = null;
+  originalOnUnhandledRejection = null;
+  isSetup = false;
+  logger.log("Error handlers torn down");
+}
+
+// src/widget/types.ts
+var DEFAULT_WIDGET_CONFIG = {
+  enabled: false,
+  theme: {
+    primary: "#6366f1",
+    background: "#ffffff",
+    text: "#1f2937",
+    accent: "#10b981"
+  },
+  messages: {
+    greeting: "Opa! Algo n\xE3o saiu como esperado.",
+    subtext: "Pode nos ajudar a entender o que aconteceu?",
+    thankYou: "Valeu! J\xE1 estamos olhando isso.",
+    buttonSend: "Enviar",
+    buttonSkip: "Agora n\xE3o"
+  },
+  position: "bottom-right",
+  delay: 2e3,
+  maxShowsPerSession: 2,
+  cooldownMinutes: 30
+};
+
+// src/widget/Avatar.ts
+var Avatar = class {
+  constructor(theme, onClick) {
+    this.element = null;
+    this.pupilLeft = null;
+    this.pupilRight = null;
+    this.mouseTrackingEnabled = true;
+    this.theme = theme;
+    this.onClick = onClick;
+    this.handleMouseMove = this.handleMouseMove.bind(this);
+  }
+  create() {
+    const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    svg.setAttribute("viewBox", "0 0 100 100");
+    svg.setAttribute("class", "blinker-avatar");
+    svg.innerHTML = this.getSVGContent();
+    svg.addEventListener("click", this.onClick);
+    svg.addEventListener("mouseenter", () => this.setState("hover"));
+    svg.addEventListener("mouseleave", () => this.setState("idle"));
+    this.element = svg;
+    this.pupilLeft = svg.querySelector(".blinker-pupil-left");
+    this.pupilRight = svg.querySelector(".blinker-pupil-right");
+    document.addEventListener("mousemove", this.handleMouseMove);
+    return svg;
+  }
+  getSVGContent() {
+    return `
+      <defs>
+        <linearGradient id="blinker-body-gradient" x1="0%" y1="0%" x2="0%" y2="100%">
+          <stop offset="0%" style="stop-color:${this.theme.primary};stop-opacity:1" />
+          <stop offset="100%" style="stop-color:${this.adjustColor(this.theme.primary, -30)};stop-opacity:1" />
+        </linearGradient>
+        <filter id="blinker-shadow" x="-20%" y="-20%" width="140%" height="140%">
+          <feDropShadow dx="0" dy="4" stdDeviation="4" flood-opacity="0.2"/>
+        </filter>
+      </defs>
+
+      <!-- Glow effect -->
+      <ellipse class="blinker-avatar-glow" cx="50" cy="85" rx="25" ry="8" />
+
+      <!-- Body -->
+      <g class="blinker-avatar-body" filter="url(#blinker-shadow)">
+        <!-- Main body shape - rounded rectangle with personality -->
+        <path d="
+          M 25 30
+          Q 25 15, 50 15
+          Q 75 15, 75 30
+          L 75 65
+          Q 75 85, 50 85
+          Q 25 85, 25 65
+          Z
+        " fill="url(#blinker-body-gradient)" />
+
+        <!-- Antenna/Top detail -->
+        <circle cx="50" cy="12" r="4" fill="${this.theme.primary}" />
+        <line x1="50" y1="16" x2="50" y2="22" stroke="${this.theme.primary}" stroke-width="3" stroke-linecap="round" />
+      </g>
+
+      <!-- Face -->
+      <g class="blinker-avatar-face">
+        <!-- Left eye container -->
+        <ellipse class="blinker-avatar-eye blinker-avatar-eye-left" cx="38" cy="42" rx="10" ry="11" />
+        <!-- Right eye container -->
+        <ellipse class="blinker-avatar-eye blinker-avatar-eye-right" cx="62" cy="42" rx="10" ry="11" />
+
+        <!-- Left pupil -->
+        <circle class="blinker-avatar-pupil blinker-pupil-left" cx="38" cy="43" r="5" />
+        <!-- Right pupil -->
+        <circle class="blinker-avatar-pupil blinker-pupil-right" cx="62" cy="43" r="5" />
+
+        <!-- Eye shine -->
+        <circle cx="35" cy="40" r="2" fill="white" opacity="0.8" />
+        <circle cx="59" cy="40" r="2" fill="white" opacity="0.8" />
+
+        <!-- Mouth -->
+        <path class="blinker-avatar-mouth" d="M 40 60 Q 50 68, 60 60" />
+      </g>
+
+      <!-- Decorative elements -->
+      <circle cx="30" cy="55" r="3" fill="${this.theme.primary}" opacity="0.3" />
+      <circle cx="70" cy="55" r="3" fill="${this.theme.primary}" opacity="0.3" />
+    `;
+  }
+  handleMouseMove(e) {
+    if (!this.mouseTrackingEnabled || !this.element || !this.pupilLeft || !this.pupilRight) return;
+    const rect = this.element.getBoundingClientRect();
+    const centerX = rect.left + rect.width / 2;
+    const centerY = rect.top + rect.height / 2;
+    const deltaX = (e.clientX - centerX) / 50;
+    const deltaY = (e.clientY - centerY) / 50;
+    const maxOffset = 3;
+    const offsetX = Math.max(-maxOffset, Math.min(maxOffset, deltaX));
+    const offsetY = Math.max(-maxOffset, Math.min(maxOffset, deltaY));
+    this.pupilLeft.setAttribute("transform", `translate(${offsetX}, ${offsetY})`);
+    this.pupilRight.setAttribute("transform", `translate(${offsetX}, ${offsetY})`);
+  }
+  setState(state) {
+    if (!this.element) return;
+    this.element.classList.remove("idle", "hover", "minimized", "talking");
+    this.element.classList.add(state);
+  }
+  setMinimized(minimized) {
+    if (!this.element) return;
+    if (minimized) {
+      this.element.classList.add("minimized");
+      this.mouseTrackingEnabled = false;
+    } else {
+      this.element.classList.remove("minimized");
+      this.mouseTrackingEnabled = true;
+    }
+  }
+  updateTheme(theme) {
+    this.theme = theme;
+    if (this.element) {
+      this.element.innerHTML = this.getSVGContent();
+      this.pupilLeft = this.element.querySelector(".blinker-pupil-left");
+      this.pupilRight = this.element.querySelector(".blinker-pupil-right");
+    }
+  }
+  adjustColor(hex, amount) {
+    const num = parseInt(hex.replace("#", ""), 16);
+    const r = Math.max(0, Math.min(255, (num >> 16) + amount));
+    const g = Math.max(0, Math.min(255, (num >> 8 & 255) + amount));
+    const b = Math.max(0, Math.min(255, (num & 255) + amount));
+    return `#${(r << 16 | g << 8 | b).toString(16).padStart(6, "0")}`;
+  }
+  getElement() {
+    return this.element;
+  }
+  destroy() {
+    document.removeEventListener("mousemove", this.handleMouseMove);
+    if (this.element) {
+      this.element.removeEventListener("click", this.onClick);
+      this.element.remove();
+      this.element = null;
+    }
+  }
+};
+
+// src/widget/Dialog.ts
+var Dialog = class {
+  constructor(config, onSubmit, onClose) {
+    this.overlay = null;
+    this.dialog = null;
+    this.questions = [];
+    this.answers = {};
+    this.errorId = "";
+    this.state = "questions";
+    this.config = config;
+    this.onSubmit = onSubmit;
+    this.onClose = onClose;
+  }
+  open(errorId, questions) {
+    this.errorId = errorId;
+    this.questions = questions;
+    this.answers = {};
+    this.state = "questions";
+    this.render();
+  }
+  close() {
+    if (this.overlay) {
+      this.overlay.remove();
+      this.overlay = null;
+    }
+    if (this.dialog) {
+      this.dialog.remove();
+      this.dialog = null;
+    }
+    this.onClose();
+  }
+  render() {
+    this.close();
+    this.overlay = document.createElement("div");
+    this.overlay.className = "blinker-dialog-overlay";
+    this.overlay.addEventListener("click", () => this.close());
+    this.dialog = document.createElement("div");
+    this.dialog.className = `blinker-dialog ${this.config.position}`;
+    this.dialog.innerHTML = this.state === "questions" ? this.getQuestionsHTML() : this.getThankYouHTML();
+    document.body.appendChild(this.overlay);
+    document.body.appendChild(this.dialog);
+    this.attachEventListeners();
+  }
+  getQuestionsHTML() {
+    const { messages } = this.config;
+    return `
+      <div class="blinker-dialog-header">
+        <svg class="blinker-dialog-avatar" viewBox="0 0 100 100">
+          <defs>
+            <linearGradient id="dialog-gradient" x1="0%" y1="0%" x2="0%" y2="100%">
+              <stop offset="0%" style="stop-color:${this.config.theme.primary}" />
+              <stop offset="100%" style="stop-color:${this.adjustColor(this.config.theme.primary, -30)}" />
+            </linearGradient>
+          </defs>
+          <path d="M 25 30 Q 25 15, 50 15 Q 75 15, 75 30 L 75 65 Q 75 85, 50 85 Q 25 85, 25 65 Z" fill="url(#dialog-gradient)" />
+          <ellipse cx="38" cy="42" rx="10" ry="11" fill="${this.config.theme.background}" />
+          <ellipse cx="62" cy="42" rx="10" ry="11" fill="${this.config.theme.background}" />
+          <circle cx="38" cy="43" r="5" fill="${this.config.theme.text}" />
+          <circle cx="62" cy="43" r="5" fill="${this.config.theme.text}" />
+          <path d="M 40 60 Q 50 68, 60 60" stroke="${this.config.theme.background}" stroke-width="2" fill="none" stroke-linecap="round" />
+        </svg>
+        <div class="blinker-dialog-title">
+          <p class="blinker-dialog-greeting">${messages.greeting}</p>
+          <p class="blinker-dialog-subtext">${messages.subtext}</p>
+        </div>
+        <button class="blinker-dialog-close" aria-label="Fechar">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M18 6L6 18M6 6l12 12" />
+          </svg>
+        </button>
+      </div>
+      <div class="blinker-dialog-body">
+        ${this.questions.map((q) => this.getQuestionHTML(q)).join("")}
+      </div>
+      <div class="blinker-dialog-footer">
+        <button class="blinker-btn blinker-btn-secondary" data-action="skip">
+          ${messages.buttonSkip}
+        </button>
+        <button class="blinker-btn blinker-btn-primary" data-action="submit">
+          ${messages.buttonSend}
+        </button>
+      </div>
+    `;
+  }
+  getQuestionHTML(question) {
+    var _a;
+    const required = question.required ? " *" : "";
+    switch (question.type) {
+      case "text":
+        return `
+          <div class="blinker-question" data-question-id="${question.id}">
+            <label class="blinker-question-label">${question.text}${required}</label>
+            <textarea
+              class="blinker-question-input blinker-question-textarea"
+              placeholder="Digite sua resposta..."
+              data-question-id="${question.id}"
+            ></textarea>
+          </div>
+        `;
+      case "select":
+        return `
+          <div class="blinker-question" data-question-id="${question.id}">
+            <label class="blinker-question-label">${question.text}${required}</label>
+            <select class="blinker-question-input blinker-question-select" data-question-id="${question.id}">
+              <option value="">Selecione...</option>
+              ${(_a = question.options) == null ? void 0 : _a.map((opt) => `<option value="${opt}">${opt}</option>`).join("")}
+            </select>
+          </div>
+        `;
+      case "boolean":
+        return `
+          <div class="blinker-question" data-question-id="${question.id}">
+            <label class="blinker-question-label">${question.text}${required}</label>
+            <div class="blinker-question-boolean">
+              <button type="button" data-question-id="${question.id}" data-value="true">Sim</button>
+              <button type="button" data-question-id="${question.id}" data-value="false">N\xE3o</button>
+            </div>
+          </div>
+        `;
+      default:
+        return "";
+    }
+  }
+  getThankYouHTML() {
+    return `
+      <div class="blinker-thank-you">
+        <svg class="blinker-thank-you-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14" />
+          <polyline points="22 4 12 14.01 9 11.01" />
+        </svg>
+        <p class="blinker-thank-you-text">${this.config.messages.thankYou}</p>
+      </div>
+    `;
+  }
+  attachEventListeners() {
+    if (!this.dialog) return;
+    const closeBtn = this.dialog.querySelector(".blinker-dialog-close");
+    closeBtn == null ? void 0 : closeBtn.addEventListener("click", () => this.close());
+    const submitBtn = this.dialog.querySelector('[data-action="submit"]');
+    submitBtn == null ? void 0 : submitBtn.addEventListener("click", () => this.handleSubmit());
+    const skipBtn = this.dialog.querySelector('[data-action="skip"]');
+    skipBtn == null ? void 0 : skipBtn.addEventListener("click", () => this.close());
+    const textareas = this.dialog.querySelectorAll("textarea");
+    textareas.forEach((textarea) => {
+      textarea.addEventListener("input", (e) => {
+        const target = e.target;
+        const questionId = target.dataset.questionId;
+        if (questionId) {
+          this.answers[questionId] = target.value;
+        }
+      });
+    });
+    const selects = this.dialog.querySelectorAll("select");
+    selects.forEach((select) => {
+      select.addEventListener("change", (e) => {
+        const target = e.target;
+        const questionId = target.dataset.questionId;
+        if (questionId) {
+          this.answers[questionId] = target.value;
+        }
+      });
+    });
+    const booleanBtns = this.dialog.querySelectorAll(".blinker-question-boolean button");
+    booleanBtns.forEach((btn) => {
+      btn.addEventListener("click", (e) => {
+        const target = e.target;
+        const questionId = target.dataset.questionId;
+        const value = target.dataset.value === "true";
+        if (questionId) {
+          this.answers[questionId] = value;
+          const container = target.parentElement;
+          container == null ? void 0 : container.querySelectorAll("button").forEach((b) => b.classList.remove("selected"));
+          target.classList.add("selected");
+        }
+      });
+    });
+  }
+  handleSubmit() {
+    var _a;
+    const requiredQuestions = this.questions.filter((q) => q.required);
+    const missingRequired = requiredQuestions.some((q) => {
+      const answer = this.answers[q.id];
+      return answer === void 0 || answer === "";
+    });
+    if (missingRequired) {
+      const firstRequired = requiredQuestions.find((q) => !this.answers[q.id]);
+      if (firstRequired) {
+        const input = (_a = this.dialog) == null ? void 0 : _a.querySelector(`[data-question-id="${firstRequired.id}"]`);
+        if (input instanceof HTMLElement) {
+          input.focus();
+          input.style.borderColor = "#ef4444";
+          setTimeout(() => {
+            input.style.borderColor = "";
+          }, 2e3);
+        }
+      }
+      return;
+    }
+    const feedback = {
+      errorId: this.errorId,
+      answers: { ...this.answers },
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.onSubmit(feedback);
+    this.state = "thankyou";
+    this.render();
+    setTimeout(() => {
+      this.close();
+    }, 2500);
+  }
+  updateConfig(config) {
+    this.config = config;
+  }
+  adjustColor(hex, amount) {
+    const num = parseInt(hex.replace("#", ""), 16);
+    const r = Math.max(0, Math.min(255, (num >> 16) + amount));
+    const g = Math.max(0, Math.min(255, (num >> 8 & 255) + amount));
+    const b = Math.max(0, Math.min(255, (num & 255) + amount));
+    return `#${(r << 16 | g << 8 | b).toString(16).padStart(6, "0")}`;
+  }
+  isOpen() {
+    return this.dialog !== null;
+  }
+};
+
+// src/widget/QuestionEngine.ts
+var BASE_QUESTIONS = [
+  {
+    id: "what_doing",
+    text: "O que voc\xEA estava tentando fazer?",
+    type: "text",
+    required: true
+  }
+];
+var QUESTION_RULES = [
+  {
+    id: "server_error",
+    condition: (e) => e.httpCode !== void 0 && e.httpCode >= 500,
+    priority: 10,
+    questions: [
+      {
+        id: "form_filled",
+        text: "Voc\xEA preencheu algum formul\xE1rio antes disso?",
+        type: "boolean"
+      },
+      {
+        id: "data_lost",
+        text: "Voc\xEA perdeu algum dado importante?",
+        type: "boolean"
+      }
+    ]
+  },
+  {
+    id: "network_error",
+    condition: (e) => e.message.toLowerCase().includes("network") || e.message.toLowerCase().includes("fetch") || e.message.toLowerCase().includes("failed to fetch") || e.errorType === "TypeError" && e.message.includes("fetch"),
+    priority: 9,
+    questions: [
+      {
+        id: "internet_working",
+        text: "Sua internet est\xE1 funcionando normalmente?",
+        type: "boolean"
+      },
+      {
+        id: "using_vpn",
+        text: "Voc\xEA est\xE1 usando VPN ou proxy?",
+        type: "boolean"
+      }
+    ]
+  },
+  {
+    id: "timeout_error",
+    condition: (e) => e.message.toLowerCase().includes("timeout") || e.message.toLowerCase().includes("timed out"),
+    priority: 8,
+    questions: [
+      {
+        id: "page_slow",
+        text: "A p\xE1gina estava lenta antes do erro?",
+        type: "boolean"
+      },
+      {
+        id: "first_time",
+        text: "\xC9 a primeira vez que isso acontece?",
+        type: "boolean"
+      }
+    ]
+  },
+  {
+    id: "auth_error",
+    condition: (e) => e.httpCode === 401 || e.httpCode === 403 || e.message.toLowerCase().includes("unauthorized") || e.message.toLowerCase().includes("forbidden"),
+    priority: 7,
+    questions: [
+      {
+        id: "logged_in",
+        text: "Voc\xEA estava logado no sistema?",
+        type: "boolean"
+      },
+      {
+        id: "session_expired",
+        text: "Ficou muito tempo sem usar o sistema?",
+        type: "boolean"
+      }
+    ]
+  },
+  {
+    id: "not_found",
+    condition: (e) => e.httpCode === 404,
+    priority: 6,
+    questions: [
+      {
+        id: "how_arrived",
+        text: "Como voc\xEA chegou nessa p\xE1gina?",
+        type: "select",
+        options: ["Digitei o link", "Cliquei em um bot\xE3o", "Usei o menu", "Outro"]
+      }
+    ]
+  },
+  {
+    id: "validation_error",
+    condition: (e) => e.httpCode === 400 || e.httpCode === 422 || e.message.toLowerCase().includes("validation") || e.message.toLowerCase().includes("invalid"),
+    priority: 5,
+    questions: [
+      {
+        id: "what_filled",
+        text: "O que voc\xEA preencheu no formul\xE1rio?",
+        type: "text"
+      },
+      {
+        id: "special_chars",
+        text: "Usou caracteres especiais ou emojis?",
+        type: "boolean"
+      }
+    ]
+  },
+  {
+    id: "ui_error",
+    condition: (e) => e.errorType === "TypeError" || e.message.toLowerCase().includes("undefined") || e.message.toLowerCase().includes("null"),
+    priority: 4,
+    questions: [
+      {
+        id: "clicked_what",
+        text: "Voc\xEA clicou em algo espec\xEDfico?",
+        type: "text"
+      },
+      {
+        id: "page_loaded",
+        text: "A p\xE1gina tinha carregado completamente?",
+        type: "boolean"
+      }
+    ]
+  },
+  {
+    id: "load_error",
+    condition: (e) => e.message.toLowerCase().includes("chunk") || e.message.toLowerCase().includes("loading") || e.message.toLowerCase().includes("script"),
+    priority: 3,
+    questions: [
+      {
+        id: "refreshed",
+        text: "Voc\xEA tentou atualizar a p\xE1gina?",
+        type: "boolean"
+      },
+      {
+        id: "browser",
+        text: "Qual navegador voc\xEA est\xE1 usando?",
+        type: "select",
+        options: ["Chrome", "Firefox", "Safari", "Edge", "Outro"]
+      }
+    ]
+  }
+];
+var FALLBACK_QUESTIONS = [
+  {
+    id: "happened_before",
+    text: "Isso j\xE1 aconteceu antes?",
+    type: "boolean"
+  },
+  {
+    id: "additional_info",
+    text: "Algo mais que possa nos ajudar?",
+    type: "text",
+    required: false
+  }
+];
+var QuestionEngine = class {
+  inferQuestions(message, payload) {
+    const context = {
+      message,
+      type: "error",
+      httpCode: payload == null ? void 0 : payload.httpCode,
+      errorType: payload == null ? void 0 : payload.errorType,
+      stack: payload == null ? void 0 : payload.stack
+    };
+    const matchedRules = QUESTION_RULES.filter((rule) => rule.condition(context)).sort((a, b) => b.priority - a.priority);
+    const questions = [...BASE_QUESTIONS];
+    const addedIds = new Set(questions.map((q) => q.id));
+    for (const rule of matchedRules.slice(0, 2)) {
+      for (const question of rule.questions) {
+        if (!addedIds.has(question.id)) {
+          questions.push(question);
+          addedIds.add(question.id);
+        }
+      }
+    }
+    if (questions.length < 3) {
+      for (const question of FALLBACK_QUESTIONS) {
+        if (!addedIds.has(question.id) && questions.length < 4) {
+          questions.push(question);
+          addedIds.add(question.id);
+        }
+      }
+    }
+    return questions.slice(0, 4);
+  }
+  shouldShowWidget(message, payload, backendDecision) {
+    if (backendDecision !== void 0) {
+      return backendDecision;
+    }
+    if ((payload == null ? void 0 : payload.httpCode) !== void 0) {
+      if (payload.httpCode >= 500) return true;
+      if (payload.httpCode === 400 || payload.httpCode === 422) return true;
+    }
+    const criticalPatterns = [
+      "unexpected",
+      "critical",
+      "fatal",
+      "crash",
+      "failed to",
+      "cannot read",
+      "cannot access",
+      "undefined is not",
+      "null is not"
+    ];
+    const lowerMessage = message.toLowerCase();
+    return criticalPatterns.some((pattern) => lowerMessage.includes(pattern));
+  }
+};
+
+// src/widget/styles.ts
+function injectStyles(theme) {
+  if (document.getElementById("blinker-widget-styles")) return;
+  const styles = document.createElement("style");
+  styles.id = "blinker-widget-styles";
+  styles.textContent = getStyles(theme);
+  document.head.appendChild(styles);
+}
+function removeStyles() {
+  const styles = document.getElementById("blinker-widget-styles");
+  if (styles) styles.remove();
+}
+function updateStyles(theme) {
+  const styles = document.getElementById("blinker-widget-styles");
+  if (styles) {
+    styles.textContent = getStyles(theme);
+  }
+}
+function getStyles(theme) {
+  return `
+    @keyframes blinker-breathe {
+      0%, 100% { transform: scale(1); }
+      50% { transform: scale(1.05); }
+    }
+
+    @keyframes blinker-pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.7; }
+    }
+
+    @keyframes blinker-float {
+      0%, 100% { transform: translateY(0); }
+      50% { transform: translateY(-5px); }
+    }
+
+    @keyframes blinker-fade-in {
+      from { opacity: 0; transform: scale(0.8) translateY(20px); }
+      to { opacity: 1; transform: scale(1) translateY(0); }
+    }
+
+    @keyframes blinker-fade-out {
+      from { opacity: 1; transform: scale(1) translateY(0); }
+      to { opacity: 0; transform: scale(0.8) translateY(20px); }
+    }
+
+    @keyframes blinker-slide-up {
+      from { opacity: 0; transform: translateY(30px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+
+    @keyframes blinker-eye-blink {
+      0%, 45%, 55%, 100% { transform: scaleY(1); }
+      50% { transform: scaleY(0.1); }
+    }
+
+    @keyframes blinker-glow {
+      0%, 100% { filter: drop-shadow(0 0 8px ${theme.primary}40); }
+      50% { filter: drop-shadow(0 0 15px ${theme.primary}60); }
+    }
+
+    .blinker-widget-container {
+      position: fixed;
+      z-index: 999999;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    }
+
+    .blinker-widget-container.bottom-right {
+      bottom: 20px;
+      right: 20px;
+    }
+
+    .blinker-widget-container.bottom-left {
+      bottom: 20px;
+      left: 20px;
+    }
+
+    .blinker-avatar {
+      width: 60px;
+      height: 60px;
+      cursor: pointer;
+      animation: blinker-float 3s ease-in-out infinite, blinker-glow 2s ease-in-out infinite;
+      transition: transform 0.3s ease;
+    }
+
+    .blinker-avatar:hover {
+      transform: scale(1.1);
+    }
+
+    .blinker-avatar.minimized {
+      width: 40px;
+      height: 40px;
+    }
+
+    .blinker-avatar-body {
+      fill: ${theme.primary};
+      animation: blinker-breathe 4s ease-in-out infinite;
+      transform-origin: center;
+    }
+
+    .blinker-avatar-eye {
+      fill: ${theme.background};
+      animation: blinker-eye-blink 4s ease-in-out infinite;
+      transform-origin: center;
+    }
+
+    .blinker-avatar-eye-left {
+      animation-delay: 0.1s;
+    }
+
+    .blinker-avatar-pupil {
+      fill: ${theme.text};
+      transition: transform 0.1s ease;
+    }
+
+    .blinker-avatar-mouth {
+      stroke: ${theme.background};
+      stroke-width: 2;
+      fill: none;
+      stroke-linecap: round;
+    }
+
+    .blinker-avatar-glow {
+      fill: ${theme.primary};
+      opacity: 0.3;
+      animation: blinker-pulse 2s ease-in-out infinite;
+    }
+
+    .blinker-dialog-overlay {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0, 0, 0, 0.3);
+      z-index: 999998;
+      animation: blinker-fade-in 0.3s ease;
+    }
+
+    .blinker-dialog {
+      position: fixed;
+      z-index: 999999;
+      width: 340px;
+      max-width: calc(100vw - 40px);
+      background: ${theme.background};
+      border-radius: 16px;
+      box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+      animation: blinker-slide-up 0.4s ease;
+      overflow: hidden;
     }
-  }
-  return result;
+
+    .blinker-dialog.bottom-right {
+      bottom: 90px;
+      right: 20px;
+    }
+
+    .blinker-dialog.bottom-left {
+      bottom: 90px;
+      left: 20px;
+    }
+
+    .blinker-dialog-header {
+      padding: 20px 20px 0;
+      display: flex;
+      align-items: flex-start;
+      gap: 12px;
+    }
+
+    .blinker-dialog-avatar {
+      width: 40px;
+      height: 40px;
+      flex-shrink: 0;
+    }
+
+    .blinker-dialog-title {
+      flex: 1;
+    }
+
+    .blinker-dialog-greeting {
+      font-size: 16px;
+      font-weight: 600;
+      color: ${theme.text};
+      margin: 0 0 4px;
+    }
+
+    .blinker-dialog-subtext {
+      font-size: 13px;
+      color: ${theme.text}99;
+      margin: 0;
+    }
+
+    .blinker-dialog-close {
+      background: none;
+      border: none;
+      padding: 4px;
+      cursor: pointer;
+      color: ${theme.text}66;
+      border-radius: 6px;
+      transition: all 0.2s;
+    }
+
+    .blinker-dialog-close:hover {
+      background: ${theme.text}10;
+      color: ${theme.text};
+    }
+
+    .blinker-dialog-body {
+      padding: 20px;
+    }
+
+    .blinker-question {
+      margin-bottom: 16px;
+    }
+
+    .blinker-question:last-child {
+      margin-bottom: 0;
+    }
+
+    .blinker-question-label {
+      display: block;
+      font-size: 14px;
+      font-weight: 500;
+      color: ${theme.text};
+      margin-bottom: 8px;
+    }
+
+    .blinker-question-input {
+      width: 100%;
+      padding: 10px 12px;
+      border: 1px solid ${theme.text}20;
+      border-radius: 8px;
+      font-size: 14px;
+      color: ${theme.text};
+      background: ${theme.background};
+      transition: border-color 0.2s, box-shadow 0.2s;
+      box-sizing: border-box;
+    }
+
+    .blinker-question-input:focus {
+      outline: none;
+      border-color: ${theme.primary};
+      box-shadow: 0 0 0 3px ${theme.primary}20;
+    }
+
+    .blinker-question-input::placeholder {
+      color: ${theme.text}50;
+    }
+
+    .blinker-question-textarea {
+      resize: vertical;
+      min-height: 80px;
+    }
+
+    .blinker-question-select {
+      appearance: none;
+      background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23666' d='M6 8L1 3h10z'/%3E%3C/svg%3E");
+      background-repeat: no-repeat;
+      background-position: right 12px center;
+      padding-right: 36px;
+    }
+
+    .blinker-question-boolean {
+      display: flex;
+      gap: 8px;
+    }
+
+    .blinker-question-boolean button {
+      flex: 1;
+      padding: 10px;
+      border: 1px solid ${theme.text}20;
+      border-radius: 8px;
+      background: ${theme.background};
+      color: ${theme.text};
+      font-size: 14px;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+
+    .blinker-question-boolean button:hover {
+      border-color: ${theme.primary};
+    }
+
+    .blinker-question-boolean button.selected {
+      background: ${theme.primary};
+      border-color: ${theme.primary};
+      color: white;
+    }
+
+    .blinker-dialog-footer {
+      padding: 16px 20px 20px;
+      display: flex;
+      gap: 8px;
+    }
+
+    .blinker-btn {
+      flex: 1;
+      padding: 12px 16px;
+      border-radius: 8px;
+      font-size: 14px;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.2s;
+      border: none;
+    }
+
+    .blinker-btn-primary {
+      background: ${theme.accent};
+      color: white;
+    }
+
+    .blinker-btn-primary:hover {
+      filter: brightness(1.1);
+    }
+
+    .blinker-btn-primary:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+
+    .blinker-btn-secondary {
+      background: ${theme.text}10;
+      color: ${theme.text}99;
+    }
+
+    .blinker-btn-secondary:hover {
+      background: ${theme.text}20;
+    }
+
+    .blinker-thank-you {
+      text-align: center;
+      padding: 40px 20px;
+    }
+
+    .blinker-thank-you-icon {
+      width: 48px;
+      height: 48px;
+      margin: 0 auto 16px;
+      color: ${theme.accent};
+    }
+
+    .blinker-thank-you-text {
+      font-size: 16px;
+      color: ${theme.text};
+      margin: 0;
+    }
+  `;
 }
 
-// src/errorHandler.ts
-var originalOnError = null;
-var originalOnUnhandledRejection = null;
-var isSetup = false;
-function setupErrorHandlers(callback, options = {}) {
-  const { captureErrors = true, captureRejections = true, debug = false } = options;
-  if (isSetup) {
-    if (debug) {
-      console.warn("[Blinker] Error handlers already set up");
+// src/widget/Widget.ts
+var STORAGE_KEY = "blinker_widget_state";
+var Widget = class {
+  constructor(config) {
+    this.container = null;
+    this.avatar = null;
+    this.dialog = null;
+    this.onFeedbackSubmit = null;
+    this.config = { ...DEFAULT_WIDGET_CONFIG, ...config };
+    this.state = this.loadState();
+    this.questionEngine = new QuestionEngine();
+  }
+  init(onFeedbackSubmit) {
+    if (!this.config.enabled) return;
+    if (typeof document === "undefined") return;
+    this.onFeedbackSubmit = onFeedbackSubmit || null;
+    injectStyles(this.config.theme);
+    this.createContainer();
+  }
+  createContainer() {
+    if (this.container) return;
+    this.container = document.createElement("div");
+    this.container.className = `blinker-widget-container ${this.config.position}`;
+    document.body.appendChild(this.container);
+    this.avatar = new Avatar(this.config.theme, () => this.handleAvatarClick());
+    const avatarElement = this.avatar.create();
+    this.container.appendChild(avatarElement);
+    this.dialog = new Dialog(
+      this.config,
+      (feedback) => this.handleFeedbackSubmit(feedback),
+      () => this.handleDialogClose()
+    );
+    this.hide();
+  }
+  show(errorId, message, payload, backendDecision) {
+    if (!this.config.enabled) return;
+    if (!this.container || !this.avatar) return;
+    const shouldShow = this.questionEngine.shouldShowWidget(message, payload, backendDecision);
+    if (!shouldShow) return;
+    if (!this.canShowWidget()) return;
+    const questions = this.questionEngine.inferQuestions(message, payload);
+    this.state.currentErrorId = errorId;
+    this.state.questions = questions;
+    this.state.isVisible = true;
+    this.state.showCount++;
+    this.state.lastShowTime = Date.now();
+    this.saveState();
+    this.container.style.display = "block";
+    this.avatar.setMinimized(false);
+  }
+  hide() {
+    if (!this.container) return;
+    this.state.isVisible = false;
+    this.state.isDialogOpen = false;
+    this.container.style.display = "none";
+  }
+  handleAvatarClick() {
+    var _a;
+    if (!this.dialog || !this.state.currentErrorId) return;
+    if (this.state.isDialogOpen) {
+      this.dialog.close();
+    } else {
+      this.state.isDialogOpen = true;
+      this.dialog.open(this.state.currentErrorId, this.state.questions);
+      (_a = this.avatar) == null ? void 0 : _a.setMinimized(true);
     }
-    return;
   }
-  if (typeof window === "undefined") {
-    if (debug) {
-      console.log("[Blinker] Not in browser environment, skipping error handlers");
+  handleFeedbackSubmit(feedback) {
+    if (this.onFeedbackSubmit) {
+      this.onFeedbackSubmit(feedback);
     }
-    return;
   }
-  if (captureErrors) {
-    originalOnError = window.onerror;
-    window.onerror = function(message, source, lineno, colno, error) {
-      const errorMessage = typeof message === "string" ? message : message.type || "Unknown error";
-      const payload = {
-        source,
-        lineno,
-        colno,
-        stack: error == null ? void 0 : error.stack,
-        errorType: error == null ? void 0 : error.name
-      };
-      if (debug) {
-        console.log("[Blinker] Captured error:", errorMessage);
-      }
-      callback("error", errorMessage, payload);
-      if (typeof originalOnError === "function") {
-        return originalOnError.call(window, message, source, lineno, colno, error);
-      }
-      return false;
-    };
+  handleDialogClose() {
+    var _a;
+    this.state.isDialogOpen = false;
+    (_a = this.avatar) == null ? void 0 : _a.setMinimized(false);
+    setTimeout(() => {
+      this.hide();
+    }, 500);
   }
-  if (captureRejections) {
-    originalOnUnhandledRejection = window.onunhandledrejection;
-    window.onunhandledrejection = function(event) {
-      let message = "Unhandled Rejection";
-      const payload = {};
-      const reason = event.reason;
-      if (reason instanceof Error) {
-        message = reason.message || message;
-        payload.stack = reason.stack;
-        payload.errorType = reason.name;
-      } else if (typeof reason === "string") {
-        message = reason;
-      } else if (reason !== void 0 && reason !== null) {
-        try {
-          message = JSON.stringify(reason);
-        } catch (e) {
-          message = String(reason);
-        }
-      }
-      if (debug) {
-        console.log("[Blinker] Captured unhandled rejection:", message);
-      }
-      callback("error", message, payload);
-      if (typeof originalOnUnhandledRejection === "function") {
-        originalOnUnhandledRejection.call(window, event);
+  canShowWidget() {
+    if (this.state.showCount >= this.config.maxShowsPerSession) {
+      return false;
+    }
+    if (this.state.lastShowTime) {
+      const cooldownMs = this.config.cooldownMinutes * 60 * 1e3;
+      const timeSinceLastShow = Date.now() - this.state.lastShowTime;
+      if (timeSinceLastShow < cooldownMs) {
+        return false;
       }
+    }
+    return true;
+  }
+  loadState() {
+    const defaultState = {
+      isVisible: false,
+      isMinimized: false,
+      isDialogOpen: false,
+      currentErrorId: null,
+      questions: [],
+      showCount: 0,
+      lastShowTime: null
     };
+    if (typeof sessionStorage === "undefined") return defaultState;
+    try {
+      const stored = sessionStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        return {
+          ...defaultState,
+          showCount: parsed.showCount || 0,
+          lastShowTime: parsed.lastShowTime || null
+        };
+      }
+    } catch (e) {
+    }
+    return defaultState;
   }
-  isSetup = true;
-}
-function teardownErrorHandlers() {
-  if (typeof window === "undefined") {
-    return;
+  saveState() {
+    if (typeof sessionStorage === "undefined") return;
+    try {
+      sessionStorage.setItem(STORAGE_KEY, JSON.stringify({
+        showCount: this.state.showCount,
+        lastShowTime: this.state.lastShowTime
+      }));
+    } catch (e) {
+    }
   }
-  if (originalOnError !== void 0) {
-    window.onerror = originalOnError;
+  updateConfig(config) {
+    var _a, _b;
+    this.config = { ...this.config, ...config };
+    if (config.theme) {
+      updateStyles(this.config.theme);
+      (_a = this.avatar) == null ? void 0 : _a.updateTheme(this.config.theme);
+    }
+    (_b = this.dialog) == null ? void 0 : _b.updateConfig(this.config);
   }
-  if (originalOnUnhandledRejection !== void 0) {
-    window.onunhandledrejection = originalOnUnhandledRejection;
+  getConfig() {
+    return { ...this.config };
+  }
+  isVisible() {
+    return this.state.isVisible;
+  }
+  isDialogOpen() {
+    return this.state.isDialogOpen;
+  }
+  destroy() {
+    var _a, _b;
+    (_a = this.avatar) == null ? void 0 : _a.destroy();
+    (_b = this.dialog) == null ? void 0 : _b.close();
+    if (this.container) {
+      this.container.remove();
+      this.container = null;
+    }
+    removeStyles();
+    this.avatar = null;
+    this.dialog = null;
   }
-  originalOnError = null;
-  originalOnUnhandledRejection = null;
-  isSetup = false;
-}
-
-// src/Blinker.ts
-var BLINKER_API = "https://api.blinker.live";
-var DEFAULT_FILTERS = {
-  // Auth/permission errors are usually expected behavior, not bugs
-  ignoreHttpCodes: [401, 403],
-  // All JS error types are captured by default
-  ignoreErrorTypes: [],
-  // Common benign browser errors that aren't actionable
-  ignoreMessagePatterns: [
-    "ResizeObserver loop",
-    // Common benign browser error
-    "Script error",
-    // Cross-origin script errors (no useful info)
-    "ResizeObserver loop completed"
-    // Another variant of ResizeObserver
-  ],
-  // By default, respect the filters
-  captureAll: false
 };
+
+// src/core/Blinker.ts
 var Blinker = class {
   constructor() {
     this.config = null;
     this.initialized = false;
-    this.filters = { ...DEFAULT_FILTERS };
+    this.filterEngine = null;
+    this.queue = null;
+    this.sessionManager = null;
+    this.userContext = null;
+    this.rateLimiter = null;
+    this.sampler = null;
+    this.deduplicator = null;
+    this.widget = null;
+  }
+  get version() {
+    return SDK_VERSION;
   }
-  /**
-   * Initialize the Blinker SDK
-   * @param config Configuration options
-   */
   init(config) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d;
     if (this.initialized) {
-      if (config.debug) {
-        console.warn("[Blinker] SDK already initialized");
-      }
+      const logger2 = getLogger();
+      logger2.warn("SDK already initialized");
       return;
     }
     if (!config.token) {
       throw new Error("[Blinker] Token is required");
     }
+    const enabled = (_a = config.enabled) != null ? _a : DEFAULTS.enabled;
+    if (!enabled) {
+      setGlobalLogger((_b = config.debug) != null ? _b : false);
+      const logger2 = getLogger();
+      logger2.log("SDK disabled via config");
+      this.config = { ...DEFAULTS, ...config };
+      return;
+    }
     this.config = {
-      captureErrors: true,
-      captureRejections: true,
-      debug: false,
+      ...DEFAULTS,
       ...config
     };
-    this.filters = {
-      ignoreHttpCodes: (_b = (_a = config.filters) == null ? void 0 : _a.ignoreHttpCodes) != null ? _b : DEFAULT_FILTERS.ignoreHttpCodes,
-      ignoreErrorTypes: (_d = (_c = config.filters) == null ? void 0 : _c.ignoreErrorTypes) != null ? _d : DEFAULT_FILTERS.ignoreErrorTypes,
-      ignoreMessagePatterns: (_f = (_e = config.filters) == null ? void 0 : _e.ignoreMessagePatterns) != null ? _f : DEFAULT_FILTERS.ignoreMessagePatterns,
-      captureAll: (_h = (_g = config.filters) == null ? void 0 : _g.captureAll) != null ? _h : DEFAULT_FILTERS.captureAll
-    };
-    if (this.config.debug) {
-      console.log("[Blinker] Filters configured:", this.filters);
-    }
+    setGlobalLogger((_c = this.config.debug) != null ? _c : false);
+    const logger = getLogger();
+    this.filterEngine = new FilterEngine(config.filters);
+    logger.log("Filter engine initialized");
+    this.queue = new EventQueue(config.token, {
+      endpoint: this.config.endpoint,
+      enableBatching: this.config.enableBatching,
+      batchSize: this.config.batchSize,
+      flushInterval: this.config.flushInterval,
+      enableOfflineStorage: this.config.enableOfflineStorage,
+      maxStoredEvents: this.config.maxStoredEvents,
+      onError: this.config.onError
+    });
+    logger.log("Event queue initialized");
+    this.sessionManager = new SessionManager();
+    this.userContext = new UserContext(this.sessionManager);
+    logger.log("Context managers initialized");
+    this.rateLimiter = new RateLimiter(this.config.maxEventsPerMinute);
+    this.sampler = new Sampler(this.config.sampleRate);
+    logger.log("Sampling modules initialized");
+    this.deduplicator = new Deduplicator(
+      this.config.enableDeduplication,
+      this.config.deduplicationWindow
+    );
+    logger.log("Deduplicator initialized");
     if (this.config.captureErrors || this.config.captureRejections) {
       setupErrorHandlers(
-        (type, message, payload) => {
-          var _a2;
-          if (this.shouldCapture(message, payload == null ? void 0 : payload.errorType)) {
-            this.track(type, message, payload);
-          } else if ((_a2 = this.config) == null ? void 0 : _a2.debug) {
-            console.log("[Blinker] Error filtered out:", message);
-          }
-        },
+        (type, message, payload) => this.handleCapturedError(type, message, payload),
         {
           captureErrors: this.config.captureErrors,
-          captureRejections: this.config.captureRejections,
-          debug: this.config.debug
+          captureRejections: this.config.captureRejections
         }
       );
+      logger.log("Error handlers set up");
     }
-    this.initialized = true;
-    if (this.config.debug) {
-      console.log("[Blinker] SDK initialized successfully");
+    if ((_d = this.config.widget) == null ? void 0 : _d.enabled) {
+      this.widget = new Widget(this.config.widget);
+      this.widget.init((feedback) => this.handleWidgetFeedback(feedback));
+      logger.log("Widget initialized");
     }
+    this.initialized = true;
+    logger.log("SDK initialized successfully");
   }
-  /**
-   * Check if an error should be captured based on filter settings
-   * @param message Error message
-   * @param errorType Optional JS error type (e.g., 'TypeError')
-   * @param httpCode Optional HTTP status code
-   * @returns true if the error should be captured, false if filtered out
-   */
-  shouldCapture(message, errorType, httpCode) {
-    if (this.filters.captureAll) {
-      return true;
-    }
-    if (httpCode !== void 0 && this.filters.ignoreHttpCodes.includes(httpCode)) {
-      return false;
-    }
-    if (errorType && this.filters.ignoreErrorTypes.includes(errorType)) {
-      return false;
+  handleCapturedError(type, message, payload) {
+    var _a, _b, _c, _d, _e;
+    if (!((_a = this.filterEngine) == null ? void 0 : _a.shouldCapture(message, payload.errorType, payload.httpCode))) {
+      return;
     }
-    for (const pattern of this.filters.ignoreMessagePatterns) {
-      if (message.toLowerCase().includes(pattern.toLowerCase())) {
-        return false;
-      }
+    const dedupResult = (_b = this.deduplicator) == null ? void 0 : _b.check(message, payload.stack);
+    if (dedupResult && !dedupResult.shouldSend) {
+      return;
     }
-    if (httpCode === void 0) {
-      const httpCodeMatch = message.match(/(?:HTTP\s*|status[:\s]*)?(\d{3})(?:\s|$|:)/i);
-      if (httpCodeMatch) {
-        const extractedCode = parseInt(httpCodeMatch[1], 10);
-        if (extractedCode >= 100 && extractedCode < 600) {
-          if (this.filters.ignoreHttpCodes.includes(extractedCode)) {
-            return false;
-          }
-        }
-      }
+    const errorId = generateUniqueId();
+    this.track(type, message, {
+      ...payload,
+      errorId,
+      count: dedupResult == null ? void 0 : dedupResult.count
+    });
+    if (this.widget && ((_d = (_c = this.config) == null ? void 0 : _c.widget) == null ? void 0 : _d.enabled)) {
+      setTimeout(() => {
+        var _a2;
+        (_a2 = this.widget) == null ? void 0 : _a2.show(errorId, message, payload);
+      }, (_e = this.config.widget.delay) != null ? _e : 2e3);
     }
-    return true;
   }
-  /**
-   * Track a custom event
-   * @param type Event type (e.g., 'click', 'pageview', 'custom')
-   * @param message Event message or description
-   * @param payload Optional additional data
-   */
+  handleWidgetFeedback(feedback) {
+    const logger = getLogger();
+    logger.log("Widget feedback received:", feedback.errorId);
+    this.track("feedback", "User feedback submitted", {
+      errorId: feedback.errorId,
+      answers: feedback.answers,
+      submittedAt: feedback.submittedAt
+    });
+  }
   track(type, message, payload) {
-    var _a;
-    if (!this.initialized || !this.config) {
-      if ((_a = this.config) == null ? void 0 : _a.debug) {
-        console.warn("[Blinker] SDK not initialized. Call blinker.init() first.");
-      }
+    var _a, _b, _c;
+    if (!this.config) {
       return Promise.resolve({ success: false, error: "SDK not initialized" });
     }
-    const event = {
+    if (!this.config.enabled) {
+      return Promise.resolve({ success: true, error: "SDK disabled" });
+    }
+    if (!this.initialized) {
+      return Promise.resolve({ success: false, error: "SDK not initialized" });
+    }
+    const logger = getLogger();
+    const isError = type === "error";
+    if (!((_a = this.rateLimiter) == null ? void 0 : _a.allow())) {
+      logger.log("Event dropped due to rate limit");
+      return Promise.resolve({ success: false, error: "Rate limited" });
+    }
+    if (!((_b = this.sampler) == null ? void 0 : _b.shouldSample(isError))) {
+      return Promise.resolve({ success: true, error: "Sampled out" });
+    }
+    const context = (_c = this.userContext) == null ? void 0 : _c.getEventContext();
+    let event = {
+      id: generateUniqueId(),
       type,
       message,
       payload,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      url: typeof window !== "undefined" ? window.location.href : void 0,
-      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+      url: getCurrentUrl(),
+      userAgent: getUserAgent(),
+      sessionId: context == null ? void 0 : context.sessionId,
+      userId: context == null ? void 0 : context.userId,
+      userTraits: context == null ? void 0 : context.userTraits,
+      context: context == null ? void 0 : context.custom
     };
-    return sendEvent(BLINKER_API, this.config.token, event, this.config.debug);
+    if (this.config.onBeforeSend) {
+      event = this.config.onBeforeSend(event);
+      if (!event) {
+        logger.log("Event filtered by onBeforeSend");
+        return Promise.resolve({ success: true, error: "Filtered by onBeforeSend" });
+      }
+    }
+    logger.log("Tracking event:", type, message.substring(0, 50));
+    return this.queue.add(event);
   }
-  /**
-   * Track an error manually
-   * @param error Error object or message
-   * @param additionalPayload Optional additional data (can include httpCode for filtering)
-   */
   captureError(error, additionalPayload) {
-    var _a;
+    var _a, _b;
     const message = error instanceof Error ? error.message : error;
     const errorType = error instanceof Error ? error.name : void 0;
+    const stack = error instanceof Error ? error.stack : void 0;
     const httpCode = additionalPayload == null ? void 0 : additionalPayload.httpCode;
-    if (!this.shouldCapture(message, errorType, httpCode)) {
-      if ((_a = this.config) == null ? void 0 : _a.debug) {
-        console.log("[Blinker] Error filtered out:", { message, errorType, httpCode });
-      }
-      return Promise.resolve({ success: true, error: "Filtered out by settings" });
+    if (!((_a = this.filterEngine) == null ? void 0 : _a.shouldCapture(message, errorType, httpCode))) {
+      return Promise.resolve({ success: true, error: "Filtered out" });
+    }
+    const dedupResult = (_b = this.deduplicator) == null ? void 0 : _b.check(message, stack);
+    if (dedupResult && !dedupResult.shouldSend) {
+      return Promise.resolve({ success: true, error: "Deduplicated" });
     }
     const payload = {
-      ...additionalPayload
+      ...additionalPayload,
+      errorType,
+      stack,
+      count: dedupResult == null ? void 0 : dedupResult.count
     };
-    if (error instanceof Error) {
-      payload.stack = error.stack;
-      payload.errorType = error.name;
-    }
     return this.track("error", message, payload);
   }
-  /**
-   * Track a page view
-   * @param pageName Optional page name (defaults to current URL path)
-   * @param additionalPayload Optional additional data
-   */
   trackPageView(pageName, additionalPayload) {
-    const page = pageName || (typeof window !== "undefined" ? window.location.pathname : "unknown");
+    var _a;
+    const page = pageName || getCurrentPath();
+    (_a = this.sessionManager) == null ? void 0 : _a.recordPageView();
     return this.track("pageview", page, {
       ...additionalPayload,
-      referrer: typeof document !== "undefined" ? document.referrer : void 0
+      referrer: getReferrer()
     });
   }
-  /**
-   * Check if SDK is initialized
-   */
+  identify(userId, traits) {
+    var _a;
+    (_a = this.userContext) == null ? void 0 : _a.identify(userId, traits);
+  }
+  setContext(key, value) {
+    var _a;
+    (_a = this.userContext) == null ? void 0 : _a.setContext(key, value);
+  }
+  getContext() {
+    var _a, _b;
+    return (_b = (_a = this.userContext) == null ? void 0 : _a.getCustomContext()) != null ? _b : {};
+  }
+  clearContext() {
+    var _a;
+    (_a = this.userContext) == null ? void 0 : _a.clearAll();
+  }
+  getSessionId() {
+    var _a, _b;
+    return (_b = (_a = this.sessionManager) == null ? void 0 : _a.getSessionId()) != null ? _b : "";
+  }
+  getSession() {
+    var _a, _b;
+    return (_b = (_a = this.sessionManager) == null ? void 0 : _a.getSession()) != null ? _b : null;
+  }
+  async flush() {
+    var _a;
+    await ((_a = this.queue) == null ? void 0 : _a.flush());
+  }
+  getQueueSize() {
+    var _a, _b;
+    return (_b = (_a = this.queue) == null ? void 0 : _a.size()) != null ? _b : 0;
+  }
   isInitialized() {
     return this.initialized;
   }
-  /**
-   * Get current configuration (without token for security)
-   */
   getConfig() {
     if (!this.config) return null;
     const { token: _token, ...safeConfig } = this.config;
     return safeConfig;
   }
-  /**
-   * Destroy the SDK instance
-   * Removes error handlers and resets state
-   */
-  destroy() {
+  getFilters() {
+    var _a, _b;
+    return (_b = (_a = this.filterEngine) == null ? void 0 : _a.getFilters()) != null ? _b : { ...DEFAULT_FILTERS };
+  }
+  showWidget(errorId, message, payload) {
+    var _a;
+    (_a = this.widget) == null ? void 0 : _a.show(errorId, message, payload);
+  }
+  hideWidget() {
+    var _a;
+    (_a = this.widget) == null ? void 0 : _a.hide();
+  }
+  getWidgetConfig() {
+    var _a, _b;
+    return (_b = (_a = this.widget) == null ? void 0 : _a.getConfig()) != null ? _b : null;
+  }
+  updateWidgetConfig(config) {
     var _a;
-    const wasDebug = (_a = this.config) == null ? void 0 : _a.debug;
+    (_a = this.widget) == null ? void 0 : _a.updateConfig(config);
+  }
+  isWidgetVisible() {
+    var _a, _b;
+    return (_b = (_a = this.widget) == null ? void 0 : _a.isVisible()) != null ? _b : false;
+  }
+  destroy() {
+    var _a, _b, _c, _d;
+    const logger = getLogger();
+    (_a = this.queue) == null ? void 0 : _a.destroy();
     teardownErrorHandlers();
+    (_b = this.deduplicator) == null ? void 0 : _b.destroy();
+    (_c = this.sessionManager) == null ? void 0 : _c.endSession();
+    (_d = this.widget) == null ? void 0 : _d.destroy();
     this.config = null;
     this.initialized = false;
-    this.filters = { ...DEFAULT_FILTERS };
-    if (wasDebug) {
-      console.log("[Blinker] SDK destroyed");
-    }
-  }
-  /**
-   * Get current filter settings
-   */
-  getFilters() {
-    return { ...this.filters };
+    this.filterEngine = null;
+    this.queue = null;
+    this.sessionManager = null;
+    this.userContext = null;
+    this.rateLimiter = null;
+    this.sampler = null;
+    this.deduplicator = null;
+    this.widget = null;
+    logger.log("SDK destroyed");
+    setGlobalLogger(false);
   }
 };
 
@@ -368,6 +2292,8 @@ var index_default = blinker;
 export {
   Blinker,
   DEFAULT_FILTERS,
+  DEFAULT_WIDGET_CONFIG,
+  SDK_VERSION,
   blinker,
   index_default as default
 };