@clipto/reporter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clipto, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @clipto/reporter
+
+通用数据上报 SDK:攒批、重试、有界队列、崩溃恢复,浏览器与 Node 双端通用。
+
+- **浏览器端**:`fetch(keepalive)` 发送 + `sendBeacon` 退出兜底,队列持久化到 IndexedDB(Dexie,不支持时降级 localStorage)
+- **Node 端**:axios 发送,队列持久化到 JSON 文件(conf,内部原子写,`persistDir` 配置后启用)
+- **内置组件**:不手写底层 IO,双端差异仅发送与持久化,核心(入队 / 攒批 / 重试 / 溢出策略)平台无关
+- 依赖按需动态加载:浏览器不会加载 axios / conf,Node 不会加载 Dexie
+
+## 安装
+
+```bash
+npm install @clipto/reporter
+```
+
+## 快速上手
+
+### 浏览器
+
+```ts
+import { Reporter } from '@clipto/reporter';
+
+const reporter = new Reporter({
+  endpoint: 'https://reporter.example.com/api/events',
+  baseProperties: { productId: 'my.app' },
+});
+
+reporter.track('user_action', { action: 'click', eid: 'btn' });
+reporter.flush(); // 立即冲刷(跳过退避),页面卸载时 SDK 自动走 sendBeacon 兜底
+```
+
+### Node
+
+```ts
+import { Reporter } from '@clipto/reporter';
+
+const reporter = new Reporter({
+  endpoint: 'https://reporter.example.com/api/events',
+  platform: 'node', // 不传则按 typeof window 自动探测
+  persistDir: './data', // 配置后待发队列落盘,进程重启后恢复重发;不传仅内存
+});
+
+reporter.track('conversion', { conversionType: 'purchase', value: 99 });
+await reporter.dispose(); // 停止并兜底 flush(进程退出信号自动触发)
+```
+
+### 双端注入自定义实现
+
+```ts
+new Reporter({
+  endpoint,
+  transport: { send: (events) => http.post(endpoint, events) }, // 自定义发送
+  storage: { save, load, clear }, // 自定义持久化
+});
+```
+
+## 配置项
+
+| 配置 | 默认 | 说明 |
+| --- | --- | --- |
+| `endpoint` | 必填 | 上报端点 |
+| `platform` | 自动探测 | `'browser'` / `'node'`,驱动内置发送与持久化实现 |
+| `flushInterval` | 2000 | 攒批窗口(ms),0 表示关闭批量即时发送 |
+| `maxBatchSize` | 10 | 单批最大条数,达到即刷 |
+| `maxBatchBytes` | 64KB | 单批最大字节数,达到即刷 |
+| `maxQueueSize` | 1000 | 队列最大条数 |
+| `overflowPolicy` | `'drop-oldest'` | 队列溢出:`'drop-oldest'` / `'drop-newest'` / `'flush-now'` |
+| `maxAttempts` | 3 | 单事件最大发送尝试次数,超限丢弃 |
+| `backoffMs` | 1000 | 失败重发退避基数(ms),按 2^n 指数增长;`flush()` 跳过退避 |
+| `baseProperties` | `{}` | 合并进每个事件 properties 的公共业务字段 |
+| `context` | 无 | 上下文采集函数,每次入队实时调用并合并进 properties |
+| `enrich` | 无 | 逐事件顶层字段补充(`sessionId` / `userId` / `deviceId` / `context`),每次入队实时调用 |
+| `flushOnExit` | true | 退出兜底 flush(浏览器 sendBeacon / Node 进程信号) |
+| `persist` | true | 浏览器端:队列持久化到 IndexedDB |
+| `persistDir` | 无 | Node 端:持久化目录,设置后落盘 |
+| `autoPageView` | false | 浏览器端:自动上报 page_view(初始化 + 页面重新可见) |
+| `headers` | 无 | 自定义请求头(内置传输实现使用) |
+| `debug` | false | 调试日志 |
+| `transport` / `storage` | 无 | 注入自定义发送 / 持久化实现 |
+| `onFlushed` / `onFailed` / `onDropped` | 无 | 批次成功 / 失败 / 事件丢弃(重试耗尽 / 溢出 / 非法)钩子 |
+
+## API
+
+```ts
+interface IReporter {
+  /** 上报一条事件,返回事件 id(dispose 后或非法事件返回空串);immediate 跳过攒批立即发送 */
+  track(name: string, properties?: Record<string, unknown>, options?: {
+    immediate?: boolean;
+    timestamp?: number;
+    category?: string; // 事件类别顶层字段,默认 'custom'
+  }): string;
+  /** 立即冲刷队列(跳过退避等待),并等待在途批次完成 */
+  flush(): Promise<void>;
+  /** 队列中待发条数 */
+  readonly size: number;
+  /** 停止并兜底 flush(flushOnExit),之后拒绝新事件 */
+  dispose(): Promise<void>;
+}
+```
+
+## 事件数据结构
+
+事件顶层字段与历史 SDK(renderer `event-tracker-sdk`)保持一致,上报信封:
+
+```jsonc
+{
+  "events": [
+    {
+      "id": "evt_...",
+      "eventName": "user_action", // SDK 内部字段名 name,序列化输出为 eventName
+      "timestamp": 1756200000000,
+      "sessionId": "session_...", // enrich 提供,缺省核心按实例生成
+      "userId": null,             // enrich 提供,缺省 null
+      "deviceId": "device_...",   // enrich 提供,缺省核心按实例生成
+      "properties": { /* baseProperties + context + 业务属性 */ },
+      "category": "custom",       // track options 提供,默认 'custom'
+      "context": {}               // enrich 提供(页面 / 用户 / 浏览器 / 屏幕 / 视口)
+    }
+  ],
+  "metadata": { "sdkVersion": "1.0.0", "timestamp": 1756200000000, "batchId": "evt_..." }
+}
+```
+
+事件 id 与 batchId 均为 `evt_${时间戳}_${随机串}` 格式;`attempts` 为 SDK 内部字段,不上报。
+
+## 注意事项
+
+- **conf 与打包器**:Node 持久化依赖 `conf`(含 Node 内置模块),源码中 `import('conf')` 带 `webpackIgnore` 注释,消费方 webpack 等打包器会跳过它,由 Node 运行时直接解析;浏览器端永不执行该分支。
+- **依赖按需加载**:`axios` / `conf` 仅在 Node 分支动态加载,`dexie` 仅在浏览器分支动态加载。
+- **dispose 后不可再用**:`dispose()` 执行退出兜底 flush 并拒绝新事件(返回空串)。

package/dist/index.cjs

@@ -0,0 +1,557 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Reporter: () => Reporter,
+  createBrowserStorage: () => createBrowserStorage,
+  createBrowserTransport: () => createBrowserTransport,
+  createLocalStorageStorage: () => createLocalStorageStorage,
+  createNodeStorage: () => createNodeStorage,
+  createNodeTransport: () => createNodeTransport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/id.ts
+function generateEventId() {
+  return `evt_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+
+// src/builtins.ts
+var SDK_VERSION = "1.0.0";
+var DB_NAME = "CliptoReportDB";
+var STORE_NAME = "clipto-reporting";
+var QUEUE_KEY = "pending";
+var LS_KEY = "clipto_report_pending_queue";
+function buildPayload(events) {
+  return {
+    // attempts 为 SDK 内部字段,不上报;name 输出为 eventName(对齐旧 SDK)
+    events: events.map(
+      ({
+        id,
+        name,
+        timestamp,
+        sessionId,
+        userId,
+        deviceId,
+        properties,
+        category,
+        context
+      }) => ({
+        id,
+        eventName: name,
+        timestamp,
+        sessionId,
+        userId,
+        deviceId,
+        properties,
+        category,
+        context
+      })
+    ),
+    metadata: {
+      sdkVersion: SDK_VERSION,
+      timestamp: Date.now(),
+      batchId: generateEventId()
+      // 与事件 id 同格式(对齐旧 SDK)
+    }
+  };
+}
+function createBrowserTransport(endpoint, headers) {
+  const commonHeaders = {
+    "Content-Type": "application/json",
+    ...headers ?? {}
+  };
+  return {
+    async send(events) {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: commonHeaders,
+        body: JSON.stringify(buildPayload(events)),
+        keepalive: true
+      });
+      if (!response.ok) {
+        throw new Error(`report send failed: HTTP ${response.status}`);
+      }
+    },
+    sendSync(events) {
+      if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
+        return false;
+      }
+      try {
+        const blob = new Blob([JSON.stringify(buildPayload(events))], {
+          type: "application/json"
+        });
+        return navigator.sendBeacon(endpoint, blob);
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+async function createNodeTransport(endpoint, headers) {
+  const { default: axios } = await import("axios");
+  return {
+    async send(events) {
+      await axios.post(endpoint, buildPayload(events), {
+        headers,
+        timeout: 1e4
+      });
+    }
+  };
+}
+function createLocalStorageStorage() {
+  return {
+    save(events) {
+      try {
+        localStorage.setItem(LS_KEY, JSON.stringify(events));
+      } catch {
+      }
+    },
+    load() {
+      try {
+        const text = localStorage.getItem(LS_KEY);
+        return text ? JSON.parse(text) : [];
+      } catch {
+        return [];
+      }
+    },
+    clear() {
+      try {
+        localStorage.removeItem(LS_KEY);
+      } catch {
+      }
+    }
+  };
+}
+async function createBrowserStorage() {
+  try {
+    const { default: Dexie } = await import("dexie");
+    const db = new Dexie(DB_NAME);
+    db.version(1).stores({ queue: "key" });
+    await db.open();
+    const table = db.table(
+      "queue"
+    );
+    return {
+      async save(events) {
+        await table.put({ key: QUEUE_KEY, events });
+      },
+      async load() {
+        const row = await table.get(QUEUE_KEY);
+        return row ? row.events : [];
+      },
+      async clear() {
+        await table.delete(QUEUE_KEY);
+      }
+    };
+  } catch {
+    return createLocalStorageStorage();
+  }
+}
+async function createNodeStorage(persistDir) {
+  const { default: Conf } = await import(
+    /* webpackIgnore: true */
+    "conf"
+  );
+  const store = new Conf({
+    configName: STORE_NAME,
+    // 落盘为 persistDir/clipto-reporting.json
+    cwd: persistDir
+  });
+  return {
+    save(events) {
+      store.set(QUEUE_KEY, events);
+    },
+    load() {
+      return store.get(QUEUE_KEY) ?? [];
+    },
+    clear() {
+      store.delete(QUEUE_KEY);
+    }
+  };
+}
+
+// src/reporter.ts
+var DEFAULT_FLUSH_INTERVAL = 2e3;
+var DEFAULT_MAX_BATCH_SIZE = 10;
+var DEFAULT_MAX_BATCH_BYTES = 64 * 1024;
+var DEFAULT_MAX_QUEUE_SIZE = 1e3;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_BACKOFF_MS = 1e3;
+var STORAGE_WRITE_THROTTLE_MS = 500;
+var Reporter = class {
+  constructor(options) {
+    /** 会话 / 设备 id 兜底:enrich 未提供时按实例生成(对齐旧 SDK 格式) */
+    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    this.deviceId = `device_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    /** 待发队列(内存中的事实源,持久化是它的影子) */
+    this.queue = [];
+    this.flushTimer = null;
+    this.retryTimer = null;
+    this.persistTimer = null;
+    this.persistDirty = false;
+    this.flushPromise = null;
+    this.disposed = false;
+    this.onExit = () => {
+      this.fire(this.dispose());
+    };
+    this.onPageHide = () => {
+      this.fire(this.dispose());
+    };
+    this.onVisibilityChange = () => {
+      if (document.visibilityState === "hidden") {
+        this.fire(this.flush());
+      } else if (this.opts.autoPageView) {
+        this.track("page_view");
+      }
+    };
+    if (!options.endpoint) {
+      throw new Error("Reporter: endpoint \u4E3A\u5FC5\u586B\u9879");
+    }
+    this.opts = options;
+    this.platform = options.platform ?? (typeof window !== "undefined" ? "browser" : "node");
+    this.flushInterval = options.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+    this.maxBatchSize = options.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+    this.maxBatchBytes = options.maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES;
+    this.maxQueueSize = options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+    this.overflowPolicy = options.overflowPolicy ?? "drop-oldest";
+    this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    this.backoffMs = options.backoffMs ?? DEFAULT_BACKOFF_MS;
+    this.flushOnExit = options.flushOnExit ?? true;
+    if (options.transport) {
+      this.transportPromise = Promise.resolve(options.transport);
+    } else if (this.platform === "browser") {
+      this.transportPromise = Promise.resolve(
+        createBrowserTransport(options.endpoint, options.headers)
+      );
+    } else {
+      this.transportPromise = createNodeTransport(
+        options.endpoint,
+        options.headers
+      );
+    }
+    if (options.storage) {
+      this.storagePromise = Promise.resolve(options.storage);
+    } else if (options.persist === false) {
+      this.storagePromise = Promise.resolve(void 0);
+    } else if (this.platform === "browser") {
+      this.storagePromise = createBrowserStorage();
+    } else if (options.persistDir) {
+      this.storagePromise = createNodeStorage(options.persistDir);
+    } else {
+      this.storagePromise = Promise.resolve(void 0);
+    }
+    this.fire(this.init());
+  }
+  track(name, properties, options) {
+    if (this.disposed) {
+      this.log("dispose \u540E\u5FFD\u7565\u65B0\u4E8B\u4EF6:", name);
+      return "";
+    }
+    const enriched = this.opts.enrich?.() ?? {};
+    const event = {
+      id: generateEventId(),
+      name,
+      properties: {
+        ...this.opts.baseProperties ?? {},
+        ...this.opts.context?.() ?? {},
+        ...properties ?? {}
+      },
+      timestamp: options?.timestamp ?? Date.now(),
+      attempts: 0,
+      sessionId: enriched.sessionId ?? this.sessionId,
+      userId: enriched.userId ?? null,
+      deviceId: enriched.deviceId ?? this.deviceId,
+      category: options?.category ?? "custom",
+      context: enriched.context ?? {}
+    };
+    if (typeof name !== "string" || name.length === 0) {
+      this.opts.onDropped?.([event], "invalid");
+      return "";
+    }
+    if (options?.immediate) {
+      this.fire(this.sendBatch([event]));
+      return event.id;
+    }
+    this.enqueue(event);
+    if (this.flushInterval <= 0) {
+      this.fire(this.flush());
+    } else {
+      this.scheduleFlush();
+    }
+    return event.id;
+  }
+  flush() {
+    if (!this.flushPromise) {
+      if (this.retryTimer) {
+        clearTimeout(this.retryTimer);
+        this.retryTimer = null;
+      }
+      this.flushPromise = this.drain().finally(() => {
+        this.flushPromise = null;
+      });
+    }
+    return this.flushPromise;
+  }
+  get size() {
+    return this.queue.length;
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    if (this.platform === "browser") {
+      window.removeEventListener("pagehide", this.onPageHide);
+      document.removeEventListener("visibilitychange", this.onVisibilityChange);
+    } else {
+      const exitProcess = this.getExitProcess();
+      exitProcess.off("beforeExit", this.onExit);
+      exitProcess.off("SIGINT", this.onExit);
+      exitProcess.off("SIGTERM", this.onExit);
+    }
+    const transport = await this.transportPromise;
+    if (this.queue.length === 0) {
+      if (this.persistDirty) {
+        await this.persistNow([]);
+      }
+      return;
+    }
+    if (this.flushOnExit) {
+      const pending = this.queue.splice(0);
+      if (transport.sendSync?.(pending) ?? false) {
+        this.opts.onFlushed?.(pending);
+        await this.persistNow([]);
+        return;
+      }
+      try {
+        await transport.send(pending);
+        this.opts.onFlushed?.(pending);
+        await this.persistNow([]);
+      } catch (error) {
+        this.opts.onFailed?.(pending, error);
+        this.queue.push(...pending);
+        await this.persistNow();
+      }
+      return;
+    }
+    if (this.persistDirty) {
+      await this.persistNow();
+    }
+  }
+  /** 异步初始化:创建内置持久化、恢复上次会话队列、挂载退出兜底 */
+  async init() {
+    this.storage = await this.storagePromise;
+    if (this.disposed) return;
+    if (this.storage) {
+      try {
+        const restored = await this.storage.load();
+        if (restored.length > 0) {
+          this.enqueueRestored(restored);
+        }
+      } catch (error) {
+        this.log("restore pending queue failed:", error);
+      }
+    }
+    if (this.disposed) return;
+    if (this.platform === "browser") {
+      if (this.flushOnExit) {
+        window.addEventListener("pagehide", this.onPageHide);
+      }
+      if (this.flushOnExit || this.opts.autoPageView) {
+        document.addEventListener("visibilitychange", this.onVisibilityChange);
+      }
+      if (this.opts.autoPageView) {
+        this.track("page_view");
+      }
+    } else if (this.flushOnExit) {
+      const exitProcess = this.getExitProcess();
+      exitProcess.once("beforeExit", this.onExit);
+      exitProcess.once("SIGINT", this.onExit);
+      exitProcess.once("SIGTERM", this.onExit);
+    }
+    if (this.queue.length > 0) {
+      this.scheduleFlush();
+      this.schedulePersist();
+    }
+  }
+  /** 恢复队列入队:历史事件放队头保证先到先发,超限按溢出丢弃 */
+  enqueueRestored(events) {
+    let accepted = events;
+    if (accepted.length > this.maxQueueSize) {
+      this.opts.onDropped?.(accepted.slice(this.maxQueueSize), "overflow");
+      accepted = accepted.slice(0, this.maxQueueSize);
+    }
+    this.queue.unshift(...accepted);
+  }
+  enqueue(event) {
+    if (this.queue.length >= this.maxQueueSize) {
+      if (this.overflowPolicy === "drop-newest") {
+        this.opts.onDropped?.([event], "overflow");
+        return;
+      }
+      if (this.overflowPolicy === "drop-oldest") {
+        this.opts.onDropped?.([this.queue.shift()], "overflow");
+      } else {
+        this.fire(this.flush());
+      }
+    }
+    this.queue.push(event);
+    this.schedulePersist();
+  }
+  /** 攒批定时:延迟上报的实现,窗口内事件合并为一批 */
+  scheduleFlush() {
+    if (this.flushTimer || this.disposed || this.flushInterval <= 0) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      if (this.queue.length > 0) {
+        this.fire(this.flush());
+      }
+    }, this.flushInterval);
+  }
+  /** 串行清空队列;失败批次重新入队后由 retryTimer 再次触发 drain */
+  async drain() {
+    while (!this.disposed && !this.retryTimer && this.queue.length > 0) {
+      await this.sendBatch(this.takeBatch());
+    }
+  }
+  /** 取一批:受条数 / 字节数限制;首条必取,避免单事件超 maxBatchBytes 时队列卡死 */
+  takeBatch() {
+    const batch = [];
+    let bytes = 0;
+    while (this.queue.length > 0 && batch.length < this.maxBatchSize) {
+      const size = JSON.stringify(this.queue[0]).length;
+      if (batch.length > 0 && bytes + size > this.maxBatchBytes) break;
+      batch.push(this.queue.shift());
+      bytes += size;
+    }
+    return batch;
+  }
+  async sendBatch(batch) {
+    const transport = await this.transportPromise;
+    try {
+      await transport.send(batch);
+      this.opts.onFlushed?.(batch);
+      this.schedulePersist();
+    } catch (error) {
+      this.opts.onFailed?.(batch, error);
+      this.log("send batch failed:", error);
+      const updated = batch.map((event) => ({
+        ...event,
+        attempts: event.attempts + 1
+      }));
+      const retryable = updated.filter(
+        (event) => event.attempts < this.maxAttempts
+      );
+      const dead = updated.filter(
+        (event) => event.attempts >= this.maxAttempts
+      );
+      if (dead.length > 0) {
+        this.opts.onDropped?.(dead, "max-attempts");
+      }
+      if (retryable.length > 0) {
+        this.queue.unshift(...retryable);
+        this.schedulePersist();
+        this.scheduleRetry(retryable);
+      }
+    }
+  }
+  /** 失败退避:按批次内最大 attempts 计 2^n 指数增长,避免失败批次频繁重试 */
+  scheduleRetry(retryable) {
+    if (this.retryTimer) return;
+    const maxAttemptsInBatch = Math.max(
+      ...retryable.map((event) => event.attempts)
+    );
+    const delay = this.backoffMs * 2 ** (maxAttemptsInBatch - 1);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.fire(this.flush());
+    }, delay);
+  }
+  /** 持久化节流:窗口内多次变更只落盘一次,避免每次入队全量序列化 */
+  schedulePersist() {
+    if (!this.storage) return;
+    this.persistDirty = true;
+    if (this.persistTimer) return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      if (!this.persistDirty) return;
+      this.persistDirty = false;
+      this.fire(this.persistNow());
+    }, STORAGE_WRITE_THROTTLE_MS);
+  }
+  async persistNow(events = this.queue) {
+    if (!this.storage) return;
+    try {
+      await this.storage.save(events);
+    } catch (error) {
+      this.log("persist queue failed:", error);
+    }
+  }
+  log(...args) {
+    if (this.opts.debug) {
+      console.log("[reporter]", ...args);
+    }
+  }
+  /**
+   * Node 进程退出事件句柄:Electron 渲染进程 typings 里 process 只声明了 'loaded'
+   * 事件,与 @types/node 不一致,显式收窄到本 SDK 用到的信号,兼容两端编译器
+   */
+  getExitProcess() {
+    return process;
+  }
+  /** 安全触发异步任务:吞掉 rejection,避免未处理异常 */
+  fire(promise) {
+    promise.catch((error) => {
+      this.log("async task failed:", error);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Reporter,
+  createBrowserStorage,
+  createBrowserTransport,
+  createLocalStorageStorage,
+  createNodeStorage,
+  createNodeTransport
+});
+//# sourceMappingURL=index.cjs.map