@brunyee-studio/onus-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,588 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/dsn.ts
+function parseDsn(raw) {
+  if (!raw) return null;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+  const key = url.username.split(":")[0] ?? "";
+  if (!key) return null;
+  const segments = url.pathname.split("/").filter((s) => s !== "");
+  if (segments.length !== 1) return null;
+  const projectId = segments[0] ?? "";
+  if (!/^\d+$/.test(projectId)) return null;
+  return {
+    key,
+    host: url.host,
+    projectId,
+    envelopeUrl: `${url.protocol}//${url.host}/api/${projectId}/envelope/`,
+    origin: url.origin
+  };
+}
+function buildSentryAuthHeader(dsn, clientVersion) {
+  return `Sentry sentry_key=${dsn.key}, sentry_version=7, sentry_client=onus.javascript/${clientVersion}`;
+}
+var init_dsn = __esm({
+  "src/dsn.ts"() {
+    "use strict";
+  }
+});
+
+// src/envelope.ts
+function eventId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function itemHeader(type, length) {
+  const header = { type, length };
+  return JSON.stringify(header);
+}
+function buildEnvelope(header, items) {
+  const parts = [JSON.stringify(header)];
+  for (const item of items) {
+    parts.push(itemHeader(item.type, item.type === "replay_recording" ? item.length : void 0));
+    if (item.type === "replay_recording") {
+      parts.push(item.payload);
+    } else {
+      parts.push(JSON.stringify(item.payload));
+    }
+  }
+  const serialized = parts.join("\n");
+  if (new TextEncoder().encode(serialized).byteLength > MAX_ENVELOPE_BYTES) {
+    return null;
+  }
+  return serialized;
+}
+function withReplayContext(event, replayId) {
+  if (!replayId || !REPLAY_ID_RE.test(replayId)) return event;
+  const contexts = {
+    ...event["contexts"],
+    replay: { replay_id: replayId }
+  };
+  return { ...event, contexts };
+}
+var MAX_ENVELOPE_BYTES, REPLAY_ID_RE;
+var init_envelope = __esm({
+  "src/envelope.ts"() {
+    "use strict";
+    MAX_ENVELOPE_BYTES = 1024 * 1024;
+    REPLAY_ID_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+  }
+});
+
+// src/transport.ts
+async function gzipText(text) {
+  const CS = globalThis.CompressionStream;
+  if (!CS || typeof Response === "undefined") return null;
+  try {
+    const body = new Response(text).body;
+    if (!body) return null;
+    const buf = await new Response(body.pipeThrough(new CS("gzip"))).arrayBuffer();
+    return new Uint8Array(buf);
+  } catch {
+    return null;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function sendEnvelope(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const maxRetries = opts.maxRetries ?? 1;
+  const backoffMs = opts.backoffMs ?? 500;
+  const sleep = opts.delayImpl ?? delay;
+  const gz = await gzipText(opts.body);
+  const headers = {
+    "Content-Type": "application/x-sentry-envelope",
+    "X-Sentry-Auth": opts.authHeader,
+    ...gz ? { "Content-Encoding": "gzip" } : {}
+  };
+  for (let attempt = 0; ; attempt++) {
+    let res;
+    try {
+      res = await fetchImpl(opts.url, {
+        method: "POST",
+        headers,
+        body: gz ?? opts.body,
+        // Analytics-style telemetry: never block page unload on the response.
+        keepalive: true
+      });
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : "network error" };
+    }
+    if (res.ok) return { ok: true, status: res.status };
+    if (res.status === 429 && attempt < maxRetries) {
+      const retryAfter = Number(res.headers.get("retry-after") ?? "");
+      const wait = Math.min(
+        Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : backoffMs * (attempt + 1),
+        1e4
+      );
+      await sleep(wait);
+      continue;
+    }
+    if (res.status === 429) {
+      const retryAfter = Number(res.headers.get("retry-after") ?? "");
+      return {
+        ok: false,
+        status: 429,
+        retryAfterSeconds: Number.isFinite(retryAfter) ? retryAfter : void 0,
+        error: "rate limited"
+      };
+    }
+    return { ok: false, status: res.status, error: `ingest responded ${res.status}` };
+  }
+}
+var init_transport = __esm({
+  "src/transport.ts"() {
+    "use strict";
+  }
+});
+
+// src/replay.ts
+var replay_exports = {};
+__export(replay_exports, {
+  REPLAY_ID_RE: () => REPLAY_ID_RE,
+  activeReplayId: () => activeReplayId,
+  emitSegment: () => emitSegment,
+  parseDsn: () => parseDsn,
+  resetReplayForTest: () => resetReplayForTest,
+  startSessionReplay: () => startSessionReplay,
+  stopSessionReplay: () => stopSessionReplay
+});
+async function startSessionReplay(options = {}) {
+  if (active) return active.replayId;
+  const dsn = parseDsn(options.dsn);
+  if (!dsn) return null;
+  const replayId = eventId().replace(/-/g, "");
+  const state2 = { replayId, stop: null, buffer: [], timer: null };
+  active = state2;
+  let record = null;
+  if (options.recorderFactory) {
+    let recorder;
+    try {
+      recorder = await options.recorderFactory();
+    } catch {
+      active = null;
+      return null;
+    }
+    if (!recorder) {
+      active = null;
+      return null;
+    }
+    record = (_opts) => {
+      recorder.wire?.(_opts);
+      return () => recorder.stop();
+    };
+  } else {
+    try {
+      const mod = await import("rrweb");
+      const fn = mod.record;
+      if (typeof fn !== "function") {
+        active = null;
+        return null;
+      }
+      record = fn;
+    } catch {
+      active = null;
+      return null;
+    }
+  }
+  const segmentIntervalMs = options.segmentIntervalMs ?? 5e3;
+  const maxEventsPerSegment = options.maxEventsPerSegment ?? 100;
+  const narrowedDsn = dsn;
+  async function flushBuffer() {
+    if (state2.timer !== null) {
+      clearTimeout(state2.timer);
+      state2.timer = null;
+    }
+    if (state2.buffer.length === 0) return;
+    const events = state2.buffer;
+    state2.buffer = [];
+    await emitSegment(
+      narrowedDsn,
+      options,
+      state2,
+      events,
+      ++segmentCounter,
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+  const stop = record({
+    emit: (event) => {
+      state2.buffer.push(event);
+      if (state2.buffer.length >= maxEventsPerSegment) {
+        void flushBuffer();
+        return;
+      }
+      if (state2.timer === null) {
+        state2.timer = setTimeout(() => {
+          state2.timer = null;
+          void flushBuffer();
+        }, segmentIntervalMs);
+      }
+    },
+    ...options.recordOptions
+  });
+  state2.stop = typeof stop === "function" ? () => {
+    stop();
+    void flushBuffer();
+  } : null;
+  if (typeof window !== "undefined") {
+    window.addEventListener(
+      "pagehide",
+      () => {
+        void flushBuffer();
+      },
+      { once: true }
+    );
+  }
+  return replayId;
+}
+function stopSessionReplay() {
+  const stopping = active;
+  active = null;
+  if (!stopping) return;
+  stopping.stop?.();
+  if (stopping.timer !== null) {
+    clearTimeout(stopping.timer);
+    stopping.timer = null;
+  }
+  stopping.buffer.length = 0;
+}
+function activeReplayId() {
+  return active?.replayId ?? null;
+}
+function resetReplayForTest() {
+  active?.stop?.();
+  active = null;
+  segmentCounter = 0;
+}
+function resolveSessionId(options) {
+  const raw = typeof options.sessionId === "function" ? options.sessionId() : options.sessionId;
+  return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+async function emitSegment(dsn, options, state2, event, segmentId, timestamp) {
+  const recordingText = `{"segment_id":${segmentId}}
+${JSON.stringify(event ?? [])}`;
+  const sessionId = resolveSessionId(options);
+  const items = [
+    {
+      type: "replay_event",
+      payload: {
+        segment_id: segmentId,
+        replay_id: state2.replayId,
+        timestamp,
+        ...sessionId ? { session_id: sessionId } : {},
+        ...options.environment ? { environment: options.environment } : {},
+        ...options.release ? { release: options.release } : {}
+      }
+    },
+    {
+      type: "replay_recording",
+      payload: recordingText,
+      // Byte length (not UTF-16 code units) — the server validates the
+      // declared length against payload bytes.
+      length: new TextEncoder().encode(recordingText).length
+    }
+  ];
+  const serialized = buildEnvelope(
+    {
+      event_id: eventId(),
+      sent_at: timestamp,
+      sdk: { name: SDK_NAME, version: "0.1.0" }
+    },
+    items
+  );
+  if (!serialized) return false;
+  const result = await sendEnvelope({
+    url: dsn.envelopeUrl,
+    authHeader: `Sentry sentry_key=${dsn.key}, sentry_version=7, sentry_client=onus.javascript/0.1.0`,
+    body: serialized,
+    fetchImpl: options.fetchImpl
+  });
+  return result.ok;
+}
+var active, segmentCounter;
+var init_replay = __esm({
+  "src/replay.ts"() {
+    "use strict";
+    init_envelope();
+    init_transport();
+    init_dsn();
+    init_client();
+    init_envelope();
+    init_dsn();
+    active = null;
+    segmentCounter = 0;
+  }
+});
+
+// src/client.ts
+function debugLog(...args) {
+  if (false) {
+    console.debug("[onus]", ...args);
+  }
+}
+function dispatch(items, eventIdValue) {
+  if (!state?.dsn) return Promise.resolve(false);
+  const serialized = buildEnvelope(
+    {
+      event_id: eventIdValue,
+      sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+      sdk: { name: SDK_NAME, version: SDK_VERSION }
+    },
+    items
+  );
+  if (!serialized) {
+    debugLog("envelope exceeded 1 MiB cap; dropped", eventIdValue);
+    return Promise.resolve(false);
+  }
+  const send = sendEnvelope({
+    url: state.dsn.envelopeUrl,
+    authHeader: state.authHeader,
+    body: serialized,
+    fetchImpl: state.options.fetchImpl
+  });
+  const tracked = send.then((r) => {
+    if (!r.ok) debugLog("send failed", r.status, r.error);
+    return r.ok;
+  });
+  pending.push(tracked);
+  if (pending.length > MAX_PENDING) pending.shift();
+  return tracked;
+}
+function init(options) {
+  const dsn = parseDsn(options.dsn);
+  if (!dsn) {
+    debugLog("no valid dsn; SDK is disabled (no network sends)");
+  }
+  state = {
+    dsn,
+    options,
+    authHeader: dsn ? buildSentryAuthHeader(dsn, SDK_VERSION) : "",
+    replayId: null
+  };
+  autoReplayStart = null;
+  if (options.replays && options.replays.enabled !== false && dsn) {
+    autoReplayStart = startAutoReplay(options.replays, options);
+  }
+}
+async function startAutoReplay(replays, options) {
+  try {
+    const rate = typeof replays.sampleRate === "number" && replays.sampleRate >= 0 && replays.sampleRate <= 1 ? replays.sampleRate : 1;
+    if (Math.random() >= rate) return;
+    const replay = await Promise.resolve().then(() => (init_replay(), replay_exports));
+    const replayId = await replay.startSessionReplay({
+      dsn: options.dsn,
+      environment: replays.environment ?? options.environment,
+      release: replays.release ?? options.release,
+      sessionId: replays.sessionId,
+      segmentIntervalMs: replays.segmentIntervalMs,
+      maxEventsPerSegment: replays.maxEventsPerSegment,
+      recordOptions: replays.recordOptions,
+      recorderFactory: replays.recorderFactory,
+      fetchImpl: replays.fetchImpl ?? options.fetchImpl
+    });
+    if (replayId) setActiveReplayId(replayId);
+  } catch (e) {
+    debugLog("replay auto-start failed", e);
+  }
+}
+function isEnabled() {
+  return state?.dsn !== null && state?.dsn !== void 0;
+}
+function resetForTest() {
+  state = null;
+  pending.length = 0;
+  autoReplayStart = null;
+}
+function baseEvent(error) {
+  return {
+    platform: "javascript",
+    environment: state?.options.environment ?? "production",
+    ...state?.options.release ? { release: state.options.release } : {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...error
+  };
+}
+function captureException(exception, hint) {
+  const id = eventId();
+  const event = withReplayContext(baseEvent({ level: "error", ...hint }), state?.replayId ?? null);
+  event["event_id"] = id;
+  event["exception"] = exceptionPayload(exception);
+  void dispatch([{ type: "event", payload: event }], id);
+  return id;
+}
+function exceptionPayload(exception) {
+  if (exception instanceof Error) {
+    return {
+      values: [
+        {
+          type: exception.name,
+          value: exception.message,
+          stacktrace: exception.stack ? { frames: parseStackFrames(exception.stack) } : void 0
+        }
+      ]
+    };
+  }
+  return { values: [{ value: String(exception) }] };
+}
+function parseStackFrames(stack) {
+  const frames = [];
+  for (const line of stack.split("\n")) {
+    const m = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?\s*$/.exec(line);
+    if (!m) continue;
+    frames.push({
+      function: m[1] ?? void 0,
+      filename: m[2],
+      lineno: Number(m[3]),
+      colno: Number(m[4])
+    });
+  }
+  return frames.reverse();
+}
+function captureMessage(message, hint) {
+  const id = eventId();
+  const event = withReplayContext(
+    baseEvent({ message, level: "info", ...hint }),
+    state?.replayId ?? null
+  );
+  event["event_id"] = id;
+  void dispatch([{ type: "event", payload: event }], id);
+  return id;
+}
+function captureEvent(event) {
+  const id = eventId();
+  const payload = withReplayContext(baseEvent(event), state?.replayId ?? null);
+  payload["event_id"] = id;
+  void dispatch([{ type: "event", payload }], id);
+  return id;
+}
+function captureCustomEvent(name, props) {
+  const id = eventId();
+  const event = baseEvent({
+    message: name,
+    level: "info",
+    tags: { __onus_custom: name },
+    extra: props ?? {}
+  });
+  event["event_id"] = id;
+  void dispatch([{ type: "event", payload: event }], id);
+  return id;
+}
+function setActiveReplayId(replayId) {
+  if (state) state.replayId = replayId && /^[a-zA-Z0-9_-]{1,64}$/.test(replayId) ? replayId : null;
+}
+function getActiveReplayId() {
+  return state?.replayId ?? null;
+}
+async function flush() {
+  if (autoReplayStart) await autoReplayStart;
+  await Promise.allSettled(pending.splice(0, pending.length));
+  return isEnabled();
+}
+var SDK_NAME, SDK_VERSION, autoReplayStart, state, pending, MAX_PENDING;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_dsn();
+    init_envelope();
+    init_transport();
+    SDK_NAME = "onus.javascript";
+    SDK_VERSION = "0.1.0";
+    autoReplayStart = null;
+    state = null;
+    pending = [];
+    MAX_PENDING = 100;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MAX_ENVELOPE_BYTES: () => MAX_ENVELOPE_BYTES,
+  REPLAY_ID_RE: () => REPLAY_ID_RE,
+  SDK_NAME: () => SDK_NAME,
+  SDK_VERSION: () => SDK_VERSION,
+  buildEnvelope: () => buildEnvelope,
+  buildSentryAuthHeader: () => buildSentryAuthHeader,
+  captureCustomEvent: () => captureCustomEvent,
+  captureEvent: () => captureEvent,
+  captureException: () => captureException,
+  captureMessage: () => captureMessage,
+  eventId: () => eventId,
+  flush: () => flush,
+  getActiveReplayId: () => getActiveReplayId,
+  init: () => init,
+  isEnabled: () => isEnabled,
+  parseDsn: () => parseDsn,
+  resetForTest: () => resetForTest,
+  setActiveReplayId: () => setActiveReplayId
+});
+module.exports = __toCommonJS(src_exports);
+init_client();
+init_dsn();
+init_envelope();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_ENVELOPE_BYTES,
+  REPLAY_ID_RE,
+  SDK_NAME,
+  SDK_VERSION,
+  buildEnvelope,
+  buildSentryAuthHeader,
+  captureCustomEvent,
+  captureEvent,
+  captureException,
+  captureMessage,
+  eventId,
+  flush,
+  getActiveReplayId,
+  init,
+  isEnabled,
+  parseDsn,
+  resetForTest,
+  setActiveReplayId
+});

package/dist/index.d.ts

@@ -0,0 +1,102 @@
+import { R as Recorder } from './replay-D7ejwI0s.js';
+export { E as EnvelopeItem, M as MAX_ENVELOPE_BYTES, P as ParsedDsn, a as REPLAY_ID_RE, b as buildEnvelope, c as buildSentryAuthHeader, e as eventId, p as parseDsn } from './replay-D7ejwI0s.js';
+
+declare const SDK_NAME = "onus.javascript";
+declare const SDK_VERSION = "0.1.0";
+/**
+ * Session-replay capture config (ONUS-155). Passing this block opts the app
+ * into automatic replay recording from `init()`; within the block, capture
+ * defaults to **all sessions** (`sampleRate` 1) — sampling is an opt-down.
+ * rrweb itself stays behind the lazy `@onus/sdk/replay` subpath, so the
+ * recorder chunk only downloads once recording actually starts.
+ */
+interface ReplaysOptions {
+    /** Auto-start replay with `init()` (default true when the block is given). */
+    enabled?: boolean;
+    /** Fraction of sessions recorded, 0..1 (default 1 — capture all users). */
+    sampleRate?: number;
+    /**
+     * @onus/analytics session id (or getter) attached to each replay_event so
+     * the sessions surface can deep-link playback. A getter is evaluated per
+     * segment flush so rotated session ids stay fresh.
+     */
+    sessionId?: string | (() => string | null | undefined);
+    /** Override the replay environment (defaults to the core `environment`). */
+    environment?: string;
+    /** Override the replay release (defaults to the core `release`). */
+    release?: string;
+    /** Buffered events flushed as one segment after this long (default 5000ms). */
+    segmentIntervalMs?: number;
+    /** Buffered events that force an immediate segment flush (default 100). */
+    maxEventsPerSegment?: number;
+    /** rrweb record options passthrough (privacy masking, etc.). */
+    recordOptions?: Record<string, unknown>;
+    /** Test seam: recorder injection (defaults to lazy rrweb import). */
+    recorderFactory?: () => Promise<Recorder | null>;
+    /** Test seam: fetch implementation (defaults to the core `fetchImpl`). */
+    fetchImpl?: typeof fetch;
+}
+interface OnusSdkOptions {
+    /** Flat DSN `https://{key}@{host}/{numericProjectId}` — required to send. */
+    dsn?: string;
+    release?: string;
+    environment?: string;
+    /** Session-replay capture (see {@link ReplaysOptions}); omit to opt out. */
+    replays?: ReplaysOptions;
+    /** Test seam: fetch implementation (defaults to globalThis.fetch). */
+    fetchImpl?: typeof fetch;
+}
+interface OnusErrorEvent {
+    message?: string;
+    level?: 'error' | 'warning' | 'info' | 'debug';
+    exception?: unknown;
+    tags?: Record<string, string | number | boolean>;
+    extra?: Record<string, unknown>;
+    contexts?: Record<string, unknown>;
+    breadcrumbs?: unknown[];
+    request?: Record<string, unknown>;
+}
+/** Initialize the SDK. Safe to call once; later calls reconfigure the DSN. */
+declare function init(options: OnusSdkOptions): void;
+/** Whether the SDK has a usable DSN and will actually send. */
+declare function isEnabled(): boolean;
+/** Test seam: reset module state. */
+declare function resetForTest(): void;
+/** Capture a handled/unhandled exception. Returns the event id. */
+declare function captureException(exception: unknown, hint?: OnusErrorEvent): string;
+/** Capture a textual message (level defaults to info). */
+declare function captureMessage(message: string, hint?: OnusErrorEvent): string;
+/** Capture a fully-formed event (Sentry captureEvent). */
+declare function captureEvent(event: OnusErrorEvent): string;
+/**
+ * Capture a custom analytics event. Routed through the error envelope as an
+ * `event` item with `tags.__onus_custom` marker so the same ingest path
+ * serves both surfaces (the @onus/analytics SDK remains the PostHog-style
+ * events pipeline; this is for lightweight app-level breadcrumbs).
+ */
+declare function captureCustomEvent(name: string, props?: Record<string, unknown>): string;
+/** Register the active replay session id for error↔replay linking. */
+declare function setActiveReplayId(replayId: string | null): void;
+/** Active replay id (null when replay is off). */
+declare function getActiveReplayId(): string | null;
+/** Drain in-flight sends; resolves true when the SDK is enabled. */
+declare function flush(): Promise<boolean>;
+
+/**
+ * Envelope transport for @onus/sdk (ONUS-68).
+ *
+ * POSTs a serialized envelope to the ingest route with `X-Sentry-Auth`.
+ * Honors the server contract: 429 + `retry-after` (rate limits, migration 34),
+ * gzip via CompressionStream when available (the route sniffs magic bytes and
+ * also accepts identity bodies). Retries 429s with capped backoff; network
+ * failures are reported, never thrown, so instrumentation can't crash the app.
+ */
+interface SendResult {
+    ok: boolean;
+    status?: number;
+    /** Server-provided retry hint (seconds) from a 429, when present. */
+    retryAfterSeconds?: number;
+    error?: string;
+}
+
+export { type OnusErrorEvent, type OnusSdkOptions, type ReplaysOptions, SDK_NAME, SDK_VERSION, type SendResult, captureCustomEvent, captureEvent, captureException, captureMessage, flush, getActiveReplayId, init, isEnabled, resetForTest, setActiveReplayId };