@bidkernel/analytics 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -628,6 +628,11 @@ var MAX_QUEUE_SIZE = 200;
 var MAX_SEND_BACKOFF_MS = 5 * 60 * 1e3;
 var MAX_CONSECUTIVE_SEND_FAILURES = 10;
 var MAX_PAYLOAD_BYTES = 32 * 1024;
+var SAFE_CONTENT_TYPE = "text/plain";
+var PENDING_BATCH_KEY_PREFIX = "_bidkernel_pending_";
+var MAX_PENDING_BATCHES = 20;
+var PENDING_BATCH_MAX_AGE_MS = 2 * 60 * 60 * 1e3;
+var PENDING_BATCH_CLEANUP_DELAY_MS = 1e4;
 var EVENT_NAME_TO_TYPE = {
   auctionStart: TraceEventType.AUCTION_START,
   auctionEnd: TraceEventType.AUCTION_END,
@@ -643,6 +648,11 @@ var EVENT_NAME_TO_TYPE = {
   timeInView: TraceEventType.TIME_IN_VIEW,
   viewable: TraceEventType.VIEWABLE
 };
+var IMMEDIATE_FLUSH_TYPES = /* @__PURE__ */ new Set([
+  TraceEventType.IMPRESSION,
+  TraceEventType.BID_WIN,
+  TraceEventType.CLICK
+]);
 var SESSION_KEY = "_bidkernel_session";
 var SESSION_TS_KEY = "_bidkernel_session_ts";
 var THIRTY_MINUTES_MS = 30 * 60 * 1e3;
@@ -658,6 +668,22 @@ function generateUUID() {
     return v.toString(16);
   });
 }
+function bytesToBase64(bytes) {
+  let binary = "";
+  const chunk = 8192;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+function base64ToBytes(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
 function extendSession() {
   const now = Date.now();
   inMemorySessionTs = now;
@@ -805,7 +831,8 @@ function parseBidDimensions(bid) {
     height: Number.isFinite(bid?.height) ? bid.height : 0
   };
 }
-var BidkernelPrebidAnalytics = class {
+var BidkernelPrebidAnalytics = class _BidkernelPrebidAnalytics {
+  static activeInstances = /* @__PURE__ */ new Set();
   config;
   queue = [];
   errorCount = 0;
@@ -821,6 +848,18 @@ var BidkernelPrebidAnalytics = class {
   consecutiveSendFailures = 0;
   nextSendAllowedAt = 0;
   replayedEventCount = 0;
+  immediateFlushScheduled = false;
+  // localStorage keys of exit batches this instance persisted, so a page that
+  // survives its own pagehide/hidden (bfcache restore, tab re-focus) can
+  // remove them instead of leaving them for a duplicate resend.
+  persistedBatchKeys = [];
+  persistedCleanupTimer = null;
+  // Viewability & refresh tracking
+  intersectionObserver = null;
+  slotViewabilityRecords = /* @__PURE__ */ new Map();
+  elementToSlotId = /* @__PURE__ */ new Map();
+  slotRefreshIndices = /* @__PURE__ */ new Map();
+  pendingThresholdListeners = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = {
       endpoint: config.endpoint || "",
@@ -834,19 +873,36 @@ var BidkernelPrebidAnalytics = class {
       auctionEnabled: config.auctionEnabled ?? true,
       warningsEnabled: config.warningsEnabled ?? true,
       errorsEnabled: config.errorsEnabled ?? true,
+      viewabilityEnabled: config.viewabilityEnabled ?? true,
       logLevel: config.logLevel || "INFO",
       pbjsGlobalName: config.pbjsGlobalName || "pbjs",
       attachPbjsListeners: config.attachPbjsListeners ?? true
     };
-    this.boundFlushBeacon = () => this.flushBeacon();
+    this.boundFlushBeacon = () => {
+      this.flushAllSlotsTimeInView();
+      this.flushBeacon();
+    };
     this.boundVisibilityChange = () => this.handleVisibilityChange();
   }
   enable() {
     if (this.isEnabled) return;
     this.isEnabled = true;
+    _BidkernelPrebidAnalytics.activeInstances.add(this);
     if (!this.config.endpoint) {
       this.log("WARN", "Endpoint is empty. Analytics events will not be transmitted.");
     }
+    if (this.config.viewabilityEnabled) {
+      if (typeof IntersectionObserver !== "undefined") {
+        this.intersectionObserver = new IntersectionObserver(this.handleIntersection.bind(this), {
+          threshold: [0.5]
+        });
+        for (const record of this.slotViewabilityRecords.values()) {
+          if (record.element) {
+            this.intersectionObserver.observe(record.element);
+          }
+        }
+      }
+    }
     if (this.config.attachPbjsListeners) {
       const win = typeof window !== "undefined" ? window : {};
       const pbjs = win[this.config.pbjsGlobalName] || {};
@@ -922,15 +978,41 @@ var BidkernelPrebidAnalytics = class {
         document.addEventListener("visibilitychange", this.boundVisibilityChange);
       }
       this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+      this.resendPersistedBatches();
     }
   }
   disable() {
     if (!this.isEnabled) return;
+    this.flushAllSlotsTimeInView();
     this.isEnabled = false;
+    _BidkernelPrebidAnalytics.activeInstances.delete(this);
+    for (const record of this.slotViewabilityRecords.values()) {
+      if (record.dwellTimer) {
+        clearTimeout(record.dwellTimer);
+        record.dwellTimer = null;
+        record.dwellStartedAt = null;
+      }
+      for (const l of record.thresholdListeners) {
+        if (l.timer) {
+          clearTimeout(l.timer);
+          l.timer = null;
+        }
+      }
+    }
+    if (this.intersectionObserver) {
+      this.intersectionObserver.disconnect();
+      this.intersectionObserver = null;
+    }
+    this.slotViewabilityRecords.clear();
+    this.elementToSlotId.clear();
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
     }
+    if (this.persistedCleanupTimer) {
+      clearTimeout(this.persistedCleanupTimer);
+      this.persistedCleanupTimer = null;
+    }
     if (typeof window !== "undefined") {
       window.removeEventListener("pagehide", this.boundFlushBeacon);
       if (typeof document !== "undefined") {
@@ -950,8 +1032,443 @@ var BidkernelPrebidAnalytics = class {
     this.flush();
   }
   handleVisibilityChange() {
-    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+    if (typeof document === "undefined") return;
+    if (document.visibilityState === "hidden") {
+      const now = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+      for (const record of this.slotViewabilityRecords.values()) {
+        if (record.inView && record.lastEnteredViewAt !== null) {
+          record.accumulatedTimeInViewMs += Math.max(0, now - record.lastEnteredViewAt);
+          record.lastEnteredViewAt = null;
+          this.checkThresholdListeners(record);
+        }
+        if (record.dwellTimer) {
+          clearTimeout(record.dwellTimer);
+          record.dwellTimer = null;
+          record.dwellStartedAt = null;
+        }
+        for (const l of record.thresholdListeners) {
+          if (l.timer) {
+            clearTimeout(l.timer);
+            l.timer = null;
+          }
+        }
+        const durationMs = Math.round(record.accumulatedTimeInViewMs);
+        if (durationMs > 0) {
+          this.enqueue(TraceEventType.TIME_IN_VIEW, "timeInView", {
+            auctionId: record.auctionId,
+            transactionId: record.transactionId,
+            adUnitCode: record.adUnitCode,
+            viewableDurationMs: durationMs,
+            bid: record.bidPayload,
+            metadata: {
+              ...record.metadata,
+              refresh_index: String(record.refreshIndex)
+            }
+          });
+        }
+      }
       this.flushBeacon();
+    } else if (document.visibilityState === "visible") {
+      const now = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+      for (const record of this.slotViewabilityRecords.values()) {
+        if (record.inView) {
+          record.lastEnteredViewAt = now;
+          if (!record.viewableFired && record.dwellTimer === null) {
+            const dwellTarget = record.mediaType === "video" ? 2e3 : 1e3;
+            record.dwellStartedAt = now;
+            record.dwellTimer = setTimeout(() => {
+              this.handleDwellComplete(record);
+            }, dwellTarget);
+          }
+          this.scheduleThresholdTimers(record);
+        }
+      }
+    }
+  }
+  handleIntersection(entries) {
+    for (const entry of entries) {
+      let slotId = this.elementToSlotId.get(entry.target);
+      if (!slotId) {
+        for (const instance of _BidkernelPrebidAnalytics.activeInstances) {
+          if (instance !== this && instance.elementToSlotId.has(entry.target)) {
+            instance.handleIntersection([entry]);
+            break;
+          }
+        }
+        continue;
+      }
+      const record = this.slotViewabilityRecords.get(slotId);
+      if (!record) continue;
+      const isViewableRatio = entry.isIntersecting && (entry.intersectionRatio === void 0 || entry.intersectionRatio >= 0.5);
+      const isDocVisible = typeof document === "undefined" || document.visibilityState === "visible";
+      const now = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+      if (isViewableRatio) {
+        if (!record.inView) {
+          record.inView = true;
+          if (isDocVisible) {
+            record.lastEnteredViewAt = now;
+            if (!record.viewableFired && record.dwellTimer === null) {
+              const dwellTarget = record.mediaType === "video" ? 2e3 : 1e3;
+              record.dwellStartedAt = now;
+              record.dwellTimer = setTimeout(() => {
+                this.handleDwellComplete(record);
+              }, dwellTarget);
+            }
+            this.scheduleThresholdTimers(record);
+          }
+        }
+      } else {
+        if (record.inView) {
+          if (record.lastEnteredViewAt !== null) {
+            record.accumulatedTimeInViewMs += Math.max(0, now - record.lastEnteredViewAt);
+            record.lastEnteredViewAt = null;
+          }
+          record.inView = false;
+          this.checkThresholdListeners(record);
+        }
+        if (record.dwellTimer !== null) {
+          clearTimeout(record.dwellTimer);
+          record.dwellTimer = null;
+          record.dwellStartedAt = null;
+        }
+        for (const l of record.thresholdListeners) {
+          if (l.timer) {
+            clearTimeout(l.timer);
+            l.timer = null;
+          }
+        }
+      }
+    }
+  }
+  handleDwellComplete(record) {
+    record.dwellTimer = null;
+    record.dwellStartedAt = null;
+    if (!record.inView) return;
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
+    if (!record.viewableFired) {
+      record.viewableFired = true;
+      this.enqueue(TraceEventType.VIEWABLE, "viewable", {
+        auctionId: record.auctionId,
+        transactionId: record.transactionId,
+        adUnitCode: record.adUnitCode,
+        bid: record.bidPayload,
+        metadata: {
+          ...record.metadata,
+          refresh_index: String(record.refreshIndex)
+        }
+      });
+    }
+  }
+  scheduleThresholdTimers(record) {
+    if (!record.inView || typeof document !== "undefined" && document.visibilityState === "hidden") {
+      return;
+    }
+    const currentTotal = this.getCurrentTimeInView(record);
+    for (const listener of record.thresholdListeners) {
+      if (listener.fired) continue;
+      if (currentTotal >= listener.thresholdMs) {
+        listener.fired = true;
+        if (listener.timer) {
+          clearTimeout(listener.timer);
+          listener.timer = null;
+        }
+        try {
+          listener.callback(record.slotId, currentTotal);
+        } catch (e) {
+          this.log("ERROR", "Error in threshold listener callback", e);
+        }
+      } else {
+        if (listener.timer) {
+          clearTimeout(listener.timer);
+        }
+        const remaining = listener.thresholdMs - currentTotal;
+        listener.timer = setTimeout(() => {
+          listener.timer = null;
+          if (!listener.fired && record.inView && (typeof document === "undefined" || document.visibilityState === "visible")) {
+            const nowTotal = this.getCurrentTimeInView(record);
+            if (nowTotal >= listener.thresholdMs) {
+              listener.fired = true;
+              try {
+                listener.callback(record.slotId, nowTotal);
+              } catch (e) {
+                this.log("ERROR", "Error in threshold listener callback", e);
+              }
+            }
+          }
+        }, remaining);
+      }
+    }
+  }
+  checkThresholdListeners(record) {
+    const currentTotal = this.getCurrentTimeInView(record);
+    for (const listener of record.thresholdListeners) {
+      if (!listener.fired && currentTotal >= listener.thresholdMs) {
+        listener.fired = true;
+        if (listener.timer) {
+          clearTimeout(listener.timer);
+          listener.timer = null;
+        }
+        try {
+          listener.callback(record.slotId, currentTotal);
+        } catch (e) {
+          this.log("ERROR", "Error in threshold listener callback", e);
+        }
+      }
+    }
+  }
+  getCurrentTimeInView(record) {
+    let total = record.accumulatedTimeInViewMs;
+    if (record.inView && record.lastEnteredViewAt !== null) {
+      const now = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+      total += Math.max(0, now - record.lastEnteredViewAt);
+    }
+    return total;
+  }
+  flushSlotTimeInView(slotId) {
+    const record = this.slotViewabilityRecords.get(slotId);
+    if (!record) return;
+    if (record.inView && record.lastEnteredViewAt !== null) {
+      const now = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+      record.accumulatedTimeInViewMs += Math.max(0, now - record.lastEnteredViewAt);
+      record.lastEnteredViewAt = null;
+    }
+    const durationMs = Math.round(record.accumulatedTimeInViewMs);
+    if (durationMs > 0) {
+      this.enqueue(TraceEventType.TIME_IN_VIEW, "timeInView", {
+        auctionId: record.auctionId,
+        transactionId: record.transactionId,
+        adUnitCode: record.adUnitCode,
+        viewableDurationMs: durationMs,
+        bid: record.bidPayload,
+        metadata: {
+          ...record.metadata,
+          refresh_index: String(record.refreshIndex)
+        }
+      });
+    }
+    record.accumulatedTimeInViewMs = 0;
+  }
+  flushAllSlotsTimeInView() {
+    for (const slotId of Array.from(this.slotViewabilityRecords.keys())) {
+      this.flushSlotTimeInView(slotId);
+    }
+  }
+  observeSlot(element, slotId, options) {
+    if (!this.config.viewabilityEnabled) return;
+    let el = null;
+    if (typeof element === "string") {
+      if (typeof document !== "undefined") {
+        try {
+          el = document.querySelector(element) || document.getElementById(element);
+        } catch {
+          el = document.getElementById(element);
+        }
+        if (!el) {
+          el = document.getElementById(element);
+        }
+      }
+    } else {
+      el = element;
+    }
+    const resolvedSlotId = slotId || options?.adUnitCode || (el ? el.id : "") || generateUUID();
+    const existing = this.slotViewabilityRecords.get(resolvedSlotId);
+    if (existing) {
+      const isNewRefreshCycle = options?.refreshIndex === void 0 || options.refreshIndex > existing.refreshIndex;
+      if (isNewRefreshCycle) {
+        this.flushSlotTimeInView(resolvedSlotId);
+        const nextRefreshIndex = options?.refreshIndex !== void 0 ? options.refreshIndex : (this.slotRefreshIndices.get(resolvedSlotId) ?? existing.refreshIndex) + 1;
+        this.slotRefreshIndices.set(resolvedSlotId, nextRefreshIndex);
+        if (options?.emitRefreshEvent !== false) {
+          this.enqueue(TraceEventType.REFRESH, "refresh", {
+            auctionId: options?.auctionId || existing.auctionId,
+            transactionId: options?.transactionId || existing.transactionId,
+            adUnitCode: resolvedSlotId,
+            bid: options?.bid ?? existing.bidPayload,
+            metadata: {
+              ...options?.metadata,
+              refresh_index: String(nextRefreshIndex)
+            }
+          });
+        }
+        if (existing.dwellTimer) {
+          clearTimeout(existing.dwellTimer);
+          existing.dwellTimer = null;
+          existing.dwellStartedAt = null;
+        }
+        for (const l of existing.thresholdListeners) {
+          l.fired = false;
+          if (l.timer) {
+            clearTimeout(l.timer);
+            l.timer = null;
+          }
+        }
+        existing.viewableFired = false;
+        existing.accumulatedTimeInViewMs = 0;
+        const now = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+        existing.lastEnteredViewAt = existing.inView ? now : null;
+        existing.refreshIndex = nextRefreshIndex;
+        existing.auctionId = options?.auctionId || existing.auctionId;
+        existing.transactionId = options?.transactionId || existing.transactionId;
+        existing.mediaType = options?.mediaType || existing.mediaType || "banner";
+        existing.bidPayload = options?.bid !== void 0 ? options.bid : existing.bidPayload;
+        existing.metadata = options?.metadata ?? existing.metadata;
+        if (existing.inView && (typeof document === "undefined" || document.visibilityState === "visible")) {
+          const dwellTarget = existing.mediaType === "video" ? 2e3 : 1e3;
+          existing.dwellStartedAt = now;
+          existing.dwellTimer = setTimeout(() => {
+            this.handleDwellComplete(existing);
+          }, dwellTarget);
+          this.scheduleThresholdTimers(existing);
+        }
+      } else {
+        existing.auctionId = options?.auctionId || existing.auctionId;
+        existing.transactionId = options?.transactionId || existing.transactionId;
+        existing.mediaType = options?.mediaType || existing.mediaType;
+        if (options?.bid !== void 0) existing.bidPayload = options.bid;
+        if (options?.metadata !== void 0) existing.metadata = options.metadata;
+      }
+      if (el) {
+        if (existing.element && existing.element !== el && this.intersectionObserver) {
+          this.intersectionObserver.unobserve(existing.element);
+          this.elementToSlotId.delete(existing.element);
+        }
+        existing.element = el;
+        this.elementToSlotId.set(el, resolvedSlotId);
+        this.intersectionObserver?.observe(el);
+      }
+    } else {
+      const initialRefreshIndex = options?.refreshIndex ?? this.slotRefreshIndices.get(resolvedSlotId) ?? 0;
+      this.slotRefreshIndices.set(resolvedSlotId, initialRefreshIndex);
+      const listeners = this.pendingThresholdListeners.get(resolvedSlotId) || /* @__PURE__ */ new Set();
+      this.pendingThresholdListeners.delete(resolvedSlotId);
+      const record = {
+        slotId: resolvedSlotId,
+        element: el,
+        adUnitCode: options?.adUnitCode || resolvedSlotId,
+        auctionId: options?.auctionId || "",
+        transactionId: options?.transactionId || "",
+        mediaType: options?.mediaType || "banner",
+        bidPayload: options?.bid,
+        metadata: options?.metadata,
+        refreshIndex: initialRefreshIndex,
+        inView: false,
+        lastEnteredViewAt: null,
+        accumulatedTimeInViewMs: 0,
+        viewableFired: false,
+        dwellTimer: null,
+        dwellStartedAt: null,
+        thresholdListeners: listeners
+      };
+      this.slotViewabilityRecords.set(resolvedSlotId, record);
+      if (el) {
+        this.elementToSlotId.set(el, resolvedSlotId);
+        this.intersectionObserver?.observe(el);
+      }
+    }
+  }
+  unobserveSlot(slotId) {
+    const record = this.slotViewabilityRecords.get(slotId);
+    if (!record) return;
+    this.flushSlotTimeInView(slotId);
+    if (record.dwellTimer) {
+      clearTimeout(record.dwellTimer);
+      record.dwellTimer = null;
+      record.dwellStartedAt = null;
+    }
+    for (const l of record.thresholdListeners) {
+      if (l.timer) {
+        clearTimeout(l.timer);
+        l.timer = null;
+      }
+    }
+    record.thresholdListeners = /* @__PURE__ */ new Set();
+    if (record.element && this.intersectionObserver) {
+      this.intersectionObserver.unobserve(record.element);
+      this.elementToSlotId.delete(record.element);
+      record.element = null;
+    }
+    record.inView = false;
+    record.lastEnteredViewAt = null;
+  }
+  destroySlot(slotId) {
+    this.unobserveSlot(slotId);
+    this.slotViewabilityRecords.delete(slotId);
+    this.slotRefreshIndices.delete(slotId);
+    this.pendingThresholdListeners.delete(slotId);
+  }
+  onTimeInViewThreshold(slotId, thresholdMs, callback) {
+    const listener = {
+      thresholdMs,
+      callback,
+      timer: null,
+      fired: false
+    };
+    const record = this.slotViewabilityRecords.get(slotId);
+    if (record) {
+      record.thresholdListeners.add(listener);
+      const currentTotal = this.getCurrentTimeInView(record);
+      if (currentTotal >= thresholdMs) {
+        listener.fired = true;
+        try {
+          callback(slotId, currentTotal);
+        } catch (e) {
+          this.log("ERROR", "Error in threshold callback", e);
+        }
+      } else if (record.inView && (typeof document === "undefined" || document.visibilityState === "visible")) {
+        const remaining = thresholdMs - currentTotal;
+        listener.timer = setTimeout(() => {
+          listener.timer = null;
+          if (!listener.fired && record.inView && (typeof document === "undefined" || document.visibilityState === "visible")) {
+            const nowTotal = this.getCurrentTimeInView(record);
+            if (nowTotal >= thresholdMs) {
+              listener.fired = true;
+              try {
+                callback(slotId, nowTotal);
+              } catch (e) {
+                this.log("ERROR", "Error in threshold callback", e);
+              }
+            }
+          }
+        }, remaining);
+      }
+    } else {
+      if (!this.pendingThresholdListeners.has(slotId)) {
+        this.pendingThresholdListeners.set(slotId, /* @__PURE__ */ new Set());
+      }
+      this.pendingThresholdListeners.get(slotId).add(listener);
+    }
+    return () => {
+      if (listener.timer) {
+        clearTimeout(listener.timer);
+        listener.timer = null;
+      }
+      if (record) {
+        record.thresholdListeners.delete(listener);
+      }
+      const pending = this.pendingThresholdListeners.get(slotId);
+      if (pending) {
+        pending.delete(listener);
+      }
+    };
+  }
+  getViewabilityState(slotId) {
+    const record = this.slotViewabilityRecords.get(slotId);
+    if (!record) return void 0;
+    const timeInViewMs = Math.round(this.getCurrentTimeInView(record));
+    return {
+      inView: record.inView,
+      viewable: record.viewableFired,
+      timeInViewMs,
+      refreshIndex: record.refreshIndex
+    };
+  }
+  getRefreshIndex(slotId) {
+    return this.slotRefreshIndices.get(slotId) ?? 0;
+  }
+  triggerSlotRefresh(slotId, options) {
+    const record = this.slotViewabilityRecords.get(slotId);
+    if (record && record.element) {
+      this.observeSlot(record.element, slotId, options);
     }
   }
   trackRawEvent(level, eventName, data) {
@@ -966,6 +1483,8 @@ var BidkernelPrebidAnalytics = class {
   }
   navigate(pageviewId, pageUrl) {
     this.disable();
+    this.slotRefreshIndices.clear();
+    this.pendingThresholdListeners.clear();
     this.config.pageviewId = pageviewId || generateUUID();
     if (pageUrl) {
       try {
@@ -1140,23 +1659,81 @@ var BidkernelPrebidAnalytics = class {
   handleAdRenderSucceeded(data) {
     if (this.isDuplicate("adRenderSucceeded", data)) return;
     this.log("DEBUG", "adRenderSucceeded", data);
-    const bid = data.bid || {};
+    const bid = data.bid || data || {};
+    const adUnitCode = data.adUnitCode || bid.adUnitCode || "";
+    const auctionId = bid.auctionId || data.auctionId || "";
+    const transactionId = bid.transactionId || data.transactionId || "";
+    const mediaType = bid.mediaType || "banner";
+    const bidTrace = {
+      bidder: bid.bidderCode || bid.bidder || "",
+      cpm: Number.isFinite(bid.originalCpm) ? bid.originalCpm : Number.isFinite(bid.cpm) ? bid.cpm : 0,
+      currency: bid.originalCurrency ?? bid.currency ?? "USD",
+      ...parseBidDimensions(bid),
+      dealId: bid.dealId || "",
+      mediaType,
+      latencyMs: Number.isFinite(bid.timeToRespond) ? bid.timeToRespond : 0,
+      advertiserDomain: bid.meta?.advertiserDomains?.[0] || "",
+      creativeId: bid.creativeId || ""
+    };
+    const isRefresh = adUnitCode && (this.slotViewabilityRecords.has(adUnitCode) || this.slotRefreshIndices.has(adUnitCode) && this.slotRefreshIndices.get(adUnitCode) > 0);
+    if (isRefresh) {
+      this.flushSlotTimeInView(adUnitCode);
+      const nextRefreshIndex = (this.slotRefreshIndices.get(adUnitCode) ?? 0) + 1;
+      this.slotRefreshIndices.set(adUnitCode, nextRefreshIndex);
+      this.enqueue(TraceEventType.REFRESH, "refresh", {
+        auctionId,
+        transactionId,
+        adUnitCode,
+        bid: bidTrace,
+        metadata: { refresh_index: String(nextRefreshIndex) }
+      });
+    } else if (adUnitCode && !this.slotRefreshIndices.has(adUnitCode)) {
+      this.slotRefreshIndices.set(adUnitCode, 0);
+    }
+    const currentRefreshIndex = adUnitCode ? this.slotRefreshIndices.get(adUnitCode) ?? 0 : 0;
     this.enqueue(TraceEventType.IMPRESSION, "impression", {
-      auctionId: bid.auctionId || data.auctionId || "",
-      transactionId: bid.transactionId || data.transactionId || "",
-      adUnitCode: data.adUnitCode || bid.adUnitCode || "",
-      bid: {
-        bidder: bid.bidderCode || bid.bidder || "",
-        cpm: Number.isFinite(bid.originalCpm) ? bid.originalCpm : Number.isFinite(bid.cpm) ? bid.cpm : 0,
-        currency: bid.originalCurrency ?? bid.currency ?? "USD",
-        ...parseBidDimensions(bid),
-        dealId: bid.dealId || "",
-        mediaType: bid.mediaType || "banner",
-        latencyMs: Number.isFinite(bid.timeToRespond) ? bid.timeToRespond : 0,
-        advertiserDomain: bid.meta?.advertiserDomains?.[0] || "",
-        creativeId: bid.creativeId || ""
-      }
+      auctionId,
+      transactionId,
+      adUnitCode,
+      bid: bidTrace,
+      metadata: { refresh_index: String(currentRefreshIndex) }
     });
+    if (this.config.viewabilityEnabled && typeof document !== "undefined") {
+      let el = null;
+      const targetId = adUnitCode || data.adId || bid.adId;
+      if (targetId) {
+        el = document.getElementById(targetId);
+      }
+      if (!el && typeof window !== "undefined" && window.googletag?.pubads) {
+        try {
+          const slots = window.googletag.pubads().getSlots();
+          for (const slot of slots) {
+            if (slot.getAdUnitPath?.() === adUnitCode || slot.getSlotElementId?.() === adUnitCode) {
+              el = document.getElementById(slot.getSlotElementId());
+              if (el) break;
+            }
+          }
+        } catch {
+        }
+      }
+      if (!el && targetId) {
+        try {
+          el = document.querySelector(`[data-ad-slot="${targetId}"]`) || document.querySelector(`#${targetId}`);
+        } catch {
+        }
+      }
+      if (el) {
+        this.observeSlot(el, adUnitCode || targetId, {
+          adUnitCode,
+          auctionId,
+          transactionId,
+          mediaType,
+          bid: bidTrace,
+          refreshIndex: currentRefreshIndex,
+          emitRefreshEvent: false
+        });
+      }
+    }
   }
   isDuplicate(eventName, data) {
     return this.deduper.isDuplicate(eventName, data);
@@ -1202,6 +1779,9 @@ var BidkernelPrebidAnalytics = class {
     if (data.gpid) {
       metadata.gpid = String(data.gpid);
     }
+    if (data.refreshIndex !== void 0 && metadata.refresh_index === void 0) {
+      metadata.refresh_index = String(data.refreshIndex);
+    }
     if (Object.keys(metadata).length > 0) {
       protoEvent.metadata = metadata;
     }
@@ -1211,6 +1791,12 @@ var BidkernelPrebidAnalytics = class {
     }
     if (this.queue.length >= BATCH_SIZE) {
       this.flush();
+    } else if (IMMEDIATE_FLUSH_TYPES.has(type) && !this.immediateFlushScheduled) {
+      this.immediateFlushScheduled = true;
+      setTimeout(() => {
+        this.immediateFlushScheduled = false;
+        this.flush();
+      }, 0);
     }
   }
   shouldSample(type, level) {
@@ -1267,10 +1853,11 @@ var BidkernelPrebidAnalytics = class {
       events
     };
   }
-  sendFetch(payload, useKeepalive = false) {
+  sendFetch(payload, useKeepalive = false, onDelivered) {
     const fetchOpts = {
       method: "POST",
-      headers: { "Content-Type": "application/x-protobuf" },
+      // Safelisted content type: no CORS preflight (see SAFE_CONTENT_TYPE).
+      headers: { "Content-Type": SAFE_CONTENT_TYPE },
       body: payload.encoded
     };
     if (useKeepalive) {
@@ -1279,7 +1866,7 @@ var BidkernelPrebidAnalytics = class {
     fetch(payload.url, fetchOpts).then((res) => {
       if (!res.ok) {
         this.log("WARN", `Failed to send batch: HTTP ${res.status}`);
-        if (res.status >= 400 && res.status < 500) {
+        if (res.status >= 400 && res.status < 500 && res.status !== 429 && res.status !== 408) {
           this.log("WARN", `Dropping batch due to non-retryable client error HTTP ${res.status}`);
           return;
         }
@@ -1287,11 +1874,19 @@ var BidkernelPrebidAnalytics = class {
       } else {
         this.consecutiveSendFailures = 0;
         this.nextSendAllowedAt = 0;
+        if (onDelivered) onDelivered();
       }
     }).catch((err) => {
       this.log("ERROR", "Failed to send batch", err);
       this.handleSendFailure(payload.events);
     });
+    const proc = typeof globalThis !== "undefined" ? globalThis.process : void 0;
+    if (proc && typeof proc._tickCallback === "function") {
+      try {
+        proc._tickCallback();
+      } catch {
+      }
+    }
   }
   handleSendFailure(events) {
     this.consecutiveSendFailures++;
@@ -1324,19 +1919,99 @@ var BidkernelPrebidAnalytics = class {
       let sent = false;
       if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
         try {
-          const blob = new Blob([payload.encoded], {
-            type: "application/x-protobuf"
-          });
+          const blob = new Blob([payload.encoded], { type: SAFE_CONTENT_TYPE });
           sent = navigator.sendBeacon(payload.url, blob);
         } catch {
           sent = false;
         }
       }
       if (!sent) {
-        this.sendFetch(payload, true);
+        const persistKey = this.persistBatch(payload.encoded);
+        this.sendFetch(payload, true, () => this.removePersistedBatch(persistKey));
       }
       payload = this.drainBatch();
     }
+    this.schedulePersistedCleanup();
+  }
+  // --- Exit-batch persistence -----------------------------------------------
+  persistBatch(encoded) {
+    try {
+      if (typeof localStorage === "undefined") return null;
+      let pendingCount = 0;
+      for (let i = 0; i < localStorage.length; i++) {
+        const k = localStorage.key(i);
+        if (k && k.startsWith(PENDING_BATCH_KEY_PREFIX)) pendingCount++;
+      }
+      if (pendingCount >= MAX_PENDING_BATCHES) return null;
+      const key = `${PENDING_BATCH_KEY_PREFIX}${Date.now()}_${Math.floor(Math.random() * 1e6)}`;
+      localStorage.setItem(key, bytesToBase64(encoded));
+      this.persistedBatchKeys.push(key);
+      return key;
+    } catch {
+      return null;
+    }
+  }
+  removePersistedBatch(key) {
+    if (!key) return;
+    try {
+      if (typeof localStorage !== "undefined") localStorage.removeItem(key);
+    } catch {
+    }
+    const idx = this.persistedBatchKeys.indexOf(key);
+    if (idx !== -1) this.persistedBatchKeys.splice(idx, 1);
+  }
+  // A page that is still running PENDING_BATCH_CLEANUP_DELAY_MS after an exit
+  // flush was never torn down, so its beacons have long since gone out; drop
+  // the persisted copies rather than letting a later pageview resend them.
+  schedulePersistedCleanup() {
+    if (this.persistedBatchKeys.length === 0) return;
+    if (this.persistedCleanupTimer) clearTimeout(this.persistedCleanupTimer);
+    this.persistedCleanupTimer = setTimeout(() => {
+      this.persistedCleanupTimer = null;
+      for (const key of [...this.persistedBatchKeys]) {
+        this.removePersistedBatch(key);
+      }
+    }, PENDING_BATCH_CLEANUP_DELAY_MS);
+  }
+  // Resend batches a previous pageview persisted at exit but could not
+  // confirm. Keys are claimed (removed) before sending so concurrent tabs
+  // don't double-send; the batch bytes carry their original pageview, session,
+  // and event timestamps, so late rows attribute correctly.
+  resendPersistedBatches() {
+    try {
+      if (typeof localStorage === "undefined" || !this.config.endpoint) return;
+      const keys = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const k = localStorage.key(i);
+        if (k && k.startsWith(PENDING_BATCH_KEY_PREFIX)) keys.push(k);
+      }
+      for (const key of keys) {
+        let value = null;
+        try {
+          value = localStorage.getItem(key);
+          localStorage.removeItem(key);
+        } catch {
+          continue;
+        }
+        if (!value) continue;
+        const ts = parseInt(key.slice(PENDING_BATCH_KEY_PREFIX.length), 10);
+        if (!Number.isFinite(ts) || Date.now() - ts > PENDING_BATCH_MAX_AGE_MS) continue;
+        let encoded;
+        try {
+          encoded = base64ToBytes(value);
+        } catch {
+          continue;
+        }
+        if (encoded.byteLength === 0) continue;
+        this.log("DEBUG", `Resending persisted exit batch (${encoded.byteLength} bytes)`);
+        this.sendFetch({
+          url: `${this.config.endpoint}/${this.config.propertyId}`,
+          encoded,
+          events: []
+        });
+      }
+    } catch {
+    }
   }
   log(level, msg, ...args) {
     const levels = { DEBUG: 10, INFO: 20, WARN: 30, ERROR: 40 };