onerway-analytics 1.2.0 → 1.5.0

package/README.md

@@ -214,7 +214,8 @@ const analytics = createAnalytics({
 | `keyEvents` | `string[]` | — | 关键事件名单，命中的事件立即发送 |
 | `bufferFlushInterval` | `number` | `5000` | 缓冲区定时刷新间隔（ms） |
 | `bufferMaxSize` | `number` | `25` | 缓冲区达到此数量立即刷新 |
-| `maxRetryCount` | `number` | `3` | 发送失败最大重试次数（指数退避） |
+| `maxRetryCount` | `number` | `3` | 同一事件重发预算（含离页补发），上限 5；预算跨页面保留 |
+| `persistKeyEvents` | `boolean` | `false` | 将关键事件保存到本地直到 HTTP 确认；仅对属性可安全持久化的应用启用 |
 | `sessionTimeout` | `number` | `1800000` | 会话超时（ms），默认 30 分钟 |
 | `performance.enabled` | `boolean` | `true` | Core Web Vitals 采集开关 |
 | `gtm.enabled` | `boolean` | — | GTM 双发开关 |
@@ -314,9 +315,13 @@ const analytics = createAnalytics({
 ## 可靠性机制
 
 - **缓冲区 + 批量发送**：事件先入缓冲区，满 `bufferMaxSize` 或到 `bufferFlushInterval` 后批量发送
-- **指数退避重试**：发送失败最多重试 `maxRetryCount` 次，间隔 1s / 2s / 4s…
-- **本地持久化**：超出重试次数的事件写入 localStorage，下次页面加载时自动恢复补发（24 小时内有效）
-- **页面关闭兜底**：`beforeunload` / `pagehide` 时用 `sendBeacon` 发送缓冲区剩余事件
+- **有界重试**：网络错误、408、429、5xx 最多重试 `maxRetryCount` 次（上限 5），指数退避加随机抖动；其他 4xx 终止。fetch/XHR 均有 10 秒超时。
+- **可选关键事件持久化**：`persistKeyEvents: true` 时，关键事件发送前保存完整 payload，HTTP 2xx 后移除；重启保留 event_id 和原页面归属，按 appKey/serverUrl 隔离。自动事件不落盘；队列最多 500 条、24 小时有效，超出重试预算或不可重试错误终止。存储不可用时降为内存发送。
+- **页面生命周期**：visibilitychange(hidden) / pagehide 提前刷新，pageshow/visible 恢复正常发送；原请求与离页副本任一 HTTP 2xx 即确认，另一个副本后续失败不会恢复已确认事件。全部请求使用 apiKey header；正常使用普通 fetch，隐藏时使用 keepalive，缺少 fetch 时正常页面降级异步 XHR。无 URI apiKey 或同步 XHR。
+- **首次即时发送**：正常页面的首次请求直接发送，不受两个并发的队列限制；只有失败重试和历史恢复共用两个并发。浏览器仍决定实际网络调度。
+- **离页合批**：收集所有未确认事件（包括正常请求在途的副本），关键事件优先，按相同 client/session/context/marketing/user 等请求上下文合并。一次回调内直接提交全部预算内批次，不等待前一批响应。
+- **总字节控制**：单批及同一隐藏周期离页提交总量限制为 48 KiB UTF-8 字节，同时扣除尚未完成的 keepalive 在途字节；不同生命周期回调不重复提交同一隐藏周期已提交的事件。单事件超大或待确认队列满时丢弃新增事件。SDK 无法控制其他库占用的 keepalive 额度。
+- **送达边界**：服务端必须按 event_id 去重；HTTP 2xx 仅作为传输确认。离页后后续排队请求不保证继续执行，已持久化的关键事件等下次同源访问恢复；用户不再访问、存储不可用、超过上限/有效期/重试预算时仍可能丢失。自动事件不保证跨页面补发。
 - **采样控制**：`sampleRate` 在客户端决定是否上报，降低高流量场景的服务器压力
 
 ---
@@ -335,3 +340,11 @@ analytics = createAnalytics({ ... });
 analytics = createAnalytics({ ..., autoTrackPageView: false });
 analytics.track('page_view', { page_url: location.href });
 ```
+
+## 发送可靠性验证（1.3.2）
+
+- `npm ci`，`npm run typecheck`，`npm test -- --runInBand`。
+- `npm run test:browser`：Playwright + 本地 HTTP/CORS 接收端，覆盖密集请求、断网恢复、刷新、原生 pagehide、关闭重开、401。默认使用 macOS 已安装 Chrome；其他环境可设置 `CHROME_PATH` 或先安装 Playwright Chromium。
+- `npm pack` 会重新构建模块及浏览器包，排除测试产物。生产 APISIX 鉴权、真实入库和统计去重需要部署后单独验收；本地测试不调用生产接口。
+
+- `npm run test:browser:comparison`：使用相邻收银台实际安装的 Axios 对照 V1 传输（可用 `CHECKOUT_DIR` 指定仓库路径）。每场景双写 24 个事件，覆盖正常立即跳转、已有请求积压的慢网跳转、慢网关闭；离开后不再访问或初始化 SDK，接收端比较 V1 已收到的事件是否都包含在 V2 中。V1 省略指纹等待，使其发送时机更有利；这不是完整支付业务 E2E，也不代表生产零漏报。

package/dist/bundle/index.js

@@ -67,7 +67,7 @@ var OnrwayAnalytics = (() => {
     prod: "HUk5Kogyuv9zH5qDA2qSCjVEnhanSkf8",
     production: "HUk5Kogyuv9zH5qDA2qSCjVEnhanSkf8"
   };
-  var SDK_VERSION = "1.0.0";
+  var SDK_VERSION = "1.3.2";
   var DEFAULT_CONFIG = {
     debug: false,
     autoTrack: true,
@@ -322,110 +322,275 @@ var OnrwayAnalytics = (() => {
   };
 
   // src/core/sender.ts
+  var DeliveryError = class extends Error {
+    constructor(message, retryable) {
+      super(message);
+      this.retryable = retryable;
+    }
+  };
   var Sender = class _Sender {
-    static async send(payload, serverUrl, apiKey) {
-      if (_Sender.supportsKeepalive()) {
-        return _Sender.fetchSend(payload, serverUrl, apiKey);
+    static async send(payload, serverUrl, apiKey, keepalive = false) {
+      if (typeof fetch === "function" && typeof AbortController !== "undefined") {
+        if (keepalive && !_Sender.supportsKeepalive()) {
+          throw new DeliveryError("Keepalive unavailable", true);
+        }
+        return _Sender.fetchSend(payload, serverUrl, apiKey, keepalive);
       }
+      if (keepalive) throw new DeliveryError("Unload transport unavailable", true);
       return _Sender.xhrSend(payload, serverUrl, apiKey);
     }
-    static async sendBeacon(payload, serverUrl, apiKey) {
-      if (typeof navigator === "undefined" || !navigator.sendBeacon) {
-        throw new Error("sendBeacon not available");
-      }
-      const url = _Sender.buildBeaconUrl(serverUrl, apiKey);
-      const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
-      const success = navigator.sendBeacon(url, blob);
-      if (!success) {
-        throw new Error("sendBeacon rejected payload");
-      }
+    // Compatibility entry point: authenticated delivery must support custom headers.
+    static sendBeacon(payload, serverUrl, apiKey) {
+      return _Sender.send(payload, serverUrl, apiKey, true);
     }
-    static async fetchSend(payload, serverUrl, apiKey) {
-      const response = await fetch(serverUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          apiKey
-        },
-        body: JSON.stringify(payload),
-        keepalive: true
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    static async fetchSend(payload, serverUrl, apiKey, keepalive = false) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 1e4);
+      try {
+        const response = await fetch(serverUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", apiKey },
+          body: JSON.stringify(payload),
+          keepalive,
+          signal: controller.signal
+        });
+        if (!response.ok) throw _Sender.httpError(response.status);
+      } finally {
+        clearTimeout(timer);
       }
     }
-    static async xhrSend(payload, serverUrl, apiKey) {
+    static httpError(status) {
+      return new DeliveryError(`HTTP ${status}`, status === 408 || status === 429 || status >= 500);
+    }
+    static xhrSend(payload, serverUrl, apiKey) {
       return new Promise((resolve, reject) => {
         const xhr = new XMLHttpRequest();
-        xhr.open("POST", serverUrl);
+        xhr.open("POST", serverUrl, true);
         xhr.setRequestHeader("Content-Type", "application/json");
         xhr.setRequestHeader("apiKey", apiKey);
         xhr.timeout = 1e4;
-        xhr.onload = () => {
-          if (xhr.status >= 200 && xhr.status < 300) {
-            resolve();
-          } else {
-            reject(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
-          }
-        };
-        xhr.onerror = () => reject(new Error("XHR network error"));
-        xhr.ontimeout = () => reject(new Error("XHR timeout"));
+        xhr.onload = () => xhr.status >= 200 && xhr.status < 300 ? resolve() : reject(_Sender.httpError(xhr.status));
+        xhr.onerror = () => reject(new DeliveryError("XHR network error", true));
+        xhr.ontimeout = () => reject(new DeliveryError("XHR timeout", true));
+        xhr.onabort = () => reject(new DeliveryError("XHR aborted", true));
         xhr.send(JSON.stringify(payload));
       });
     }
     static supportsKeepalive() {
-      try {
-        return typeof Request !== "undefined" && "keepalive" in Request.prototype;
-      } catch {
-        return false;
-      }
-    }
-    static buildBeaconUrl(serverUrl, apiKey) {
-      const separator = serverUrl.includes("?") ? "&" : "?";
-      return `${serverUrl}${separator}apiKey=${encodeURIComponent(apiKey)}`;
+      return typeof Request !== "undefined" && "keepalive" in Request.prototype;
     }
   };
 
-  // src/core/storage.ts
-  var MAX_EVENT_AGE_MS = 24 * 60 * 60 * 1e3;
-  var StorageQueue = class _StorageQueue {
-    static enqueue(event) {
-      try {
-        const queue = _StorageQueue.readQueue();
-        queue.push({ event, storedAt: Date.now() });
-        while (queue.length > MAX_STORAGE_ITEMS) {
-          queue.shift();
+  // src/core/delivery-queue.ts
+  var MAX_BYTES = 48 * 1024;
+  var MAX_EVENTS = 500;
+  var MAX_AGE = 24 * 60 * 60 * 1e3;
+  var DeliveryQueue = class {
+    constructor(options) {
+      this.options = options;
+      this.jobs = [];
+      this.activeRetries = 0;
+      this.hidden = typeof document !== "undefined" && document.visibilityState === "hidden";
+      this.timer = null;
+      this.stopped = false;
+      this.hiddenSent = /* @__PURE__ */ new Set();
+      this.hiddenSpent = 0;
+      this.keepaliveBytes = 0;
+      this.maxAttempts = 1 + Math.min(5, Math.max(0, options.maxRetries || 0));
+      this.storagePrefix = `__analytics_delivery_v1__:${encodeURIComponent(options.appKey)}:${encodeURIComponent(options.serverUrl)}:`;
+      if (options.persistKeyEvents && options.apiKey) this.recover();
+      this.pumpRetries();
+    }
+    enqueue(payload) {
+      if (this.stopped || !this.options.apiKey) return;
+      const accepted = [];
+      for (const event of payload.events) {
+        if (this.jobs.length >= MAX_EVENTS) break;
+        const single = { ...payload, events: [event] };
+        if (this.bytes(single) > MAX_BYTES) continue;
+        const job = {
+          payload: single,
+          attempts: 0,
+          createdAt: Date.now(),
+          nextAt: 0,
+          active: 0,
+          hiddenActive: false,
+          terminal: false
+        };
+        this.jobs.push(job);
+        this.persist(job);
+        accepted.push(job);
+      }
+      if (this.hidden) {
+        this.flushHidden();
+      } else {
+        for (const batch of this.batches(accepted, MAX_BYTES)) this.start(batch.payload, batch.jobs, false, false);
+      }
+    }
+    setHidden(hidden) {
+      if (hidden && !this.hidden) {
+        this.hiddenSent.clear();
+        this.hiddenSpent = 0;
+      }
+      this.hidden = hidden;
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      if (!hidden) this.pumpRetries();
+    }
+    /** Submit the whole affordable rescue set synchronously; do not wait for ACKs. */
+    flushHidden() {
+      if (this.stopped || !this.hidden) return;
+      const available = Math.min(MAX_BYTES - this.hiddenSpent, MAX_BYTES - this.keepaliveBytes);
+      if (available <= 0) return;
+      this.prune();
+      const candidates = this.jobs.filter((job) => !job.terminal && !job.hiddenActive && !this.hiddenSent.has(job) && job.attempts < this.maxAttempts).sort((a2, b2) => Number(b2.payload.events[0].key_event) - Number(a2.payload.events[0].key_event));
+      let remaining = available;
+      for (const batch of this.batches(candidates, available, true)) {
+        const bytes = this.bytes(batch.payload);
+        if (bytes > remaining) continue;
+        remaining -= bytes;
+        this.hiddenSpent += bytes;
+        for (const job of batch.jobs) this.hiddenSent.add(job);
+        this.start(batch.payload, batch.jobs, true, false);
+      }
+    }
+    bytes(payload) {
+      return new Blob([JSON.stringify(payload)]).size;
+    }
+    batches(jobs, budget, totalBudget = false) {
+      const result = [];
+      let remaining = budget;
+      const groups = /* @__PURE__ */ new Map();
+      for (const job of jobs) {
+        const { events, ...envelope } = job.payload;
+        const key = JSON.stringify(envelope);
+        let group = groups.get(key);
+        const proposed = { ...envelope, events: [...group?.payload.events || [], ...events].map((event, index) => ({ ...event, batch_event_index: index })) };
+        const delta = this.bytes(proposed) - (group ? this.bytes(group.payload) : 0);
+        if (totalBudget && delta > remaining) continue;
+        if (this.bytes(proposed) > budget) {
+          group = void 0;
         }
-        safeLocalStorageSet(STORAGE_KEYS.FAILED_QUEUE, JSON.stringify(queue));
-      } catch {
+        if (!group) {
+          group = { payload: { ...envelope, events: events.map((event, index) => ({ ...event, batch_event_index: index })) }, jobs: [] };
+          groups.set(key, group);
+          result.push(group);
+        } else {
+          group.payload = proposed;
+        }
+        group.jobs.push(job);
+        if (totalBudget) remaining -= delta;
       }
+      return result;
     }
-    static recover() {
+    prune() {
+      for (const job of [...this.jobs]) {
+        if (!job.active && (job.terminal || Date.now() - job.createdAt >= MAX_AGE || job.attempts >= this.maxAttempts)) this.remove(job);
+      }
+    }
+    pumpRetries() {
+      if (this.stopped || this.hidden) return;
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      this.prune();
+      while (this.activeRetries < 2) {
+        const job = this.jobs.find((item) => !item.active && item.nextAt <= Date.now());
+        if (!job) break;
+        this.start(job.payload, [job], false, true);
+      }
+      const waiting = this.jobs.filter((job) => !job.active);
+      if (waiting.length && this.activeRetries < 2) {
+        const delay = Math.max(1, Math.min(...waiting.map((job) => job.nextAt)) - Date.now());
+        this.timer = setTimeout(() => this.pumpRetries(), delay);
+      }
+    }
+    start(payload, jobs, keepalive, retry) {
+      const bytes = keepalive ? this.bytes(payload) : 0;
+      this.keepaliveBytes += bytes;
+      if (retry) this.activeRetries++;
+      for (const job of jobs) {
+        job.active++;
+        job.attempts++;
+        if (keepalive) job.hiddenActive = true;
+        this.persist(job);
+      }
+      void this.deliver(payload, jobs, keepalive, retry, bytes);
+    }
+    async deliver(payload, jobs, keepalive, retry, bytes) {
       try {
-        const queue = _StorageQueue.readQueue();
-        _StorageQueue.clear();
-        const now = Date.now();
-        const events = queue.filter((item) => now - item.storedAt < MAX_EVENT_AGE_MS).map((item) => item.event);
-        return events;
-      } catch {
-        return [];
+        await Sender.send(payload, this.options.serverUrl, this.options.apiKey, keepalive);
+        for (const job of jobs) this.remove(job);
+      } catch (error) {
+        for (const job of jobs) {
+          if (!this.jobs.includes(job)) continue;
+          if (error instanceof DeliveryError && !error.retryable) job.terminal = true;
+          job.nextAt = Date.now() + Math.min(3e4, 1e3 * 2 ** (job.attempts - 1)) + Math.floor(Math.random() * 250);
+        }
+      } finally {
+        for (const job of jobs) {
+          job.active--;
+          if (keepalive) job.hiddenActive = false;
+          if (!this.jobs.includes(job)) continue;
+          if (!job.active && (job.terminal || job.attempts >= this.maxAttempts)) this.remove(job);
+          else this.persist(job);
+        }
+        this.keepaliveBytes -= bytes;
+        if (retry) this.activeRetries--;
+        this.pumpRetries();
       }
     }
-    static clear() {
-      safeLocalStorageRemove(STORAGE_KEYS.FAILED_QUEUE);
+    key(eventId) {
+      return this.storagePrefix + eventId;
     }
-    static getQueueSize() {
-      return _StorageQueue.readQueue().length;
+    persist(job) {
+      if (!this.options.persistKeyEvents || !job.payload.events[0].key_event) return;
+      safeLocalStorageSet(this.key(job.payload.events[0].event_id), JSON.stringify({
+        payload: job.payload,
+        attempts: job.attempts,
+        createdAt: job.createdAt,
+        nextAt: job.nextAt
+      }));
     }
-    static readQueue() {
+    remove(job) {
+      if (!this.jobs.includes(job)) return;
+      this.jobs = this.jobs.filter((item) => item !== job);
+      this.hiddenSent.delete(job);
+      if (this.options.persistKeyEvents) safeLocalStorageRemove(this.key(job.payload.events[0].event_id));
+    }
+    recover() {
       try {
-        const raw = safeLocalStorageGet(STORAGE_KEYS.FAILED_QUEUE);
-        if (!raw) return [];
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed)) return [];
-        return parsed;
+        const keys = Object.keys(localStorage).filter((key) => key.startsWith(this.storagePrefix));
+        for (const key of keys) {
+          try {
+            const job = JSON.parse(safeLocalStorageGet(key) || "null");
+            if (!job || !Number.isFinite(job.createdAt) || !Number.isInteger(job.attempts) || job.attempts < 0 || !Number.isFinite(job.nextAt) || Date.now() - job.createdAt >= MAX_AGE || job.attempts >= this.maxAttempts || !Array.isArray(job.payload?.events) || job.payload.events.length !== 1 || !job.payload.events[0].key_event || this.key(job.payload.events[0].event_id) !== key || this.bytes(job.payload) > MAX_BYTES || this.jobs.length >= MAX_EVENTS) {
+              safeLocalStorageRemove(key);
+              continue;
+            }
+            this.jobs.push({ ...job, active: 0, hiddenActive: false, terminal: false });
+          } catch {
+            safeLocalStorageRemove(key);
+          }
+        }
       } catch {
-        return [];
+      }
+    }
+    clear() {
+      for (const job of [...this.jobs]) this.remove(job);
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+    }
+    destroy() {
+      this.stopped = true;
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
       }
     }
   };
@@ -1006,8 +1171,8 @@ var OnrwayAnalytics = (() => {
       this.userId = null;
       this.userProps = {};
       this.initialized = false;
-      this.retrying = 0;
       this.unloadHandler = null;
+      this.visibilityHandler = null;
       this.gtm = new GTMManager();
       this.config = {
         debug: false,
@@ -1025,9 +1190,13 @@ var OnrwayAnalytics = (() => {
       this.batchPageId = this.generateBatchPageId();
       this.sessionManager = new SessionManager(this.config.sessionTimeout);
       this.sampled = this.resolveSampling();
-      if (isBrowser()) {
-        this.recoverFailedEvents();
-      }
+      this.delivery = new DeliveryQueue({
+        serverUrl: this.config.serverUrl,
+        apiKey: this.resolveApiKey(),
+        appKey,
+        maxRetries: this.config.maxRetryCount,
+        persistKeyEvents: this.config.persistKeyEvents === true && this.sampled && !this.config.disableServer
+      });
       this.registerBeforeUnload();
       if (this.config.autoTrack && isBrowser()) {
         initAutoTrack(this, this.config.autoTrackSelector);
@@ -1117,6 +1286,7 @@ var OnrwayAnalytics = (() => {
       this.userId = null;
       this.userProps = {};
       this.buffer = [];
+      this.delivery.clear();
       if (this.bufferTimer) {
         clearTimeout(this.bufferTimer);
         this.bufferTimer = null;
@@ -1219,10 +1389,6 @@ var OnrwayAnalytics = (() => {
         this.bufferTimer = null;
       }
       if (this.buffer.length === 0) return;
-      if (this.retrying > 0) {
-        this.scheduleBufferFlush();
-        return;
-      }
       const events = this.buffer.splice(0, this.buffer.length);
       events.forEach((e2, i2) => {
         e2.batch_event_index = i2;
@@ -1235,39 +1401,12 @@ var OnrwayAnalytics = (() => {
       this.log("Flushing key event:", event.event_name);
       this.sendBatch([event], 0);
     }
-    async sendBatch(events, retryCount) {
-      if (events.length === 0) return;
-      const apiKey = this.resolveApiKey();
-      if (!apiKey) {
-        this.log("No API key configured, dropping events");
-        for (const event of events) {
-          StorageQueue.enqueue(event);
-        }
-        return;
-      }
-      const payload = this.buildPayload(events);
+    sendBatch(events, _retryCount) {
+      if (!events.length || this.config.disableServer) return;
       try {
-        await Sender.send(payload, this.config.serverUrl, apiKey);
-        this.log(`Batch sent successfully: ${events.length} events`);
+        this.delivery.enqueue(this.buildPayload(events));
       } catch (error) {
-        this.log(`Batch send failed (attempt ${retryCount + 1}/${this.config.maxRetryCount + 1}):`, error);
-        if (retryCount < this.config.maxRetryCount) {
-          const delay = 1e3 * Math.pow(2, retryCount);
-          this.log(`Retrying in ${delay}ms...`);
-          this.retrying += 1;
-          setTimeout(() => {
-            this.retrying -= 1;
-            this.sendBatch(events, retryCount + 1);
-            if (this.buffer.length > 0) {
-              this.scheduleBufferFlush();
-            }
-          }, delay);
-        } else {
-          this.log("Max retries reached, persisting events to localStorage");
-          for (const event of events) {
-            StorageQueue.enqueue(event);
-          }
-        }
+        this.log("Unable to prepare analytics payload:", error);
       }
     }
     buildPayload(events) {
@@ -1281,30 +1420,15 @@ var OnrwayAnalytics = (() => {
         events
       };
     }
-    recoverFailedEvents() {
-      if (this.config.disableServer) return;
-      if (!this.sampled) return;
-      const failedEvents = StorageQueue.recover();
-      if (failedEvents.length > 0) {
-        this.log(`Recovered ${failedEvents.length} failed events from storage`);
-        for (const event of failedEvents) {
-          event.batch_ordering_id = this.generateBatchOrderingId();
-          event.batch_page_id = this.batchPageId;
-          event.batch_event_index = 0;
-        }
-        const batchSize = this.config.bufferMaxSize;
-        for (let i2 = 0; i2 < failedEvents.length; i2 += batchSize) {
-          const batch = failedEvents.slice(i2, i2 + batchSize);
-          batch.forEach((e2, idx) => {
-            e2.batch_event_index = idx;
-          });
-          this.sendBatch(batch, 0);
-        }
-      }
-    }
     destroy() {
+      this.flushBuffer();
+      this.delivery.destroy();
+      if (this.visibilityHandler) {
+        document.removeEventListener("visibilitychange", this.visibilityHandler);
+        window.removeEventListener("pageshow", this.visibilityHandler);
+        this.visibilityHandler = null;
+      }
       if (this.unloadHandler) {
-        window.removeEventListener("beforeunload", this.unloadHandler);
         window.removeEventListener("pagehide", this.unloadHandler);
         this.unloadHandler = null;
       }
@@ -1315,41 +1439,22 @@ var OnrwayAnalytics = (() => {
     }
     registerBeforeUnload() {
       if (!isBrowser() || this.config.disableServer) return;
-      const handler = () => {
-        if (this.buffer.length === 0) return;
-        const events = this.buffer.splice(0, this.buffer.length);
-        events.forEach((e2, i2) => {
-          e2.batch_event_index = i2;
-        });
-        const apiKey = this.resolveApiKey();
-        if (!apiKey) return;
-        const payload = this.buildPayload(events);
-        try {
-          if (typeof navigator !== "undefined" && navigator.sendBeacon) {
-            const url = `${this.config.serverUrl}${this.config.serverUrl.includes("?") ? "&" : "?"}apiKey=${encodeURIComponent(apiKey)}`;
-            const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
-            const success = navigator.sendBeacon(url, blob);
-            if (!success) throw new Error("sendBeacon rejected");
-          } else {
-            try {
-              const xhr = new XMLHttpRequest();
-              xhr.open("POST", this.config.serverUrl, false);
-              xhr.setRequestHeader("Content-Type", "application/json");
-              xhr.setRequestHeader("apiKey", apiKey);
-              xhr.timeout = 2e3;
-              xhr.send(JSON.stringify(payload));
-            } catch {
-            }
-          }
-        } catch {
-          for (const event of events) {
-            StorageQueue.enqueue(event);
-          }
+      this.unloadHandler = () => {
+        this.delivery.setHidden(true);
+        this.flushBuffer();
+        this.delivery.flushHidden();
+      };
+      this.visibilityHandler = () => {
+        const hidden = document.visibilityState === "hidden";
+        this.delivery.setHidden(hidden);
+        if (hidden) {
+          this.flushBuffer();
+          this.delivery.flushHidden();
         }
       };
-      this.unloadHandler = handler;
-      window.addEventListener("beforeunload", handler);
-      window.addEventListener("pagehide", handler);
+      window.addEventListener("pagehide", this.unloadHandler);
+      document.addEventListener("visibilitychange", this.visibilityHandler);
+      window.addEventListener("pageshow", this.visibilityHandler);
     }
     trackPageView() {
       if (!isBrowser()) return;
@@ -1364,6 +1469,50 @@ var OnrwayAnalytics = (() => {
   function createAnalytics(config) {
     return new Analytics(config);
   }
+
+  // src/core/storage.ts
+  var MAX_EVENT_AGE_MS = 24 * 60 * 60 * 1e3;
+  var StorageQueue = class _StorageQueue {
+    static enqueue(event) {
+      try {
+        const queue = _StorageQueue.readQueue();
+        queue.push({ event, storedAt: Date.now() });
+        while (queue.length > MAX_STORAGE_ITEMS) {
+          queue.shift();
+        }
+        safeLocalStorageSet(STORAGE_KEYS.FAILED_QUEUE, JSON.stringify(queue));
+      } catch {
+      }
+    }
+    static recover() {
+      try {
+        const queue = _StorageQueue.readQueue();
+        _StorageQueue.clear();
+        const now = Date.now();
+        const events = queue.filter((item) => now - item.storedAt < MAX_EVENT_AGE_MS).map((item) => item.event);
+        return events;
+      } catch {
+        return [];
+      }
+    }
+    static clear() {
+      safeLocalStorageRemove(STORAGE_KEYS.FAILED_QUEUE);
+    }
+    static getQueueSize() {
+      return _StorageQueue.readQueue().length;
+    }
+    static readQueue() {
+      try {
+        const raw = safeLocalStorageGet(STORAGE_KEYS.FAILED_QUEUE);
+        if (!raw) return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) return [];
+        return parsed;
+      } catch {
+        return [];
+      }
+    }
+  };
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.js.map