@oneuptime/react-native-replay 13.0.4

package/dist/index.cjs

@@ -0,0 +1,4111 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MOBILE_RECORDER_KIND: () => MOBILE_RECORDER_KIND,
+  MobileReplayRecorder: () => MobileReplayRecorder,
+  OneUptimeReplay: () => OneUptimeReplay,
+  OneUptimeReplayProvider: () => OneUptimeReplayProvider,
+  ReplayMask: () => ReplayMask,
+  ReplayProvider: () => ReplayProvider,
+  SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES: () => SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES,
+  SessionReplayCaptureTrigger: () => SessionReplayCaptureTrigger,
+  SessionReplayConsentMode: () => SessionReplayConsentMode,
+  SessionReplayFidelityNotice: () => SessionReplayFidelityNotice,
+  SessionReplayMaskingMode: () => SessionReplayMaskingMode,
+  SessionReplayTriggerReason: () => SessionReplayTriggerReason,
+  default: () => index_default,
+  useOneUptimeReplay: () => useOneUptimeReplay
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ReplayProvider.tsx
+var import_react = require("react");
+var import_react_native3 = require("react-native");
+
+// src/MobileReplayRecorder.ts
+var import_react_native2 = require("react-native");
+
+// src/Contract.ts
+var SESSION_REPLAY_WIRE_VERSION = 1;
+var SESSION_REPLAY_SCHEMA_VERSION = 1;
+var SESSION_REPLAY_CONTENT_TYPE = "application/vnd.oneuptime.session-replay.v1";
+var SESSION_REPLAY_APP_IDENTIFIER_HEADER = "x-oneuptime-app-identifier";
+var SESSION_REPLAY_RECORDER_KIND_HEADER = "x-oneuptime-replay-recorder-kind";
+var SESSION_REPLAY_MOBILE_APP_IDENTIFIER_HEADER = "x-oneuptime-mobile-app-identifier";
+var SESSION_REPLAY_USER_REF_HEADER = "x-oneuptime-user-ref";
+var SESSION_REPLAY_MAX_USER_REF_LENGTH = 512;
+var AUTH_TOKEN_HEADER = "x-oneuptime-token";
+var CONFIG_PATH = "/telemetry/session-replay/v1/config";
+var CHUNK_PATH = "/telemetry/session-replay/v1/chunk";
+var SESSION_REPLAY_FLUSH_INTERVAL_MS = 15e3;
+var SESSION_REPLAY_FLUSH_BYTES = 256 * 1024;
+var SESSION_REPLAY_CHECKOUT_INTERVAL_MS = 6e4;
+var SESSION_REPLAY_ROLLING_BUFFER_MS = 6e4;
+var SESSION_REPLAY_ROLLING_BUFFER_BYTES = 2 * 1024 * 1024;
+var SESSION_REPLAY_IDLE_ROLLOVER_MS = 30 * 6e4;
+var SESSION_REPLAY_MAX_SESSION_MS = 4 * 60 * 6e4;
+var SESSION_REPLAY_MAX_DECOMPRESSED_FRAME_BYTES = 8 * 1024 * 1024;
+var MAX_SESSION_REPLAY_CHUNK_BYTES = 2 * 1024 * 1024;
+var MAX_SESSION_REPLAY_CHUNKS_PER_SESSION = 480;
+var MOBILE_CAPTURE_INTERVAL_MS = 500;
+var MOBILE_RECORDER_KIND = "rn-view-tree";
+var SYNTHETIC_RRWEB_VERSION = "synthetic-1";
+var RECORDER_VERSION = true ? "13.0.4" : "0.0.0-dev";
+var SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES = [
+  "mobile-view-tree",
+  "mobile-touch-events",
+  "custom-events",
+  "traits",
+  "tags",
+  "visibility",
+  "visitor-id",
+  "route-events",
+  "js-errors"
+];
+var SessionReplayMaskingMode = /* @__PURE__ */ ((SessionReplayMaskingMode2) => {
+  SessionReplayMaskingMode2["MaskSensitiveInputsOnly"] = "MaskSensitiveInputsOnly";
+  SessionReplayMaskingMode2["MaskInputsOnly"] = "MaskInputsOnly";
+  SessionReplayMaskingMode2["MaskAllText"] = "MaskAllText";
+  return SessionReplayMaskingMode2;
+})(SessionReplayMaskingMode || {});
+var SessionReplayConsentMode = /* @__PURE__ */ ((SessionReplayConsentMode2) => {
+  SessionReplayConsentMode2["RequireExplicit"] = "RequireExplicit";
+  SessionReplayConsentMode2["NotRequired"] = "NotRequired";
+  return SessionReplayConsentMode2;
+})(SessionReplayConsentMode || {});
+var SessionReplayCaptureTrigger = /* @__PURE__ */ ((SessionReplayCaptureTrigger2) => {
+  SessionReplayCaptureTrigger2["Always"] = "Always";
+  SessionReplayCaptureTrigger2["OnErrorOrFrustration"] = "OnErrorOrFrustration";
+  return SessionReplayCaptureTrigger2;
+})(SessionReplayCaptureTrigger || {});
+var SessionReplayTriggerReason = /* @__PURE__ */ ((SessionReplayTriggerReason2) => {
+  SessionReplayTriggerReason2["Error"] = "error";
+  SessionReplayTriggerReason2["Frustration"] = "frustration";
+  SessionReplayTriggerReason2["Sampled"] = "sampled";
+  SessionReplayTriggerReason2["Manual"] = "manual";
+  SessionReplayTriggerReason2["Performance"] = "performance";
+  return SessionReplayTriggerReason2;
+})(SessionReplayTriggerReason || {});
+var SessionReplayFidelityNotice = /* @__PURE__ */ ((SessionReplayFidelityNotice2) => {
+  SessionReplayFidelityNotice2["MobileImagesOpaque"] = "mobile-images-opaque";
+  SessionReplayFidelityNotice2["MobileWebViewOpaque"] = "mobile-webview-opaque";
+  SessionReplayFidelityNotice2["MobileCanvasOpaque"] = "mobile-canvas-opaque";
+  SessionReplayFidelityNotice2["MobileAnimationSampled"] = "mobile-animation-sampled";
+  SessionReplayFidelityNotice2["BufferOverflow"] = "buffer-overflow";
+  SessionReplayFidelityNotice2["SnapshotTooLarge"] = "snapshot-too-large";
+  return SessionReplayFidelityNotice2;
+})(SessionReplayFidelityNotice || {});
+var ROUTE_CUSTOM_EVENT_TAG = "oneuptime.route";
+var ERROR_CUSTOM_EVENT_TAG = "oneuptime.error";
+var CUSTOM_EVENT_TAG = "oneuptime.custom";
+var IDENTIFY_CUSTOM_EVENT_TAG = "oneuptime.identify";
+var TAGS_CUSTOM_EVENT_TAG = "oneuptime.tags";
+var VISIBILITY_CUSTOM_EVENT_TAG = "oneuptime.visibility";
+var TOUCH_CUSTOM_EVENT_TAG = "oneuptime.touch";
+
+// src/Sanitize.ts
+var MAX_TRAIT_KEYS = 20;
+var MAX_TRAIT_KEY_LENGTH = 40;
+var MAX_TRAIT_VALUE_LENGTH = 200;
+var MAX_TAG_KEYS = 20;
+var MAX_TAG_KEY_LENGTH = 32;
+var MAX_TAG_VALUE_LENGTH = 128;
+var MAX_CUSTOM_EVENT_NAME_LENGTH = 64;
+var MAX_CUSTOM_EVENT_PROPERTY_KEYS = 20;
+var MAX_CAPTURE_REASON_LENGTH = 80;
+var MAX_USER_REFERENCE_LENGTH = 200;
+var BLOCKED_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var UUID_SEGMENT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+var OBJECT_ID_SEGMENT = /^[0-9a-f]{24}$/iu;
+var EMAIL_SEGMENT = /^[^@\s/]+@[^@\s/]+\.[^@\s/]+$/u;
+var LONG_DIGIT_SEGMENT = /^\d{9,}$/u;
+var OPAQUE_TOKEN_SEGMENT = /^[A-Za-z0-9_-]{32,}$/u;
+var ABSOLUTE_URL_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+var CONTROL_CHARACTER_PATTERN = /[\u0000-\u001F\u007F]/gu;
+function truncate(value, length) {
+  return value.slice(0, Math.max(0, length));
+}
+function stringifyPrimitive(value) {
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+      return Number.isFinite(value) ? String(value) : null;
+    case "boolean":
+      return value ? "true" : "false";
+    default:
+      return value === null ? "null" : null;
+  }
+}
+function sanitizeStringMap(value, limits) {
+  const result = /* @__PURE__ */ Object.create(null);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return result;
+  }
+  for (const [rawKey, rawValue] of Object.entries(
+    value
+  )) {
+    if (Object.keys(result).length >= limits.keys) {
+      break;
+    }
+    const key = truncate(rawKey.trim(), limits.keyLength);
+    const stringValue = stringifyPrimitive(rawValue);
+    if (!key || BLOCKED_KEYS.has(key) || stringValue === null) {
+      continue;
+    }
+    result[key] = truncate(stringValue, limits.valueLength);
+  }
+  return result;
+}
+function sanitizeTraits(value) {
+  return sanitizeStringMap(value, {
+    keys: MAX_TRAIT_KEYS,
+    keyLength: MAX_TRAIT_KEY_LENGTH,
+    valueLength: MAX_TRAIT_VALUE_LENGTH
+  });
+}
+function sanitizeTags(value) {
+  return sanitizeStringMap(value, {
+    keys: MAX_TAG_KEYS,
+    keyLength: MAX_TAG_KEY_LENGTH,
+    valueLength: MAX_TAG_VALUE_LENGTH
+  });
+}
+function sanitizeEventProperties(value) {
+  return sanitizeStringMap(value, {
+    keys: MAX_CUSTOM_EVENT_PROPERTY_KEYS,
+    keyLength: MAX_TRAIT_KEY_LENGTH,
+    valueLength: MAX_TRAIT_VALUE_LENGTH
+  });
+}
+function maskTextValue(value) {
+  if (!value || value.trim().length === 0) {
+    return value;
+  }
+  const length = value.trim().length;
+  const maskedLength = length <= 8 ? 4 : length <= 32 ? 16 : 40;
+  return "\u2022".repeat(maskedLength);
+}
+function maskStringMapValues(values) {
+  const masked = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(values)) {
+    masked[key] = maskTextValue(value);
+  }
+  return masked;
+}
+function sanitizeRoute(route) {
+  if (typeof route !== "string") {
+    return "/";
+  }
+  let path = route.trim();
+  if (!path) {
+    return "/";
+  }
+  try {
+    if (ABSOLUTE_URL_PATTERN.test(path)) {
+      path = new URL(path).pathname;
+    }
+  } catch {
+    path = "/";
+  }
+  path = path.split(/[?#]/u, 1)[0] || "/";
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
+  }
+  path = path.split("/").map((segment) => {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      decoded = segment;
+    }
+    return UUID_SEGMENT.test(decoded) || OBJECT_ID_SEGMENT.test(decoded) || EMAIL_SEGMENT.test(decoded) || LONG_DIGIT_SEGMENT.test(decoded) || OPAQUE_TOKEN_SEGMENT.test(decoded) ? "[redacted]" : segment;
+  }).join("/");
+  return truncate(path.replace(CONTROL_CHARACTER_PATTERN, ""), 2048);
+}
+function toAppUrl(mobileAppIdentifier, route) {
+  return `app://${mobileAppIdentifier}${sanitizeRoute(route)}`;
+}
+function emptySignalCounts() {
+  return {
+    errorCount: 0,
+    rageClickCount: 0,
+    deadClickCount: 0,
+    errorClickCount: 0,
+    refreshRageCount: 0,
+    routeCount: 0,
+    clickCount: 0,
+    customEventCount: 0
+  };
+}
+function byteLength(value) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(value).byteLength;
+  }
+  return unescape(encodeURIComponent(value)).length;
+}
+
+// src/ChunkBuffer.ts
+var ReplayChunkBuffer = class {
+  constructor() {
+    __publicField(this, "events", []);
+    __publicField(this, "approximateBytes", 2);
+    __publicField(this, "startUnixMs", 0);
+    __publicField(this, "endUnixMs", 0);
+    __publicField(this, "hasFullSnapshot", false);
+    __publicField(this, "routes", []);
+    __publicField(this, "fidelity", /* @__PURE__ */ new Set());
+    __publicField(this, "signals", emptySignalCounts());
+    __publicField(this, "droppedEvents", 0);
+  }
+  append(event, options) {
+    let serialized;
+    try {
+      serialized = JSON.stringify(event);
+    } catch {
+      this.droppedEvents += 1;
+      return false;
+    }
+    const eventBytes = byteLength(serialized) + 1;
+    if (eventBytes > SESSION_REPLAY_MAX_DECOMPRESSED_FRAME_BYTES) {
+      this.droppedEvents += 1;
+      this.fidelity.add("snapshot-too-large" /* SnapshotTooLarge */);
+      return false;
+    }
+    this.events.push(event);
+    this.approximateBytes += eventBytes;
+    this.startUnixMs = this.startUnixMs === 0 ? event.timestamp : this.startUnixMs;
+    this.endUnixMs = Math.max(this.endUnixMs, event.timestamp);
+    if (event.type === 2 /* FullSnapshot */) {
+      this.hasFullSnapshot = true;
+    }
+    if (options?.route && !this.routes.includes(options.route)) {
+      this.routes.push(options.route);
+    }
+    for (const notice of options?.fidelityNotices ?? []) {
+      this.fidelity.add(notice);
+    }
+    if (options?.signal) {
+      const current = this.signals[options.signal] ?? 0;
+      this.signals[options.signal] = current + 1;
+    }
+    return true;
+  }
+  appendMany(events, options) {
+    let accepted = 0;
+    for (const event of events) {
+      if (this.append(event, options)) {
+        accepted += 1;
+      }
+    }
+    return accepted;
+  }
+  shouldFlush() {
+    return this.approximateBytes >= SESSION_REPLAY_FLUSH_BYTES;
+  }
+  isEmpty() {
+    return this.events.length === 0;
+  }
+  take() {
+    if (this.events.length === 0) {
+      return null;
+    }
+    const payload = JSON.stringify(this.events);
+    const segment = {
+      payload,
+      eventCount: this.events.length,
+      startUnixMs: this.startUnixMs,
+      endUnixMs: this.endUnixMs,
+      hasFullSnapshot: this.hasFullSnapshot,
+      routes: this.routes.slice(),
+      signals: { ...this.signals },
+      fidelityNotices: Array.from(this.fidelity),
+      droppedEvents: this.droppedEvents
+    };
+    this.reset();
+    return segment;
+  }
+  clear() {
+    this.reset();
+  }
+  reset() {
+    this.events = [];
+    this.approximateBytes = 2;
+    this.startUnixMs = 0;
+    this.endUnixMs = 0;
+    this.hasFullSnapshot = false;
+    this.routes = [];
+    this.fidelity.clear();
+    this.signals = emptySignalCounts();
+    this.droppedEvents = 0;
+  }
+};
+var RollingReplayBuffer = class {
+  constructor() {
+    __publicField(this, "segments", []);
+    __publicField(this, "bytes", 0);
+    __publicField(this, "overflowed", false);
+  }
+  push(segment, nowUnixMs) {
+    this.segments.push(segment);
+    this.bytes += byteLength(segment.payload);
+    const cutoff = nowUnixMs - SESSION_REPLAY_ROLLING_BUFFER_MS;
+    while (this.segments.length > 0 && (this.bytes > SESSION_REPLAY_ROLLING_BUFFER_BYTES || (this.segments[0]?.endUnixMs ?? nowUnixMs) < cutoff)) {
+      const removed = this.segments.shift();
+      if (removed) {
+        this.bytes -= byteLength(removed.payload);
+        this.overflowed = true;
+      }
+    }
+  }
+  drain() {
+    const segments = this.segments;
+    if (this.overflowed && segments[0]) {
+      const notices = new Set(
+        segments[0].fidelityNotices
+      );
+      notices.add("buffer-overflow" /* BufferOverflow */);
+      segments[0] = {
+        ...segments[0],
+        fidelityNotices: Array.from(notices)
+      };
+    }
+    this.clear();
+    return segments;
+  }
+  clear() {
+    this.segments = [];
+    this.bytes = 0;
+    this.overflowed = false;
+  }
+  get length() {
+    return this.segments.length;
+  }
+};
+
+// src/Config.ts
+var CONFIG_FETCH_TIMEOUT_MS = 5e3;
+var MOBILE_APP_IDENTIFIER_LABEL_PATTERN = /^[a-z0-9_-]+$/u;
+var WHITESPACE_PATTERN = /\s/u;
+var CONTROL_CHARACTER_PATTERN2 = /[\u0000-\u001F\u007F]/u;
+function normalizeMobileAppIdentifier(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const identifier = value.trim().toLowerCase();
+  if (!identifier || identifier.length > 255 || WHITESPACE_PATTERN.test(identifier)) {
+    return null;
+  }
+  const labels = identifier.split(".");
+  if (labels.length < 2) {
+    return null;
+  }
+  for (const label of labels) {
+    if (!label || !MOBILE_APP_IDENTIFIER_LABEL_PATTERN.test(label) || label.startsWith("-") || label.endsWith("-") || label.startsWith("_") || label.endsWith("_")) {
+      return null;
+    }
+  }
+  return identifier;
+}
+function normalizeIngestHost(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  try {
+    const parsed = new URL(value.trim());
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      return null;
+    }
+    return parsed.origin;
+  } catch {
+    return null;
+  }
+}
+function normalizeRumAppIdentifier(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const identifier = value.trim();
+  if (!identifier || identifier.length > 255 || CONTROL_CHARACTER_PATTERN2.test(identifier)) {
+    return null;
+  }
+  return identifier;
+}
+function defaultFetch(input, init) {
+  const fetchRef = globalThis.fetch;
+  if (!fetchRef) {
+    return Promise.reject(new Error("fetch-unavailable"));
+  }
+  return fetchRef(input, init);
+}
+function validateStartOptions(options) {
+  if (!options || typeof options !== "object") {
+    return null;
+  }
+  const host = normalizeIngestHost(options.host);
+  const token = typeof options.token === "string" ? options.token.trim() : "";
+  const appIdentifier = normalizeRumAppIdentifier(
+    options.appIdentifier
+  );
+  const mobileAppIdentifier = normalizeMobileAppIdentifier(
+    options.mobileAppIdentifier
+  );
+  const rawUserRef = typeof options.userRef === "string" ? options.userRef.trim() : "";
+  const userRef = rawUserRef ? rawUserRef.slice(0, SESSION_REPLAY_MAX_USER_REF_LENGTH) : void 0;
+  if (!host || !token || !appIdentifier || !mobileAppIdentifier) {
+    return null;
+  }
+  const validated = {
+    ...options,
+    host,
+    token,
+    appIdentifier,
+    mobileAppIdentifier,
+    fetch: options.fetch ?? defaultFetch
+  };
+  if (userRef) {
+    validated.userRef = userRef;
+  } else {
+    delete validated.userRef;
+  }
+  return validated;
+}
+function mobileRequestHeaders(options, includeUserRef = false) {
+  const headers = {
+    [AUTH_TOKEN_HEADER]: options.token,
+    [SESSION_REPLAY_APP_IDENTIFIER_HEADER]: options.appIdentifier,
+    [SESSION_REPLAY_RECORDER_KIND_HEADER]: MOBILE_RECORDER_KIND,
+    [SESSION_REPLAY_MOBILE_APP_IDENTIFIER_HEADER]: options.mobileAppIdentifier
+  };
+  if (includeUserRef && options.userRef) {
+    try {
+      headers[SESSION_REPLAY_USER_REF_HEADER] = encodeURIComponent(
+        options.userRef.slice(0, SESSION_REPLAY_MAX_USER_REF_LENGTH)
+      );
+    } catch {
+    }
+  }
+  return headers;
+}
+function failClosed(reason) {
+  return {
+    enabled: false,
+    captureTrigger: "OnErrorOrFrustration" /* OnErrorOrFrustration */,
+    consentMode: "RequireExplicit" /* RequireExplicit */,
+    maskingMode: "MaskAllText" /* MaskAllText */,
+    samplePercentage: 0,
+    captureUserIdentity: false,
+    configEpoch: 0,
+    isTargeted: false,
+    disabledReason: reason
+  };
+}
+function normalizeReplayConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return failClosed("invalid-config");
+  }
+  const config = value;
+  const captureTrigger = config.captureTrigger === "Always" /* Always */ ? "Always" /* Always */ : "OnErrorOrFrustration" /* OnErrorOrFrustration */;
+  const consentMode = config.consentMode === "NotRequired" /* NotRequired */ ? "NotRequired" /* NotRequired */ : "RequireExplicit" /* RequireExplicit */;
+  const samplePercentage = typeof config.samplePercentage === "number" && Number.isFinite(config.samplePercentage) && config.samplePercentage >= 0 && config.samplePercentage <= 100 ? config.samplePercentage : 0;
+  const enabled = config.enabled === true && config.directive === "continue";
+  const resolved = {
+    enabled,
+    captureTrigger,
+    consentMode,
+    /* Mobile never relaxes text masking, even if web policy is looser. */
+    maskingMode: "MaskAllText" /* MaskAllText */,
+    samplePercentage,
+    captureUserIdentity: config.captureUserIdentity === true,
+    configEpoch: typeof config.configEpoch === "number" && Number.isSafeInteger(config.configEpoch) && config.configEpoch >= 0 ? config.configEpoch : 0,
+    isTargeted: config.isTargeted === true
+  };
+  if (typeof config.disabledReason === "string") {
+    resolved.disabledReason = config.disabledReason.slice(0, 100);
+  } else if (!enabled) {
+    resolved.disabledReason = "disabled";
+  }
+  return resolved;
+}
+async function fetchReplayConfig(options, includeUserRef = false, revalidate = false) {
+  const controller = typeof AbortController === "undefined" ? null : new AbortController();
+  let timeout = null;
+  try {
+    const request = (async () => {
+      const headers = {
+        ...mobileRequestHeaders(options, includeUserRef),
+        Accept: "application/json"
+      };
+      if (revalidate) {
+        headers["Cache-Control"] = "no-cache";
+        headers["Pragma"] = "no-cache";
+      }
+      const requestInit = {
+        method: "GET",
+        headers
+      };
+      if (controller) {
+        requestInit.signal = controller.signal;
+      }
+      const response = await options.fetch(
+        `${options.host}${CONFIG_PATH}`,
+        requestInit
+      );
+      if (!response.ok) {
+        return failClosed(`config-http-${response.status}`);
+      }
+      return normalizeReplayConfig(await response.json());
+    })();
+    const deadline = new Promise(
+      (_resolve, reject) => {
+        timeout = setTimeout(() => {
+          controller?.abort();
+          reject(new Error("config-fetch-timeout"));
+        }, CONFIG_FETCH_TIMEOUT_MS);
+      }
+    );
+    return await Promise.race([request, deadline]);
+  } catch {
+    return failClosed("config-fetch-failed");
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+// src/ViewTreeSerializer.ts
+var RRWEB_DOCUMENT_NODE_ID = 1;
+var RRWEB_HTML_NODE_ID = 3;
+var RRWEB_HEAD_NODE_ID = 4;
+var RRWEB_BODY_NODE_ID = 5;
+var FIRST_VIEW_NODE_ID = 10;
+var MAX_VIEW_TREE_DEPTH = 64;
+var MAX_VIEW_TREE_NODES = 5e3;
+var MAX_GEOMETRY_VALUE = 1e5;
+var SAFE_KINDS = /* @__PURE__ */ new Set([
+  "view",
+  "scroll",
+  "button",
+  "text",
+  "input",
+  "image",
+  "webview",
+  "canvas",
+  "masked",
+  "unknown"
+]);
+function finiteGeometry(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(MAX_GEOMETRY_VALUE, Math.max(-MAX_GEOMETRY_VALUE, value));
+}
+function safeKind(value) {
+  if (typeof value === "string" && SAFE_KINDS.has(value)) {
+    return value;
+  }
+  return "unknown";
+}
+function geometryStyle(node) {
+  const x2 = finiteGeometry(node.x);
+  const y = finiteGeometry(node.y);
+  const width = Math.max(0, finiteGeometry(node.width));
+  const height = Math.max(0, finiteGeometry(node.height));
+  const style = [
+    "position:absolute",
+    `left:${x2}px`,
+    `top:${y}px`,
+    `width:${width}px`,
+    `height:${height}px`,
+    "box-sizing:border-box",
+    "overflow:hidden",
+    "outline:1px solid rgba(148,163,184,0.18)"
+  ];
+  const backgroundColor = safeColor(node.backgroundColor);
+  const borderColor = safeColor(node.borderColor);
+  const borderWidth = clampedStyleNumber(node.borderWidth, 0, 100, 0);
+  const borderRadius = clampedStyleNumber(
+    node.borderRadius,
+    0,
+    MAX_GEOMETRY_VALUE,
+    0
+  );
+  const opacity = clampedStyleNumber(node.opacity, 0, 1, 1);
+  const zIndex = clampedStyleNumber(node.zIndex, -1e4, 1e4, 0);
+  if (backgroundColor) {
+    style.push(`background-color:${backgroundColor}`);
+  }
+  if (borderColor && borderWidth > 0) {
+    style.push(`border:${borderWidth}px solid ${borderColor}`);
+  }
+  if (borderRadius > 0) {
+    style.push(`border-radius:${borderRadius}px`);
+  }
+  if (opacity < 1) {
+    style.push(`opacity:${opacity}`);
+  }
+  if (zIndex !== 0) {
+    style.push(`z-index:${zIndex}`);
+  }
+  return style.join(";");
+}
+var HEX_COLOR_PATTERN = /^#[0-9a-f]{6}([0-9a-f]{2})?$/u;
+function safeColor(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return HEX_COLOR_PATTERN.test(normalized) ? normalized : null;
+}
+function clampedStyleNumber(value, minimum, maximum, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(minimum, Math.min(maximum, value));
+}
+function cloneNode(node) {
+  return {
+    ...node,
+    attributes: { ...node.attributes },
+    childNodes: node.childNodes.map(cloneNode)
+  };
+}
+function sameAttributes(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  return leftKeys.length === rightKeys.length && leftKeys.every((key) => {
+    return left[key] === right[key];
+  });
+}
+var ViewTreeSerializer = class {
+  constructor() {
+    __publicField(this, "nodeIds", /* @__PURE__ */ new Map());
+    __publicField(this, "nextNodeId", FIRST_VIEW_NODE_ID);
+    __publicField(this, "previous", null);
+  }
+  capture(input, options) {
+    const shouldTakeFullSnapshot = !this.previous || options.forceFullSnapshot === true;
+    if (options.forceFullSnapshot === true && this.previous) {
+      this.previous = null;
+      this.nodeIds.clear();
+      this.nextNodeId = FIRST_VIEW_NODE_ID;
+    }
+    const current = this.build(input);
+    const events = shouldTakeFullSnapshot ? this.fullSnapshot(current, options) : this.mutations(
+      this.previous,
+      current,
+      options.timestamp
+    );
+    this.previous = current;
+    for (const key of this.nodeIds.keys()) {
+      if (!current.records.has(key)) {
+        this.nodeIds.delete(key);
+      }
+    }
+    return {
+      events,
+      hasFullSnapshot: shouldTakeFullSnapshot,
+      fidelityNotices: Array.from(current.fidelity),
+      droppedNodes: current.droppedNodes
+    };
+  }
+  reset() {
+    this.previous = null;
+    this.nodeIds.clear();
+    this.nextNodeId = FIRST_VIEW_NODE_ID;
+  }
+  build(input) {
+    const records = /* @__PURE__ */ new Map();
+    const byId = /* @__PURE__ */ new Map();
+    const fidelity = /* @__PURE__ */ new Set([
+      "mobile-animation-sampled" /* MobileAnimationSampled */
+    ]);
+    let visited = 0;
+    let droppedNodes = typeof input.truncatedNodes === "number" && Number.isSafeInteger(input.truncatedNodes) && input.truncatedNodes > 0 ? Math.min(input.truncatedNodes, 1e6) : 0;
+    const visit = (candidate, parentId, path, depth) => {
+      if (depth > MAX_VIEW_TREE_DEPTH || visited >= MAX_VIEW_TREE_NODES || !candidate || typeof candidate !== "object") {
+        droppedNodes += 1;
+        return null;
+      }
+      visited += 1;
+      const kind = candidate.masked ? "masked" : safeKind(candidate.kind);
+      const key = `${typeof candidate.nativeId}:${String(
+        candidate.nativeId
+      )}:${path}`;
+      let id = this.nodeIds.get(key);
+      if (id === void 0) {
+        id = this.nextNodeId;
+        this.nextNodeId += 1;
+        this.nodeIds.set(key, id);
+      }
+      const attributes = {
+        style: geometryStyle(candidate),
+        "data-oneuptime-mobile-view": kind
+      };
+      const isOpaque = candidate.opaque === true || kind === "image" || kind === "webview" || kind === "canvas" || kind === "masked";
+      if (isOpaque) {
+        attributes["data-oneuptime-replay-placeholder"] = kind;
+        if (!safeColor(candidate.backgroundColor)) {
+          attributes["style"] += ";background-color:#94a3b833";
+        }
+      } else if (kind === "text" || kind === "input") {
+        attributes["style"] += ";background-color:#94a3b826";
+      }
+      switch (kind) {
+        case "image":
+          fidelity.add("mobile-images-opaque" /* MobileImagesOpaque */);
+          break;
+        case "webview":
+          fidelity.add("mobile-webview-opaque" /* MobileWebViewOpaque */);
+          break;
+        case "canvas":
+          fidelity.add("mobile-canvas-opaque" /* MobileCanvasOpaque */);
+          break;
+        default:
+          break;
+      }
+      const element = {
+        type: 2,
+        tagName: "div",
+        attributes,
+        childNodes: [],
+        id
+      };
+      const record = {
+        key,
+        id,
+        parentId,
+        attributes,
+        node: element
+      };
+      records.set(key, record);
+      byId.set(id, record);
+      if (!isOpaque && Array.isArray(candidate.children)) {
+        candidate.children.forEach(
+          (child, index) => {
+            const serialized = visit(
+              child,
+              id,
+              `${path}.${index}`,
+              depth + 1
+            );
+            if (serialized) {
+              element.childNodes.push(serialized);
+            }
+          }
+        );
+      }
+      return element;
+    };
+    const root = visit(
+      input,
+      RRWEB_BODY_NODE_ID,
+      "0",
+      0
+    ) ?? {
+      type: 2,
+      tagName: "div",
+      attributes: {
+        style: "position:absolute;left:0px;top:0px;width:0px;height:0px;box-sizing:border-box;overflow:hidden",
+        "data-oneuptime-mobile-view": "unknown"
+      },
+      childNodes: [],
+      id: this.nextNodeId++
+    };
+    if (droppedNodes > 0) {
+      fidelity.add("buffer-overflow" /* BufferOverflow */);
+    }
+    return { root, records, byId, fidelity, droppedNodes };
+  }
+  fullSnapshot(current, options) {
+    const width = Math.max(0, finiteGeometry(options.viewportWidth));
+    const height = Math.max(0, finiteGeometry(options.viewportHeight));
+    return [
+      {
+        type: 4 /* Meta */,
+        data: {
+          href: options.url,
+          width,
+          height
+        },
+        timestamp: options.timestamp
+      },
+      {
+        type: 2 /* FullSnapshot */,
+        data: {
+          node: {
+            type: 0,
+            childNodes: [
+              {
+                type: 1,
+                name: "html",
+                publicId: "",
+                systemId: "",
+                id: 2
+              },
+              {
+                type: 2,
+                tagName: "html",
+                attributes: {},
+                childNodes: [
+                  {
+                    type: 2,
+                    tagName: "head",
+                    attributes: {},
+                    childNodes: [],
+                    id: RRWEB_HEAD_NODE_ID
+                  },
+                  {
+                    type: 2,
+                    tagName: "body",
+                    attributes: {
+                      style: `margin:0;position:relative;width:${width}px;height:${height}px;overflow:hidden`,
+                      "data-oneuptime-recorder-kind": "rn-view-tree"
+                    },
+                    childNodes: [cloneNode(current.root)],
+                    id: RRWEB_BODY_NODE_ID
+                  }
+                ],
+                id: RRWEB_HTML_NODE_ID
+              }
+            ],
+            id: RRWEB_DOCUMENT_NODE_ID
+          },
+          initialOffset: { top: 0, left: 0 }
+        },
+        timestamp: options.timestamp
+      }
+    ];
+  }
+  mutations(previous, current, timestamp) {
+    const additions = [];
+    const removals = [];
+    const attributes = [];
+    for (const record of current.records.values()) {
+      const before = previous.records.get(
+        record.key
+      );
+      if (!before) {
+        const parentWasAdded = record.parentId !== RRWEB_BODY_NODE_ID && !previous.byId.has(record.parentId);
+        if (!parentWasAdded) {
+          additions.push({
+            parentId: record.parentId,
+            nextId: null,
+            node: cloneNode(record.node)
+          });
+        }
+      } else if (!sameAttributes(before.attributes, record.attributes)) {
+        attributes.push({
+          id: record.id,
+          attributes: { ...record.attributes }
+        });
+      }
+    }
+    for (const record of previous.records.values()) {
+      if (!current.records.has(record.key)) {
+        const parentWasRemoved = record.parentId !== RRWEB_BODY_NODE_ID && !current.byId.has(record.parentId);
+        if (!parentWasRemoved) {
+          removals.push({ parentId: record.parentId, id: record.id });
+        }
+      }
+    }
+    if (additions.length === 0 && removals.length === 0 && attributes.length === 0) {
+      return [];
+    }
+    return [
+      {
+        type: 3 /* IncrementalSnapshot */,
+        data: {
+          source: 0 /* Mutation */,
+          texts: [],
+          attributes,
+          removes: removals,
+          adds: additions
+        },
+        timestamp
+      }
+    ];
+  }
+};
+
+// src/Events.ts
+var MAX_TOUCH_CLOCK_SKEW_MS = 6e4;
+function coordinate(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(-1e5, Math.min(1e5, value)) : 0;
+}
+function sanitizeRecordedTouch(value, nowUnixMs) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const raw = value;
+  if (raw.phase !== "start" && raw.phase !== "move" && raw.phase !== "end") {
+    return null;
+  }
+  const safeNowUnixMs = Number.isFinite(nowUnixMs) ? nowUnixMs : Date.now();
+  const candidateTimestamp = raw.timestamp;
+  const timestamp = typeof candidateTimestamp === "number" && Number.isFinite(candidateTimestamp) && candidateTimestamp >= safeNowUnixMs - MAX_TOUCH_CLOCK_SKEW_MS && candidateTimestamp <= safeNowUnixMs + MAX_TOUCH_CLOCK_SKEW_MS ? candidateTimestamp : safeNowUnixMs;
+  const touch = {
+    phase: raw.phase,
+    x: coordinate(raw.x),
+    y: coordinate(raw.y),
+    timestamp
+  };
+  if (typeof raw.targetTag === "number" && Number.isSafeInteger(raw.targetTag) && raw.targetTag > 0) {
+    touch.targetTag = raw.targetTag;
+  }
+  if (typeof raw.pointerId === "number" && Number.isSafeInteger(raw.pointerId) || typeof raw.pointerId === "string" && raw.pointerId.length <= 100) {
+    touch.pointerId = raw.pointerId;
+  }
+  return touch;
+}
+function createTouchEvent(touch) {
+  const x2 = coordinate(touch.x);
+  const y = coordinate(touch.y);
+  if (touch.phase === "move") {
+    return {
+      type: 3 /* IncrementalSnapshot */,
+      data: {
+        source: 6 /* TouchMove */,
+        positions: [
+          {
+            x: x2,
+            y,
+            id: RRWEB_BODY_NODE_ID,
+            timeOffset: 0
+          }
+        ]
+      },
+      timestamp: touch.timestamp
+    };
+  }
+  return {
+    type: 3 /* IncrementalSnapshot */,
+    data: {
+      source: 2 /* MouseInteraction */,
+      type: touch.phase === "start" ? 7 /* TouchStart */ : 9 /* TouchEnd */,
+      id: RRWEB_BODY_NODE_ID,
+      x: x2,
+      y
+    },
+    timestamp: touch.timestamp
+  };
+}
+function createCustomEvent(tag, payload, timestamp) {
+  return {
+    type: 5 /* Custom */,
+    data: { tag, payload },
+    timestamp
+  };
+}
+
+// src/NativeViewTree.ts
+var import_react_native = require("react-native");
+function viewport() {
+  const dimensions = import_react_native.Dimensions.get(
+    "window"
+  );
+  return {
+    width: typeof dimensions.width === "number" && Number.isFinite(dimensions.width) ? dimensions.width : 0,
+    height: typeof dimensions.height === "number" && Number.isFinite(dimensions.height) ? dimensions.height : 0
+  };
+}
+var ReactNativeViewTreeAdapter = class {
+  isAvailable() {
+    const nativeModule = import_react_native.NativeModules["OneUptimeReplayViewTree"];
+    return typeof nativeModule?.captureViewTree === "function";
+  }
+  async captureViewTree(rootTag) {
+    const nativeModule = import_react_native.NativeModules["OneUptimeReplayViewTree"];
+    if (nativeModule?.captureViewTree) {
+      return await nativeModule.captureViewTree(rootTag);
+    }
+    throw new Error(
+      "OneUptime replay native module is unavailable. Expo Go is not supported; use an autolinked native or Expo development build."
+    );
+  }
+  async getAppMetadata() {
+    const nativeModule = import_react_native.NativeModules["OneUptimeReplayViewTree"];
+    let metadata = {};
+    try {
+      metadata = await nativeModule?.getAppMetadata?.() ?? {};
+    } catch {
+      metadata = {};
+    }
+    return {
+      appName: typeof metadata.appName === "string" ? metadata.appName : "React Native",
+      appVersion: typeof metadata.appVersion === "string" ? metadata.appVersion : "unknown",
+      osName: typeof metadata.osName === "string" ? metadata.osName : import_react_native.Platform.OS,
+      osVersion: typeof metadata.osVersion === "string" ? metadata.osVersion : String(import_react_native.Platform.Version)
+    };
+  }
+  async isTouchTargetPrivate(targetTag, replayRootTag) {
+    const nativeModule = import_react_native.NativeModules["OneUptimeReplayViewTree"];
+    if (typeof nativeModule?.isTouchTargetPrivate !== "function") {
+      return true;
+    }
+    try {
+      return await nativeModule.isTouchTargetPrivate(targetTag, replayRootTag) !== false;
+    } catch {
+      return true;
+    }
+  }
+};
+var defaultNativeViewTreeAdapter = new ReactNativeViewTreeAdapter();
+function getViewport() {
+  return viewport();
+}
+
+// src/Outbox.ts
+var MAX_OUTBOX_ENTRIES = 64;
+var MAX_OUTBOX_BYTES = 8 * 1024 * 1024;
+function isFrame(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const frame = value;
+  return typeof frame.id === "string" && typeof frame.payload === "string" && typeof frame.attempts === "number" && Number.isSafeInteger(frame.attempts) && Boolean(frame.envelope) && typeof frame.envelope === "object" && typeof frame.envelope.sessionId === "string" && typeof frame.envelope.tabId === "string" && typeof frame.envelope.chunkIndex === "number";
+}
+function frameId(envelope) {
+  return `${envelope.sessionId}:${envelope.tabId}:${envelope.chunkIndex}`;
+}
+var ReplayOutbox = class {
+  constructor(storage, namespace) {
+    __publicField(this, "storage");
+    __publicField(this, "key");
+    __publicField(this, "mutationQueue", Promise.resolve());
+    this.storage = storage;
+    this.key = `@oneuptime/replay/${namespace}/outbox`;
+  }
+  async list() {
+    return await this.withLock(
+      async () => {
+        return this.readUnlocked();
+      }
+    );
+  }
+  async readUnlocked() {
+    try {
+      const raw = await this.storage.getItem(this.key);
+      if (!raw) {
+        return [];
+      }
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed) || !parsed.every(isFrame)) {
+        await this.removeUnlocked();
+        return [];
+      }
+      return parsed.slice().sort(
+        (left, right) => {
+          return left.createdAtUnixMs - right.createdAtUnixMs;
+        }
+      );
+    } catch {
+      await this.removeUnlocked();
+      return [];
+    }
+  }
+  async enqueue(frame) {
+    return await this.withLock(async () => {
+      const frames = await this.readUnlocked();
+      if (frames.some((candidate) => {
+        return candidate.id === frame.id;
+      })) {
+        return { dropped: 0 };
+      }
+      frames.push(frame);
+      let dropped = 0;
+      while (frames.length > MAX_OUTBOX_ENTRIES || byteLength(JSON.stringify(frames)) > MAX_OUTBOX_BYTES) {
+        frames.shift();
+        dropped += 1;
+      }
+      await this.writeUnlocked(frames);
+      return { dropped };
+    });
+  }
+  async remove(id) {
+    await this.withLock(async () => {
+      const frames = (await this.readUnlocked()).filter((frame) => {
+        return frame.id !== id;
+      });
+      await this.writeUnlocked(frames);
+    });
+  }
+  async incrementAttempts(id) {
+    return await this.withLock(async () => {
+      const frames = await this.readUnlocked();
+      let attempts = 0;
+      for (const frame of frames) {
+        if (frame.id === id) {
+          frame.attempts += 1;
+          attempts = frame.attempts;
+          break;
+        }
+      }
+      await this.writeUnlocked(frames);
+      return attempts;
+    });
+  }
+  async clear() {
+    await this.withLock(async () => {
+      return this.removeUnlocked();
+    });
+  }
+  async removeUnlocked() {
+    try {
+      await this.storage.removeItem(this.key);
+    } catch {
+    }
+  }
+  async writeUnlocked(frames) {
+    try {
+      if (frames.length === 0) {
+        await this.storage.removeItem(this.key);
+        return;
+      }
+      await this.storage.setItem(this.key, JSON.stringify(frames));
+    } catch {
+    }
+  }
+  async withLock(operation) {
+    const result = this.mutationQueue.then(operation, operation);
+    this.mutationQueue = result.then(
+      () => {
+        return void 0;
+      },
+      () => {
+        return void 0;
+      }
+    );
+    return await result;
+  }
+};
+
+// src/Storage.ts
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var REPLAY_ID_PATTERN = /^[0-9a-f]{32}$/u;
+var defaultReplayStorage = import_async_storage.default;
+function generateReplayId() {
+  const bytes = new Uint8Array(16);
+  const cryptoRef = globalThis.crypto;
+  if (cryptoRef && typeof cryptoRef.getRandomValues === "function") {
+    cryptoRef.getRandomValues(bytes);
+  } else {
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes).map((byte) => {
+    return byte.toString(16).padStart(2, "0");
+  }).join("");
+}
+function isReplayId(value) {
+  return typeof value === "string" && REPLAY_ID_PATTERN.test(value);
+}
+function parseStoredSession(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const candidate = parsed;
+    if (!isReplayId(candidate.sessionId) || !Number.isSafeInteger(candidate.sessionStartUnixMs) || !Number.isSafeInteger(candidate.lastActivityUnixMs) || !Number.isSafeInteger(candidate.nextChunkIndex) || (candidate.nextChunkIndex ?? -1) < 0) {
+      return null;
+    }
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+var ReplaySessionStore = class {
+  constructor(storage, namespace) {
+    __publicField(this, "storage");
+    __publicField(this, "sessionKey");
+    __publicField(this, "visitorKey");
+    __publicField(this, "identity", null);
+    this.storage = storage;
+    this.sessionKey = `@oneuptime/replay/${namespace}/session`;
+    this.visitorKey = `@oneuptime/replay/${namespace}/visitor`;
+  }
+  async resolve(nowUnixMs) {
+    const stored = parseStoredSession(
+      await this.safeGet(this.sessionKey)
+    );
+    const shouldRotate = !stored || stored.nextChunkIndex >= MAX_SESSION_REPLAY_CHUNKS_PER_SESSION || nowUnixMs - stored.lastActivityUnixMs >= SESSION_REPLAY_IDLE_ROLLOVER_MS || nowUnixMs - stored.sessionStartUnixMs >= SESSION_REPLAY_MAX_SESSION_MS;
+    let session;
+    if (shouldRotate || !stored) {
+      session = {
+        sessionId: generateReplayId(),
+        sessionStartUnixMs: nowUnixMs,
+        lastActivityUnixMs: nowUnixMs,
+        nextChunkIndex: 0
+      };
+    } else {
+      session = {
+        sessionId: stored.sessionId,
+        sessionStartUnixMs: stored.sessionStartUnixMs,
+        lastActivityUnixMs: nowUnixMs,
+        nextChunkIndex: stored.nextChunkIndex
+      };
+    }
+    let visitorId = await this.safeGet(this.visitorKey);
+    if (!isReplayId(visitorId)) {
+      visitorId = generateReplayId();
+      await this.safeSet(this.visitorKey, visitorId);
+    }
+    await this.safeSet(this.sessionKey, JSON.stringify(session));
+    this.identity = {
+      sessionId: session.sessionId,
+      tabId: generateReplayId(),
+      visitorId,
+      sessionStartUnixMs: session.sessionStartUnixMs,
+      chunkIndex: session.nextChunkIndex
+    };
+    return { ...this.identity };
+  }
+  async takeChunkIndex(nowUnixMs) {
+    if (!this.identity) {
+      await this.resolve(nowUnixMs);
+    }
+    const identity = this.identity;
+    const index = identity.chunkIndex;
+    identity.chunkIndex += 1;
+    const state = {
+      sessionId: identity.sessionId,
+      sessionStartUnixMs: identity.sessionStartUnixMs,
+      lastActivityUnixMs: nowUnixMs,
+      nextChunkIndex: identity.chunkIndex
+    };
+    await this.safeSet(this.sessionKey, JSON.stringify(state));
+    return index;
+  }
+  getNextChunkIndex() {
+    return this.identity?.chunkIndex ?? null;
+  }
+  async rotate(nowUnixMs) {
+    let visitorId = await this.safeGet(this.visitorKey);
+    if (!isReplayId(visitorId)) {
+      visitorId = generateReplayId();
+      await this.safeSet(this.visitorKey, visitorId);
+    }
+    const session = {
+      sessionId: generateReplayId(),
+      sessionStartUnixMs: nowUnixMs,
+      lastActivityUnixMs: nowUnixMs,
+      nextChunkIndex: 0
+    };
+    await this.safeSet(this.sessionKey, JSON.stringify(session));
+    this.identity = {
+      sessionId: session.sessionId,
+      tabId: generateReplayId(),
+      visitorId,
+      sessionStartUnixMs: nowUnixMs,
+      chunkIndex: 0
+    };
+    return { ...this.identity };
+  }
+  async clear() {
+    this.identity = null;
+    await Promise.all([
+      this.safeRemove(this.sessionKey),
+      this.safeRemove(this.visitorKey)
+    ]);
+  }
+  async safeGet(key) {
+    try {
+      return await this.storage.getItem(key);
+    } catch {
+      return null;
+    }
+  }
+  async safeSet(key, value) {
+    try {
+      await this.storage.setItem(key, value);
+    } catch {
+    }
+  }
+  async safeRemove(key) {
+    try {
+      await this.storage.removeItem(key);
+    } catch {
+    }
+  }
+};
+
+// node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i2 = 0; i2 < 31; ++i2) {
+    b[i2] = start += 1 << eb[i2 - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i2 = 1; i2 < 30; ++i2) {
+    for (var j = b[i2]; j < b[i2 + 1]; ++j) {
+      r[j] = j - b[i2] << 5 | i2;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (; i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1; i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i2 = 0; i2 < d.length; ++i2) {
+    if (d[i2])
+      t.push({ s: i2, f: d[i2] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i22].f ? i0++ : i22++];
+    r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i2 = 1; i2 < s; ++i2) {
+    if (t2[i2].s > maxSym)
+      maxSym = t2[i2].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i2 = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (; i2 < s; ++i2) {
+      var i2_1 = t2[i2].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i2].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i2;
+    }
+    for (; i2 >= 0 && dt; --i2) {
+      var i2_3 = t2[i2].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli++] = v;
+  };
+  for (var i2 = 1; i2 <= s; ++i2) {
+    if (c[i2] == cln && i2 != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (; cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (; cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i2];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i2 = 0; i2 < cl.length; ++i2)
+    l += cf[i2] * cl[i2];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i2 = 0; i2 < s; ++i2)
+    out[o + i2 + 4] = dat[i2];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i2 = 0; i2 < lclt.length; ++i2)
+    ++lcfreq[lclt[i2] & 31];
+  for (var i2 = 0; i2 < lcdt.length; ++i2)
+    ++lcfreq[lcdt[i2] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i2 = 0; i2 < nlcc; ++i2)
+      wbits(out, p + 3 * i2, lct[clim[i2]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0; it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i2 = 0; i2 < clct.length; ++i2) {
+        var len = clct[i2] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i2 = 0; i2 < li; ++i2) {
+    var sym = syms[i2];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i3) {
+      return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25e3);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (; i2 + 2 < s; ++i2) {
+      var hv = hsh(i2);
+      var imod = i2 & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i2) {
+        var rem = s - i2;
+        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
+          li = lc_1 = eb = 0, bs = i2;
+          for (var j = 0; j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0; j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i2 - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i2);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i2 + l] == dat[i2 + l - dif]) {
+              var nl = 0;
+              for (; nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0; j < mmd; ++j) {
+                  var ti = i2 - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i2 + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i2];
+          ++lf[dat[i2]];
+        }
+      }
+    }
+    for (i2 = Math.max(i2, wi); i2 < s; ++i2) {
+      syms[li++] = dat[i2];
+      ++lf[dat[i2]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i2, st.w = wi;
+    }
+  } else {
+    for (var i2 = st.w || 0; i2 < s + lst; i2 += 65535) {
+      var e = i2 + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i2, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var crct = /* @__PURE__ */ (function() {
+  var t = new Int32Array(256);
+  for (var i2 = 0; i2 < 256; ++i2) {
+    var c = i2, k = 9;
+    while (--k)
+      c = (c & 1 && -306674912) ^ c >>> 1;
+    t[i2] = c;
+  }
+  return t;
+})();
+var crc = function() {
+  var c = -1;
+  return {
+    p: function(d) {
+      var cr = c;
+      for (var i2 = 0; i2 < d.length; ++i2)
+        cr = crct[cr & 255 ^ d[i2]] ^ cr >>> 8;
+      c = cr;
+    },
+    d: function() {
+      return ~c;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var wbytes = function(d, b, v) {
+  for (; v; ++b)
+    d[b] = v, v >>>= 8;
+};
+var gzh = function(c, o) {
+  var fn = o.filename;
+  c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3;
+  if (o.mtime != 0)
+    wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1e3));
+  if (fn) {
+    c[3] = 8;
+    for (var i2 = 0; i2 <= fn.length; ++i2)
+      c[i2 + 10] = fn.charCodeAt(i2);
+  }
+};
+var gzhl = function(o) {
+  return 10 + (o.filename ? o.filename.length + 1 : 0);
+};
+function gzipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var c = crc(), l = data.length;
+  c.p(data);
+  var d = dopt(data, opts, gzhl(opts), 8), s = d.length;
+  return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;
+}
+var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+function strToU8(str, latin1) {
+  if (latin1) {
+    var ar_1 = new u8(str.length);
+    for (var i2 = 0; i2 < str.length; ++i2)
+      ar_1[i2] = str.charCodeAt(i2);
+    return ar_1;
+  }
+  if (te)
+    return te.encode(str);
+  var l = str.length;
+  var ar = new u8(str.length + (str.length >> 1));
+  var ai = 0;
+  var w = function(v) {
+    ar[ai++] = v;
+  };
+  for (var i2 = 0; i2 < l; ++i2) {
+    if (ai + 5 > ar.length) {
+      var n = new u8(ai + 8 + (l - i2 << 1));
+      n.set(ar);
+      ar = n;
+    }
+    var c = str.charCodeAt(i2);
+    if (c < 128 || latin1)
+      w(c);
+    else if (c < 2048)
+      w(192 | c >> 6), w(128 | c & 63);
+    else if (c > 55295 && c < 57344)
+      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+    else
+      w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+  }
+  return slc(ar, 0, ai);
+}
+
+// src/Transport.ts
+var MAX_ATTEMPTS_PER_FRAME = 3;
+var DEFAULT_RETRY_MS = 15e3;
+var MAX_RETRY_MS = 5 * 6e4;
+var CHUNK_POST_TIMEOUT_MS = 1e4;
+var DIRECTIVE_REASON_PATTERN = /^[A-Za-z0-9_.:-]{1,100}$/u;
+function encodeReplayFrame(originalEnvelope, payload) {
+  const compressed = gzipSync(strToU8(payload));
+  const envelope = {
+    ...originalEnvelope,
+    payloadEncoding: "gzip",
+    payloadBytes: compressed.byteLength,
+    clientSendUnixMs: Date.now()
+  };
+  const prefix = strToU8(`${JSON.stringify(envelope)}
+`);
+  const body = new Uint8Array(
+    prefix.byteLength + compressed.byteLength
+  );
+  body.set(prefix, 0);
+  body.set(compressed, prefix.byteLength);
+  return { envelope, body };
+}
+function safeReason(value) {
+  return typeof value === "string" && DIRECTIVE_REASON_PATTERN.test(value) ? value : null;
+}
+function parseDirectiveValue(value) {
+  return value === "continue" || value === "stop" || value === "throttle" ? value : null;
+}
+async function readDirective(response) {
+  if (response.status === 204) {
+    return {
+      directive: parseDirectiveValue(
+        response.headers?.get("x-oneuptime-replay-directive")
+      ),
+      reason: safeReason(response.headers?.get("x-oneuptime-replay-reason")),
+      retryAfterSeconds: parseRetryAfter(
+        response.headers?.get("retry-after") ?? null
+      )
+    };
+  }
+  try {
+    const value = await response.json();
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { directive: null, reason: null, retryAfterSeconds: null };
+    }
+    const body = value;
+    return {
+      directive: parseDirectiveValue(body.directive),
+      reason: safeReason(body.reason) ?? safeReason(body.error),
+      retryAfterSeconds: typeof body.retryAfterSeconds === "number" && Number.isFinite(body.retryAfterSeconds) ? Math.max(0, Math.min(300, body.retryAfterSeconds)) : parseRetryAfter(response.headers?.get("retry-after") ?? null)
+    };
+  } catch {
+    return {
+      directive: null,
+      reason: null,
+      retryAfterSeconds: parseRetryAfter(
+        response.headers?.get("retry-after") ?? null
+      )
+    };
+  }
+}
+function parseRetryAfter(value) {
+  if (!value) {
+    return null;
+  }
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.min(300, seconds) : null;
+}
+var ReplayTransport = class {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "fetch");
+    __publicField(this, "drainPromise", null);
+    __publicField(this, "retryTimer", null);
+    __publicField(this, "stopped", false);
+    __publicField(this, "flushFailures", 0);
+    __publicField(this, "retryAfterDrainMs", null);
+    __publicField(this, "activeAbortController", null);
+    __publicField(this, "abortCurrentRequest", null);
+    this.options = options;
+    this.fetch = options.startOptions.fetch;
+  }
+  async enqueue(envelope, payload) {
+    if (this.stopped) {
+      return;
+    }
+    const mutation = await this.options.outbox.enqueue({
+      id: frameId(envelope),
+      envelope,
+      payload,
+      attempts: 0,
+      createdAtUnixMs: Date.now()
+    });
+    if (mutation.dropped > 0) {
+      this.options.onDiagnostic("outbox-overflow", {
+        dropped: mutation.dropped
+      });
+    }
+    await this.drain();
+  }
+  async restore() {
+    await this.drain();
+  }
+  async drain() {
+    if (this.stopped) {
+      return;
+    }
+    if (this.drainPromise) {
+      return await this.drainPromise;
+    }
+    this.drainPromise = this.drainLoop().finally(() => {
+      this.drainPromise = null;
+      if (this.retryAfterDrainMs !== null) {
+        const delayMs = this.retryAfterDrainMs;
+        this.retryAfterDrainMs = null;
+        this.scheduleRetry(delayMs);
+      }
+    });
+    return await this.drainPromise;
+  }
+  destroy() {
+    this.stopped = true;
+    this.activeAbortController?.abort();
+    this.abortCurrentRequest?.();
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  getFlushFailures() {
+    return this.flushFailures;
+  }
+  async drainLoop() {
+    const frames = await this.options.outbox.list();
+    for (const frame of frames) {
+      if (this.stopped) {
+        return;
+      }
+      const outcome = await this.post(frame);
+      if (outcome === "remove") {
+        await this.options.outbox.remove(frame.id);
+        continue;
+      }
+      if (outcome === "remove-and-halt") {
+        await this.options.outbox.remove(frame.id);
+        return;
+      }
+      if (outcome === "stop") {
+        return;
+      }
+      const attempts = await this.options.outbox.incrementAttempts(
+        frame.id
+      );
+      this.flushFailures += 1;
+      if (attempts >= MAX_ATTEMPTS_PER_FRAME) {
+        await this.options.outbox.remove(frame.id);
+        this.options.onDiagnostic("chunk-retry-exhausted", {
+          chunkIndex: frame.envelope.chunkIndex
+        });
+        continue;
+      }
+      if (this.retryAfterDrainMs === null) {
+        this.retryAfterDrainMs = DEFAULT_RETRY_MS;
+      }
+      return;
+    }
+  }
+  async post(frame) {
+    const encoded = encodeReplayFrame(
+      frame.envelope,
+      frame.payload
+    );
+    if (encoded.body.byteLength > MAX_SESSION_REPLAY_CHUNK_BYTES) {
+      this.options.onDiagnostic("chunk-too-large", {
+        chunkIndex: frame.envelope.chunkIndex,
+        bytes: encoded.body.byteLength
+      });
+      return "remove";
+    }
+    let response;
+    let said;
+    const controller = typeof AbortController === "undefined" ? null : new AbortController();
+    this.activeAbortController = controller;
+    let timedOut = false;
+    let timeout = null;
+    let abortDeadline = null;
+    try {
+      const request = (async () => {
+        const requestInit = {
+          method: "POST",
+          headers: {
+            ...mobileRequestHeaders(this.options.startOptions),
+            "Content-Type": SESSION_REPLAY_CONTENT_TYPE
+          },
+          body: encoded.body
+        };
+        if (controller) {
+          requestInit.signal = controller.signal;
+        }
+        const fetched = await this.fetch(
+          `${this.options.startOptions.host}${CHUNK_PATH}`,
+          requestInit
+        );
+        return { response: fetched, said: await readDirective(fetched) };
+      })();
+      const deadline = new Promise(
+        (_resolve, reject) => {
+          abortDeadline = () => {
+            controller?.abort();
+            reject(new Error("chunk-post-aborted"));
+          };
+          this.abortCurrentRequest = abortDeadline;
+          timeout = setTimeout(() => {
+            timedOut = true;
+            abortDeadline?.();
+          }, CHUNK_POST_TIMEOUT_MS);
+        }
+      );
+      ({ response, said } = await Promise.race([request, deadline]));
+    } catch {
+      if (this.stopped) {
+        return "stop";
+      }
+      this.options.onDiagnostic(
+        timedOut ? "chunk-post-timeout" : "chunk-network-failure",
+        {
+          chunkIndex: frame.envelope.chunkIndex
+        }
+      );
+      return "retry";
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      if (this.activeAbortController === controller) {
+        this.activeAbortController = null;
+      }
+      if (this.abortCurrentRequest === abortDeadline) {
+        this.abortCurrentRequest = null;
+      }
+    }
+    if (said.directive) {
+      this.options.onDirective(said.directive, said.reason);
+    }
+    if (said.directive === "stop") {
+      this.stopped = true;
+      await this.options.outbox.clear();
+      return "stop";
+    }
+    if (response.status >= 200 && response.status < 300) {
+      if (said.directive === "throttle") {
+        this.retryAfterDrainMs = Math.min(
+          MAX_RETRY_MS,
+          (said.retryAfterSeconds ?? DEFAULT_RETRY_MS / 1e3) * 1e3
+        );
+        return "remove-and-halt";
+      }
+      return "remove";
+    }
+    if (response.status === 400 || response.status === 413 || response.status === 422) {
+      this.options.onDiagnostic("chunk-refused", {
+        status: response.status,
+        chunkIndex: frame.envelope.chunkIndex,
+        reason: said.reason
+      });
+      return "remove";
+    }
+    if (response.status === 401 || response.status === 403 || response.status === 404) {
+      this.options.onDiagnostic("transport-disabled", {
+        status: response.status,
+        reason: said.reason
+      });
+      this.options.onDirective("stop", said.reason ?? "transport-disabled");
+      this.stopped = true;
+      await this.options.outbox.clear();
+      return "stop";
+    }
+    const retryMs = Math.min(
+      MAX_RETRY_MS,
+      (said.retryAfterSeconds ?? DEFAULT_RETRY_MS / 1e3) * 1e3
+    );
+    this.retryAfterDrainMs = retryMs;
+    return "retry";
+  }
+  scheduleRetry(delayMs) {
+    if (this.retryTimer || this.stopped) {
+      return;
+    }
+    this.retryTimer = setTimeout(
+      () => {
+        this.retryTimer = null;
+        void this.drain();
+      },
+      Math.max(0, delayMs)
+    );
+  }
+};
+
+// src/TouchPrivacy.ts
+var MAX_PRIVACY_TREE_NODES = 5e3;
+var OPAQUE_KINDS = /* @__PURE__ */ new Set([
+  "image",
+  "webview",
+  "canvas",
+  "masked"
+]);
+var CONSERVATIVE_TOUCH_PRIVACY_MAP = {
+  regions: [],
+  suppressAll: true
+};
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function deriveTouchPrivacyMap(root) {
+  const regions = [];
+  const hasRootOrigin = finite(root.touchOriginX) && finite(root.touchOriginY);
+  const rootX = hasRootOrigin ? root.touchOriginX : 0;
+  const rootY = hasRootOrigin ? root.touchOriginY : 0;
+  let suppressAll = finite(root.truncatedNodes) && root.truncatedNodes > 0;
+  let visited = 0;
+  const visit = (node, parentX, parentY, alignedPath, isRoot) => {
+    if (visited >= MAX_PRIVACY_TREE_NODES) {
+      suppressAll = true;
+      return;
+    }
+    visited += 1;
+    const hasGeometry = finite(node.x) && finite(node.y) && finite(node.width) && finite(node.height);
+    const left = isRoot ? parentX : parentX + (finite(node.x) ? node.x : 0);
+    const top = isRoot ? parentY : parentY + (finite(node.y) ? node.y : 0);
+    const pathIsAligned = alignedPath && hasGeometry;
+    const opaque = node.masked === true || node.opaque === true || OPAQUE_KINDS.has(typeof node.kind === "string" ? node.kind : "");
+    if (opaque) {
+      if (!pathIsAligned || !hasRootOrigin) {
+        suppressAll = true;
+        return;
+      }
+      if (node.width > 0 && node.height > 0) {
+        regions.push({
+          left,
+          top,
+          right: left + node.width,
+          bottom: top + node.height
+        });
+      }
+      return;
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        if (child && typeof child === "object") {
+          visit(child, left, top, pathIsAligned, false);
+        }
+      }
+    }
+  };
+  visit(root, rootX, rootY, hasRootOrigin, true);
+  return { regions, suppressAll };
+}
+function isTouchPrivate(privacyMap, x2, y) {
+  if (privacyMap.suppressAll || !finite(x2) || !finite(y)) {
+    return true;
+  }
+  return privacyMap.regions.some((region) => {
+    return x2 >= region.left && x2 <= region.right && y >= region.top && y <= region.bottom;
+  });
+}
+
+// src/MobileReplayRecorder.ts
+var MAX_DIAGNOSTIC_EVENTS = 100;
+var TOUCH_MOVE_SAMPLE_MS = 50;
+var MOBILE_POLICY_REFRESH_INTERVAL_MS = 5 * 6e4;
+var SAFE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "AggregateError",
+  "Error",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+]);
+function defaultNow() {
+  return Date.now();
+}
+function deterministicSample(sessionId, percentage) {
+  if (percentage >= 100) {
+    return true;
+  }
+  if (percentage <= 0) {
+    return false;
+  }
+  let hash = 2166136261;
+  for (let index = 0; index < sessionId.length; index += 1) {
+    hash ^= sessionId.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) % 1e4 < Math.round(percentage * 100);
+}
+function hashNamespaceSecret(value) {
+  const seeds = [
+    2166136261,
+    2654435761,
+    1013904223,
+    3747611933
+  ];
+  return seeds.map((seed) => {
+    let hash = seed;
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }).join("");
+}
+function getReplayStorageNamespace(options) {
+  const scope = [
+    options.host,
+    options.appIdentifier,
+    options.mobileAppIdentifier,
+    hashNamespaceSecret(options.token)
+  ].join("\0");
+  return `v1-${hashNamespaceSecret(scope)}`;
+}
+function safeMetadataValue(value, fallback, maximumLength = 100) {
+  return typeof value === "string" && value.trim() ? truncate(value.trim(), maximumLength) : fallback;
+}
+function isRetryablePolicyFailure(config) {
+  if (config.disabledReason === "config-fetch-failed") {
+    return true;
+  }
+  const match = config.disabledReason?.match(/^config-http-(\d{3})$/u) ?? null;
+  if (!match) {
+    return false;
+  }
+  const status = Number(match[1]);
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+var MobileReplayRecorder = class {
+  constructor(dependencies = {}) {
+    __publicField(this, "storage");
+    __publicField(this, "nativeViewTree");
+    __publicField(this, "appState");
+    __publicField(this, "now");
+    __publicField(this, "serializer", new ViewTreeSerializer());
+    __publicField(this, "chunkBuffer", new ReplayChunkBuffer());
+    __publicField(this, "rollingBuffer", new RollingReplayBuffer());
+    __publicField(this, "diagnosticsStatus", "idle");
+    __publicField(this, "diagnosticsEvents", []);
+    __publicField(this, "options", null);
+    __publicField(this, "config", null);
+    __publicField(this, "sessionStore", null);
+    __publicField(this, "identity", null);
+    __publicField(this, "outbox", null);
+    __publicField(this, "transport", null);
+    __publicField(this, "metadata", {
+      appName: "React Native",
+      appVersion: "unknown",
+      osName: "unknown",
+      osVersion: "unknown"
+    });
+    __publicField(this, "rootTag", null);
+    __publicField(this, "route", "/");
+    __publicField(this, "entryUrl", "");
+    __publicField(this, "captureTimer", null);
+    __publicField(this, "flushTimer", null);
+    __publicField(this, "appStateSubscription", null);
+    __publicField(this, "captureGeneration", null);
+    __publicField(this, "running", false);
+    __publicField(this, "foreground", true);
+    __publicField(this, "forceFullSnapshot", true);
+    __publicField(this, "lastFullSnapshotAtUnixMs", 0);
+    __publicField(this, "sampled", false);
+    __publicField(this, "triggered", false);
+    __publicField(this, "uploadActive", false);
+    __publicField(this, "consentGranted", false);
+    __publicField(this, "triggerReason", "sampled" /* Sampled */);
+    __publicField(this, "userRef", null);
+    __publicField(this, "traits", {});
+    __publicField(this, "tags", {});
+    __publicField(this, "metaDirty", true);
+    __publicField(this, "droppedEvents", 0);
+    __publicField(this, "closeQueue", Promise.resolve());
+    __publicField(this, "lastTouchMoveAtUnixMs", 0);
+    __publicField(this, "previousGlobalErrorHandler", null);
+    __publicField(this, "installedGlobalErrorHandler", null);
+    __publicField(this, "globalErrorUtils", null);
+    __publicField(this, "lifecycleGeneration", 0);
+    __publicField(this, "lifecycleCancellationEpoch", 0);
+    __publicField(this, "lifecycleQueue", Promise.resolve());
+    __publicField(this, "pendingStart", null);
+    __publicField(this, "pendingStartCancellation", null);
+    __publicField(this, "identityPersisted", false);
+    __publicField(this, "sessionLastActivityUnixMs", 0);
+    __publicField(this, "rotatingSession", false);
+    __publicField(this, "rotationPromise", null);
+    __publicField(this, "appStateQueue", Promise.resolve());
+    __publicField(this, "acceptingEvents", false);
+    __publicField(this, "lastPolicyRefreshAtUnixMs", 0);
+    __publicField(this, "policyRefreshPromise", null);
+    __publicField(this, "identityQueue", Promise.resolve());
+    __publicField(this, "identityCancellationEpoch", 0);
+    __publicField(this, "pendingIdentityOperations", 0);
+    __publicField(this, "sessionChangeListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "lastNotifiedSessionId", null);
+    __publicField(this, "touchPrivacyMap", CONSERVATIVE_TOUCH_PRIVACY_MAP);
+    __publicField(this, "touchQueue", Promise.resolve());
+    __publicField(this, "suppressedTouchPointers", /* @__PURE__ */ new Set());
+    __publicField(this, "unidentifiedTouchCount", 0);
+    __publicField(this, "unidentifiedTouchPrivate", false);
+    this.storage = dependencies.storage ?? defaultReplayStorage;
+    this.nativeViewTree = dependencies.nativeViewTree ?? defaultNativeViewTreeAdapter;
+    this.appState = dependencies.appState ?? import_react_native2.AppState;
+    this.now = dependencies.now ?? defaultNow;
+  }
+  start(options) {
+    if (this.pendingStart && this.pendingStart.generation === this.lifecycleCancellationEpoch) {
+      return this.pendingStart.promise;
+    }
+    const requestGeneration = this.lifecycleCancellationEpoch;
+    const identityBarrier = this.identityQueue;
+    const promise = this.enqueueLifecycleOperation(
+      async () => {
+        await identityBarrier;
+        if (requestGeneration !== this.lifecycleCancellationEpoch) {
+          return false;
+        }
+        return await this.startNow(options);
+      }
+    );
+    this.pendingStart = { generation: requestGeneration, promise };
+    void promise.then(
+      () => {
+        if (this.pendingStart?.promise === promise) {
+          this.pendingStart = null;
+        }
+      },
+      () => {
+        if (this.pendingStart?.promise === promise) {
+          this.pendingStart = null;
+        }
+      }
+    );
+    return promise;
+  }
+  async startNow(options) {
+    if (this.running) {
+      return true;
+    }
+    const generation = this.lifecycleGeneration + 1;
+    this.lifecycleGeneration = generation;
+    let cancelStart = () => {
+      return void 0;
+    };
+    const cancellation = new Promise(
+      (resolve) => {
+        cancelStart = () => {
+          resolve(false);
+        };
+      }
+    );
+    this.pendingStartCancellation = { generation, cancel: cancelStart };
+    const work = this.startInternal(options, generation);
+    try {
+      return await Promise.race([work, cancellation]);
+    } finally {
+      if (this.pendingStartCancellation?.generation === generation) {
+        this.pendingStartCancellation = null;
+      }
+    }
+  }
+  async startInternal(options, generation) {
+    this.acceptingEvents = false;
+    this.diagnosticsStatus = "starting";
+    this.serializer.reset();
+    this.chunkBuffer.clear();
+    this.rollingBuffer.clear();
+    this.closeQueue = Promise.resolve();
+    this.appStateQueue = Promise.resolve();
+    this.rotationPromise = null;
+    this.rotatingSession = false;
+    this.policyRefreshPromise = null;
+    this.lastPolicyRefreshAtUnixMs = 0;
+    this.forceFullSnapshot = true;
+    this.lastFullSnapshotAtUnixMs = 0;
+    this.touchPrivacyMap = CONSERVATIVE_TOUCH_PRIVACY_MAP;
+    this.touchQueue = Promise.resolve();
+    this.resetTouchSequences();
+    const validated = validateStartOptions(options);
+    if (!validated) {
+      this.disable("invalid-start-options");
+      return false;
+    }
+    if (validated.userRef) {
+      this.userRef = truncate(validated.userRef, MAX_USER_REFERENCE_LENGTH);
+    }
+    this.options = this.userRef ? { ...validated, userRef: this.userRef } : validated;
+    if (this.nativeViewTree.isAvailable?.() === false) {
+      this.disable("native-module-unavailable", {
+        expoGoUnsupported: true
+      });
+      return false;
+    }
+    let config = await fetchReplayConfig(this.options);
+    if (!this.isCurrentGeneration(generation)) {
+      return false;
+    }
+    if (config.enabled && this.userRef && (config.consentMode === "NotRequired" /* NotRequired */ || this.consentGranted)) {
+      config = await this.refreshTargetingConfig(config);
+      if (!this.isCurrentGeneration(generation)) {
+        return false;
+      }
+    }
+    this.config = config;
+    if (!config.enabled) {
+      this.disable("config-disabled", {
+        reason: config.disabledReason ?? "not-reported"
+      });
+      return false;
+    }
+    this.lastPolicyRefreshAtUnixMs = this.now();
+    const namespace = getReplayStorageNamespace(validated);
+    const sessionStore = new ReplaySessionStore(
+      this.storage,
+      namespace
+    );
+    this.sessionStore = sessionStore;
+    const nowUnixMs = this.now();
+    const awaitingConsent = config.consentMode === "RequireExplicit" /* RequireExplicit */ && !this.consentGranted;
+    if (awaitingConsent) {
+      this.identity = this.ephemeralIdentity(nowUnixMs);
+      this.identityPersisted = false;
+      this.sampled = false;
+    } else {
+      const identity = await sessionStore.resolve(nowUnixMs);
+      if (!this.isCurrentGeneration(generation) || this.sessionStore !== sessionStore) {
+        return false;
+      }
+      this.identity = identity;
+      this.identityPersisted = true;
+      this.sampled = deterministicSample(
+        this.identity.sessionId,
+        config.samplePercentage
+      );
+    }
+    this.sessionLastActivityUnixMs = nowUnixMs;
+    if (!awaitingConsent && config.captureTrigger === "Always" /* Always */ && !this.sampled && !config.isTargeted) {
+      this.disable("not-sampled");
+      return false;
+    }
+    this.outbox = new ReplayOutbox(this.storage, namespace);
+    this.transport = this.createTransport(validated, this.outbox);
+    try {
+      const nativeMetadata = await this.nativeViewTree.getAppMetadata();
+      if (!this.isCurrentGeneration(generation)) {
+        return false;
+      }
+      this.metadata = {
+        appName: safeMetadataValue(
+          validated.appName,
+          safeMetadataValue(nativeMetadata?.appName, "React Native")
+        ),
+        appVersion: safeMetadataValue(
+          validated.appVersion,
+          safeMetadataValue(nativeMetadata?.appVersion, "unknown")
+        ),
+        osName: safeMetadataValue(nativeMetadata?.osName, "unknown"),
+        osVersion: safeMetadataValue(nativeMetadata?.osVersion, "unknown")
+      };
+    } catch {
+      if (!this.isCurrentGeneration(generation)) {
+        return false;
+      }
+      this.diagnostic("native-metadata-unavailable");
+    }
+    this.route = "/";
+    this.entryUrl = toAppUrl(validated.mobileAppIdentifier, this.route);
+    this.running = true;
+    this.acceptingEvents = true;
+    this.triggered = config.isTargeted;
+    this.triggerReason = config.isTargeted ? "manual" /* Manual */ : "sampled" /* Sampled */;
+    const hasConsent = config.consentMode === "NotRequired" /* NotRequired */ || this.consentGranted;
+    this.uploadActive = hasConsent && (this.sampled || config.isTargeted || this.triggered);
+    this.foreground = this.appState.currentState === "active";
+    this.diagnosticsStatus = hasConsent ? this.foreground ? "recording" : "background" : "consent-required";
+    this.notifySessionChange();
+    this.installLifecycle();
+    this.installGlobalErrorHandler();
+    if (this.foreground) {
+      this.startTimers();
+      await this.captureTick(true);
+    }
+    if (!this.running) {
+      return false;
+    }
+    if (this.uploadActive) {
+      await this.transport.restore();
+    }
+    if (!this.isCurrentGeneration(generation) || !this.running) {
+      return false;
+    }
+    this.diagnostic("recorder-started", {
+      sampled: this.sampled,
+      consentState: this.consentState()
+    });
+    return true;
+  }
+  stop() {
+    const identityBarrier = this.identityQueue;
+    this.lifecycleGeneration += 1;
+    this.lifecycleCancellationEpoch += 1;
+    this.pendingStartCancellation?.cancel();
+    this.acceptingEvents = false;
+    this.quiesceCapture();
+    return this.enqueueLifecycleOperation(async () => {
+      await identityBarrier;
+      await this.stopInternal();
+    });
+  }
+  async stopInternal() {
+    if (!this.running) {
+      this.diagnosticsStatus = "stopped";
+      return;
+    }
+    if (this.rotationPromise) {
+      await this.rotationPromise;
+    }
+    if (!this.running) {
+      this.diagnosticsStatus = "stopped";
+      return;
+    }
+    this.appendCustom(
+      VISIBILITY_CUSTOM_EVENT_TAG,
+      { state: "stopped" },
+      void 0,
+      true
+    );
+    this.haltCapture();
+    await this.closeCurrent(true);
+    if (this.uploadActive) {
+      await this.transport?.drain();
+    } else {
+      this.rollingBuffer.clear();
+    }
+    this.transport?.destroy();
+    this.diagnosticsStatus = "stopped";
+    this.diagnostic("recorder-stopped");
+  }
+  grantConsent() {
+    const identityBarrier = this.identityQueue;
+    return this.enqueueLifecycleOperation(async () => {
+      await identityBarrier;
+      await this.grantConsentInternal();
+    });
+  }
+  async grantConsentInternal() {
+    this.consentGranted = true;
+    if (!this.running && this.options) {
+      const options = this.options;
+      await this.startNow(options);
+      return;
+    }
+    if (!this.running || !this.config) {
+      return;
+    }
+    const generation = this.lifecycleGeneration;
+    const refreshed = await this.refreshRuntimePolicy(
+      generation,
+      true,
+      "consent"
+    );
+    if (!refreshed || !this.running || !this.consentGranted || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    this.diagnosticsStatus = this.foreground ? "recording" : "background";
+    this.diagnostic("consent-granted");
+  }
+  revokeConsent() {
+    this.lifecycleGeneration += 1;
+    this.lifecycleCancellationEpoch += 1;
+    this.identityCancellationEpoch += 1;
+    this.pendingStartCancellation?.cancel();
+    this.consentGranted = false;
+    this.acceptingEvents = false;
+    this.haltCapture();
+    this.transport?.destroy();
+    return this.enqueueLifecycleOperation(async () => {
+      return this.revokeConsentInternal();
+    });
+  }
+  async revokeConsentInternal() {
+    this.haltCapture();
+    this.transport?.destroy();
+    this.chunkBuffer.clear();
+    this.rollingBuffer.clear();
+    this.serializer.reset();
+    await this.closeQueue.catch(() => {
+      return void 0;
+    });
+    await this.outbox?.clear();
+    await this.sessionStore?.clear();
+    this.identity = null;
+    this.userRef = null;
+    this.traits = {};
+    this.tags = {};
+    this.uploadActive = false;
+    this.triggered = false;
+    this.diagnosticsStatus = "consent-revoked";
+    this.diagnostic("consent-revoked");
+  }
+  identify(userRef, traits) {
+    const trimmedRef = typeof userRef === "string" ? userRef.trim() : "";
+    const ref = trimmedRef ? truncate(trimmedRef, MAX_USER_REFERENCE_LENGTH) : null;
+    const sanitizedTraits = traits === void 0 ? null : maskStringMapValues(sanitizeTraits(traits));
+    const identityEpoch = this.identityCancellationEpoch;
+    const lifecycleBarrier = this.lifecycleQueue;
+    this.pendingIdentityOperations += 1;
+    const operation = this.identityQueue.then(
+      async () => {
+        await lifecycleBarrier;
+        await this.applyIdentityChange(ref, sanitizedTraits, identityEpoch);
+      }
+    );
+    this.identityQueue = operation.then(
+      () => {
+        this.pendingIdentityOperations = Math.max(
+          0,
+          this.pendingIdentityOperations - 1
+        );
+      },
+      () => {
+        this.pendingIdentityOperations = Math.max(
+          0,
+          this.pendingIdentityOperations - 1
+        );
+        this.diagnostic("identity-change-failed");
+      }
+    );
+  }
+  setTags(tags) {
+    const sanitizedTags = sanitizeTags(tags);
+    this.runExternalActivity(this.now(), () => {
+      this.tags = sanitizedTags;
+      this.metaDirty = true;
+      this.appendCustom(TAGS_CUSTOM_EVENT_TAG, { ...this.tags });
+    });
+  }
+  addTag(key, value) {
+    if (typeof key !== "string") {
+      return;
+    }
+    const safeKey = truncate(key.trim(), MAX_TAG_KEY_LENGTH);
+    if (!safeKey) {
+      return;
+    }
+    const safeValue = truncate(String(value), MAX_TAG_VALUE_LENGTH);
+    this.runExternalActivity(this.now(), () => {
+      this.tags = sanitizeTags({
+        ...this.tags,
+        [safeKey]: safeValue
+      });
+      this.metaDirty = true;
+      this.appendCustom(TAGS_CUSTOM_EVENT_TAG, { ...this.tags });
+    });
+  }
+  track(name, properties) {
+    const eventName = typeof name === "string" ? truncate(name.trim(), MAX_CUSTOM_EVENT_NAME_LENGTH) : "";
+    if (!eventName) {
+      return;
+    }
+    const sanitizedProperties = maskStringMapValues(
+      sanitizeEventProperties(properties)
+    );
+    this.runExternalActivity(this.now(), () => {
+      this.appendCustom(
+        CUSTOM_EVENT_TAG,
+        { name: eventName, properties: sanitizedProperties },
+        "customEventCount"
+      );
+    });
+  }
+  async setRoute(route) {
+    await this.identityQueue;
+    if (this.running && !this.acceptingEvents) {
+      this.route = sanitizeRoute(route);
+      return;
+    }
+    await this.maybeRotateSession(this.now());
+    if (!this.options) {
+      this.route = sanitizeRoute(route);
+      return;
+    }
+    const previous = this.route;
+    const next = sanitizeRoute(route);
+    if (previous === next) {
+      return;
+    }
+    this.route = next;
+    this.appendCustom(
+      ROUTE_CUSTOM_EVENT_TAG,
+      {
+        from: toAppUrl(this.options.mobileAppIdentifier, previous),
+        to: toAppUrl(this.options.mobileAppIdentifier, next),
+        kind: "manual"
+      },
+      "routeCount"
+    );
+    await this.closeCurrent(false);
+    this.forceFullSnapshot = true;
+    await this.captureTick(true);
+  }
+  async captureSession(reason = "manual") {
+    await this.identityQueue;
+    if (!this.running || !this.acceptingEvents) {
+      return;
+    }
+    await this.maybeRotateSession(this.now());
+    const safeReason2 = truncate(
+      (typeof reason === "string" ? reason.trim() : "") || "manual",
+      MAX_CAPTURE_REASON_LENGTH
+    );
+    this.appendCustom(CUSTOM_EVENT_TAG, {
+      name: "oneuptime.capture",
+      properties: { reason: maskTextValue(safeReason2) }
+    });
+    await this.trigger("manual" /* Manual */);
+  }
+  async captureError(error) {
+    await this.identityQueue;
+    if (!this.running || !this.acceptingEvents) {
+      return;
+    }
+    await this.maybeRotateSession(this.now());
+    const rawName = error instanceof Error && typeof error.name === "string" ? error.name.trim() : "";
+    const name = SAFE_ERROR_NAMES.has(rawName) ? rawName : "Error";
+    this.appendCustom(
+      ERROR_CUSTOM_EVENT_TAG,
+      { kind: "error", name, message: "[masked]" },
+      "errorCount"
+    );
+    await this.trigger("error" /* Error */);
+  }
+  recordTouch(touch) {
+    const sanitizedTouch = sanitizeRecordedTouch(
+      touch,
+      this.now()
+    );
+    if (!sanitizedTouch) {
+      this.diagnostic("invalid-touch-event");
+      return;
+    }
+    if (!this.running || !this.acceptingEvents || !this.foreground) {
+      return;
+    }
+    const generation = this.lifecycleGeneration;
+    const operation = this.touchQueue.then(
+      async () => {
+        await this.recordTouchAfterPrivacyCheck(sanitizedTouch, generation);
+      }
+    );
+    this.touchQueue = operation.catch(() => {
+      this.diagnostic("touch-privacy-check-failed");
+    });
+  }
+  async recordTouchAfterPrivacyCheck(touch, generation) {
+    if (!this.running || !this.acceptingEvents || !this.foreground || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    const pointIsPrivate = await this.isCurrentTouchPrivate(touch);
+    if (!this.running || !this.acceptingEvents || !this.foreground || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    if (this.updateTouchSuppression(touch, pointIsPrivate)) {
+      this.diagnostic("touch-suppressed-private-region");
+      return;
+    }
+    if (touch.phase === "move" && touch.timestamp - this.lastTouchMoveAtUnixMs < TOUCH_MOVE_SAMPLE_MS) {
+      return;
+    }
+    if (touch.phase === "move") {
+      this.lastTouchMoveAtUnixMs = touch.timestamp;
+    }
+    const nowUnixMs = this.now();
+    if (this.rotatingSession || this.rotationReason(nowUnixMs)) {
+      this.diagnostic("touch-dropped-session-rotation");
+      void this.maybeRotateSession(nowUnixMs);
+      return;
+    }
+    this.appendEvent(
+      createTouchEvent(touch),
+      touch.phase === "start" ? "clickCount" : void 0
+    );
+    if (touch.phase === "start") {
+      this.appendCustom(TOUCH_CUSTOM_EVENT_TAG, {
+        phase: "start",
+        x: touch.x,
+        y: touch.y
+      });
+    }
+  }
+  setRootTag(rootTag) {
+    this.rootTag = typeof rootTag === "number" && Number.isSafeInteger(rootTag) && rootTag > 0 ? rootTag : null;
+    this.forceFullSnapshot = true;
+    this.touchPrivacyMap = CONSERVATIVE_TOUCH_PRIVACY_MAP;
+    this.resetTouchSequences();
+    if (this.rootTag && this.running && this.acceptingEvents && this.foreground) {
+      void this.captureTick(true);
+    }
+  }
+  getDiagnostics() {
+    return {
+      status: this.diagnosticsStatus,
+      sessionId: this.identity?.sessionId ?? null,
+      recorderKind: MOBILE_RECORDER_KIND,
+      configEpoch: this.config?.configEpoch ?? 0,
+      sampled: this.sampled,
+      triggered: this.triggered,
+      consentState: this.consentState(),
+      pendingEvents: this.rollingBuffer.length + (this.chunkBuffer.isEmpty() ? 0 : 1),
+      events: this.diagnosticsEvents.map(
+        (event) => {
+          const copied = {
+            code: event.code,
+            atUnixMs: event.atUnixMs
+          };
+          if (event.details) {
+            copied.details = { ...event.details };
+          }
+          return copied;
+        }
+      )
+    };
+  }
+  /** Current consented replay session for host trace/log correlation. */
+  getSessionId() {
+    return this.running && this.identityPersisted ? this.identity?.sessionId ?? null : null;
+  }
+  /** Fires immediately when a session exists and again on rotate/clear. */
+  onSessionChange(listener) {
+    if (typeof listener !== "function") {
+      return () => {
+        return void 0;
+      };
+    }
+    this.sessionChangeListeners.add(listener);
+    const sessionId = this.getSessionId();
+    if (sessionId) {
+      try {
+        listener(sessionId);
+      } catch {
+      }
+    }
+    return () => {
+      this.sessionChangeListeners.delete(listener);
+    };
+  }
+  async trigger(reason) {
+    if (!this.running || !this.acceptingEvents || this.triggered || this.uploadActive || this.sampled || this.config?.isTargeted) {
+      return;
+    }
+    this.triggered = true;
+    this.triggerReason = reason;
+    this.diagnostic("capture-triggered", { reason });
+    if (this.consentState() !== "Unknown") {
+      await this.activateUpload(this.lifecycleGeneration);
+    }
+  }
+  async activateUpload(generation) {
+    if (!this.running || !this.acceptingEvents || this.uploadActive || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    await this.closeCurrent(false);
+    if (!this.running || !this.acceptingEvents || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    this.uploadActive = true;
+    const buffered = this.rollingBuffer.drain();
+    for (const segment of buffered) {
+      if (!this.running || !this.acceptingEvents || !this.isCurrentGeneration(generation)) {
+        return;
+      }
+      await this.uploadSegment(segment, false);
+    }
+    if (!this.running || !this.acceptingEvents || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    await this.transport?.restore();
+  }
+  async captureTick(force = false) {
+    const generation = this.lifecycleGeneration;
+    if (!this.running || !this.acceptingEvents || !this.foreground || !this.rootTag || this.captureGeneration === generation || !this.options) {
+      return;
+    }
+    this.captureGeneration = generation;
+    try {
+      const nowUnixMs = this.now();
+      const policyReady = await this.refreshRuntimePolicy(
+        generation,
+        false,
+        "periodic"
+      );
+      if (!policyReady) {
+        return;
+      }
+      await this.maybeRotateSession(nowUnixMs);
+      if (!this.running || !this.acceptingEvents || !this.foreground || !this.isCurrentGeneration(generation)) {
+        return;
+      }
+      const capturedSessionId = this.identity?.sessionId;
+      const tree = await this.nativeViewTree.captureViewTree(this.rootTag);
+      if (!this.running || !this.acceptingEvents || !this.foreground || !this.isCurrentGeneration(generation) || this.rotatingSession || !capturedSessionId || this.identity?.sessionId !== capturedSessionId) {
+        return;
+      }
+      this.touchPrivacyMap = deriveTouchPrivacyMap(tree);
+      const size = getViewport();
+      const shouldForce = force || this.forceFullSnapshot || nowUnixMs - this.lastFullSnapshotAtUnixMs >= SESSION_REPLAY_CHECKOUT_INTERVAL_MS;
+      if (shouldForce && !this.chunkBuffer.isEmpty()) {
+        await this.closeCurrent(false);
+      }
+      if (!this.running || !this.acceptingEvents || !this.foreground || !this.isCurrentGeneration(generation) || this.identity?.sessionId !== capturedSessionId) {
+        return;
+      }
+      const capture = this.serializer.capture(tree, {
+        timestamp: nowUnixMs,
+        url: toAppUrl(this.options.mobileAppIdentifier, this.route),
+        viewportWidth: size.width,
+        viewportHeight: size.height,
+        forceFullSnapshot: shouldForce
+      });
+      this.droppedEvents += capture.droppedNodes;
+      this.chunkBuffer.appendMany(capture.events, {
+        route: toAppUrl(this.options.mobileAppIdentifier, this.route),
+        fidelityNotices: capture.fidelityNotices
+      });
+      if (capture.hasFullSnapshot) {
+        this.lastFullSnapshotAtUnixMs = nowUnixMs;
+        this.forceFullSnapshot = false;
+      }
+      if (this.chunkBuffer.shouldFlush()) {
+        await this.closeCurrent(false);
+      }
+    } catch (error) {
+      if (this.running && this.isCurrentGeneration(generation)) {
+        this.disable("native-capture-failed", {
+          name: error instanceof Error ? error.name : "Error"
+        });
+        this.haltCapture();
+      }
+    } finally {
+      if (this.captureGeneration === generation) {
+        this.captureGeneration = null;
+      }
+    }
+  }
+  appendCustom(tag, payload, signal, allowWhenQuiesced = false) {
+    this.appendEvent(
+      createCustomEvent(tag, payload, this.now()),
+      signal,
+      allowWhenQuiesced
+    );
+  }
+  appendEvent(event, signal, allowWhenQuiesced = false) {
+    if (!this.running || !this.acceptingEvents && !allowWhenQuiesced) {
+      return;
+    }
+    if (!Number.isFinite(event.timestamp)) {
+      this.droppedEvents += 1;
+      this.diagnostic("invalid-event-timestamp");
+      return;
+    }
+    this.sessionLastActivityUnixMs = Math.max(
+      this.sessionLastActivityUnixMs,
+      event.timestamp
+    );
+    const appendOptions = {};
+    if (this.options) {
+      appendOptions.route = toAppUrl(
+        this.options.mobileAppIdentifier,
+        this.route
+      );
+    }
+    if (signal) {
+      appendOptions.signal = signal;
+    }
+    const accepted = this.chunkBuffer.append(event, appendOptions);
+    if (!accepted) {
+      this.droppedEvents += 1;
+    }
+    if (this.chunkBuffer.shouldFlush()) {
+      void this.closeCurrent(false);
+    }
+  }
+  async closeCurrent(isFinal) {
+    const closesFinalChunkSlot = !isFinal && !this.rotatingSession && this.uploadActive && this.sessionStore?.getNextChunkIndex() === MAX_SESSION_REPLAY_CHUNKS_PER_SESSION - 1;
+    if (closesFinalChunkSlot) {
+      this.rotatingSession = true;
+      const rotationOptions = {};
+      if (this.options) {
+        rotationOptions.route = toAppUrl(
+          this.options.mobileAppIdentifier,
+          this.route
+        );
+      }
+      this.chunkBuffer.append(
+        createCustomEvent(
+          "oneuptime.session-rotated",
+          { reason: "chunk-cap" },
+          this.now()
+        ),
+        rotationOptions
+      );
+    }
+    const segment = this.chunkBuffer.take();
+    if (!segment) {
+      if (closesFinalChunkSlot) {
+        this.rotatingSession = false;
+      }
+      return;
+    }
+    const operation = this.closeQueue.then(
+      async () => {
+        return this.processSegment(segment, isFinal || closesFinalChunkSlot);
+      }
+    );
+    if (closesFinalChunkSlot) {
+      const rotation = operation.then(
+        async () => {
+          if (this.running) {
+            await this.completeSessionIdentityRotation(this.now(), "chunk-cap");
+          }
+        }
+      );
+      this.rotationPromise = rotation;
+      this.closeQueue = rotation.catch(() => {
+        this.diagnostic("chunk-close-failed");
+      });
+      try {
+        await rotation;
+      } finally {
+        if (this.rotationPromise === rotation) {
+          this.rotationPromise = null;
+        }
+        this.rotatingSession = false;
+      }
+      return;
+    }
+    this.closeQueue = operation.catch(() => {
+      this.diagnostic("chunk-close-failed");
+    });
+    return await operation;
+  }
+  async processSegment(segment, isFinal) {
+    if (!this.uploadActive) {
+      this.rollingBuffer.push(segment, this.now());
+      return;
+    }
+    await this.uploadSegment(segment, isFinal);
+  }
+  async uploadSegment(segment, isFinal) {
+    if (!this.options || !this.config || !this.identity || !this.sessionStore || !this.transport || !this.identityPersisted) {
+      return;
+    }
+    const chunkIndex = await this.sessionStore.takeChunkIndex(
+      this.now()
+    );
+    if (chunkIndex >= MAX_SESSION_REPLAY_CHUNKS_PER_SESSION) {
+      this.diagnostic("session-chunk-cap-race", { chunkIndex });
+      if (this.running) {
+        await this.completeSessionIdentityRotation(this.now(), "chunk-cap");
+        await this.uploadSegment(segment, isFinal);
+      }
+      return;
+    }
+    const includeMeta = chunkIndex === 0 || isFinal || this.metaDirty;
+    const envelope = {
+      v: SESSION_REPLAY_WIRE_VERSION,
+      appIdentifier: this.options.appIdentifier,
+      sessionId: this.identity.sessionId,
+      tabId: this.identity.tabId,
+      chunkIndex,
+      sessionStartUnixMs: this.identity.sessionStartUnixMs,
+      clientSendUnixMs: this.now(),
+      chunkStartOffsetMs: Math.max(
+        0,
+        segment.startUnixMs - this.identity.sessionStartUnixMs
+      ),
+      chunkEndOffsetMs: Math.max(
+        0,
+        segment.endUnixMs - this.identity.sessionStartUnixMs
+      ),
+      eventCount: segment.eventCount,
+      hasFullSnapshot: segment.hasFullSnapshot,
+      isFinal,
+      recorderKind: MOBILE_RECORDER_KIND,
+      schemaVersion: SESSION_REPLAY_SCHEMA_VERSION,
+      rrwebVersion: SYNTHETIC_RRWEB_VERSION,
+      recorderVersion: RECORDER_VERSION,
+      maskingMode: this.config.maskingMode,
+      consentState: this.consentState(),
+      triggerReason: this.triggerReason,
+      payloadEncoding: "gzip",
+      payloadBytes: 0,
+      url: toAppUrl(this.options.mobileAppIdentifier, this.route),
+      routes: segment.routes,
+      signals: segment.signals,
+      fidelityNotices: segment.fidelityNotices,
+      droppedEvents: segment.droppedEvents + this.droppedEvents,
+      flushFailures: this.transport.getFlushFailures()
+    };
+    if (includeMeta) {
+      envelope.meta = this.buildMeta();
+    }
+    if (chunkIndex === 0) {
+      envelope.capabilities = Array.from(
+        SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES
+      );
+    }
+    this.metaDirty = false;
+    this.droppedEvents = 0;
+    await this.transport.enqueue(envelope, segment.payload);
+  }
+  buildMeta() {
+    const size = getViewport();
+    const captureIdentity = this.config?.captureUserIdentity === true;
+    const meta = {
+      entryUrl: this.entryUrl,
+      browserName: this.metadata.appName,
+      browserVersion: this.metadata.appVersion,
+      osName: `${this.metadata.osName} ${this.metadata.osVersion}`.trim(),
+      deviceType: this.metadata.osName.toLowerCase().includes("ios") ? "ios" : "android",
+      viewportWidth: size.width,
+      viewportHeight: size.height
+    };
+    if (this.identity?.visitorId) {
+      meta.visitorId = this.identity.visitorId;
+    }
+    if (captureIdentity && this.userRef) {
+      meta.identifiedUserRef = this.userRef;
+    }
+    if (captureIdentity && Object.keys(this.traits).length > 0) {
+      meta.identifiedUserTraits = { ...this.traits };
+    }
+    if (Object.keys(this.tags).length > 0) {
+      meta.tags = { ...this.tags };
+    }
+    return meta;
+  }
+  consentState() {
+    if (this.config?.consentMode === "NotRequired" /* NotRequired */) {
+      return "NotRequired";
+    }
+    return this.consentGranted ? "Granted" : "Unknown";
+  }
+  installLifecycle() {
+    this.appStateSubscription?.remove();
+    this.appStateSubscription = this.appState.addEventListener(
+      "change",
+      (state) => {
+        const generation = this.lifecycleGeneration;
+        const operation = this.appStateQueue.then(
+          async () => {
+            await this.onAppStateChange(state, generation);
+          }
+        );
+        this.appStateQueue = operation.catch(() => {
+          this.diagnostic("app-state-transition-failed");
+        });
+      }
+    );
+  }
+  async onAppStateChange(state, generation) {
+    if (!this.running || !this.isCurrentGeneration(generation)) {
+      return;
+    }
+    const isActive = state === "active";
+    if (!isActive && this.foreground) {
+      this.foreground = false;
+      this.clearTimers();
+      this.diagnosticsStatus = "background";
+      if (this.rotationPromise) {
+        await this.rotationPromise;
+      }
+      if (this.policyRefreshPromise) {
+        await this.policyRefreshPromise;
+      }
+      if (!this.running || !this.isCurrentGeneration(generation)) {
+        return;
+      }
+      this.appendCustom(VISIBILITY_CUSTOM_EVENT_TAG, { state: "hidden" });
+      await this.closeCurrent(false);
+      if (this.uploadActive) {
+        await this.transport?.drain();
+      }
+      return;
+    }
+    if (isActive && !this.foreground) {
+      this.foreground = true;
+      const policyReady = await this.refreshRuntimePolicy(
+        generation,
+        true,
+        "foreground"
+      );
+      if (!policyReady) {
+        return;
+      }
+      await this.maybeRotateSession(this.now());
+      if (!this.running || !this.isCurrentGeneration(generation)) {
+        return;
+      }
+      this.appendCustom(VISIBILITY_CUSTOM_EVENT_TAG, { state: "visible" });
+      this.forceFullSnapshot = true;
+      this.startTimers();
+      this.diagnosticsStatus = this.consentState() === "Unknown" ? "consent-required" : "recording";
+      await this.captureTick(true);
+    }
+  }
+  startTimers() {
+    this.clearTimers();
+    const intervalMs = Math.max(
+      250,
+      Math.min(
+        5e3,
+        typeof this.options?.captureIntervalMs === "number" && Number.isFinite(this.options.captureIntervalMs) ? this.options.captureIntervalMs : MOBILE_CAPTURE_INTERVAL_MS
+      )
+    );
+    this.captureTimer = setInterval(() => {
+      void this.captureTick();
+    }, intervalMs);
+    this.flushTimer = setInterval(() => {
+      if (this.acceptingEvents) {
+        void this.closeCurrent(false);
+      }
+    }, SESSION_REPLAY_FLUSH_INTERVAL_MS);
+  }
+  clearTimers() {
+    if (this.captureTimer) {
+      clearInterval(this.captureTimer);
+      this.captureTimer = null;
+    }
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  installGlobalErrorHandler() {
+    const globals = globalThis;
+    const errorUtils = globals["ErrorUtils"];
+    const previous = errorUtils?.getGlobalHandler?.();
+    if (!errorUtils?.setGlobalHandler || typeof previous !== "function") {
+      return;
+    }
+    this.globalErrorUtils = errorUtils;
+    this.previousGlobalErrorHandler = previous;
+    const handlerGeneration = this.lifecycleGeneration;
+    const installedHandler = (error, isFatal) => {
+      if (this.installedGlobalErrorHandler === installedHandler && this.lifecycleGeneration === handlerGeneration) {
+        void this.captureError(error);
+      }
+      try {
+        previous?.(error, isFatal);
+      } catch {
+      }
+    };
+    this.installedGlobalErrorHandler = installedHandler;
+    errorUtils.setGlobalHandler(installedHandler);
+  }
+  restoreGlobalErrorHandler() {
+    if (this.globalErrorUtils?.setGlobalHandler && this.globalErrorUtils.getGlobalHandler?.() === this.installedGlobalErrorHandler && this.previousGlobalErrorHandler) {
+      this.globalErrorUtils.setGlobalHandler(this.previousGlobalErrorHandler);
+    }
+    this.globalErrorUtils = null;
+    this.previousGlobalErrorHandler = null;
+    this.installedGlobalErrorHandler = null;
+  }
+  createTransport(startOptions, outbox) {
+    return new ReplayTransport({
+      startOptions,
+      outbox,
+      onDirective: (directive, reason) => {
+        this.onDirective(directive, reason);
+      },
+      onDiagnostic: (code, details) => {
+        this.diagnostic(code, details);
+      }
+    });
+  }
+  onDirective(directive, reason) {
+    this.diagnostic("server-directive", { directive, reason });
+    if (directive === "stop") {
+      this.disable("server-stopped", { reason });
+      this.haltCapture();
+      this.chunkBuffer.clear();
+      this.rollingBuffer.clear();
+      this.serializer.reset();
+      this.touchPrivacyMap = CONSERVATIVE_TOUCH_PRIVACY_MAP;
+      this.resetTouchSequences();
+      this.uploadActive = false;
+      this.transport?.destroy();
+    }
+  }
+  haltCapture() {
+    this.running = false;
+    this.acceptingEvents = false;
+    this.quiesceCapture();
+    this.notifySessionChange();
+  }
+  notifySessionChange() {
+    const sessionId = this.getSessionId();
+    if (sessionId === this.lastNotifiedSessionId) {
+      return;
+    }
+    this.lastNotifiedSessionId = sessionId;
+    for (const listener of this.sessionChangeListeners) {
+      try {
+        listener(sessionId);
+      } catch {
+      }
+    }
+  }
+  quiesceCapture() {
+    this.clearTimers();
+    this.appStateSubscription?.remove();
+    this.appStateSubscription = null;
+    this.restoreGlobalErrorHandler();
+  }
+  isCurrentGeneration(generation) {
+    return generation === this.lifecycleGeneration;
+  }
+  enqueueLifecycleOperation(action) {
+    const operation = this.lifecycleQueue.then(action, action);
+    this.lifecycleQueue = operation.then(
+      () => {
+        return void 0;
+      },
+      () => {
+        this.diagnostic("lifecycle-operation-failed");
+      }
+    );
+    return operation;
+  }
+  async isCurrentTouchPrivate(touch) {
+    if (!this.rootTag || !touch.targetTag || typeof this.nativeViewTree.isTouchTargetPrivate !== "function") {
+      return true;
+    }
+    try {
+      const privateAncestry = await this.nativeViewTree.isTouchTargetPrivate(
+        touch.targetTag,
+        this.rootTag
+      );
+      if (privateAncestry) {
+        return true;
+      }
+      return isTouchPrivate(this.touchPrivacyMap, touch.x, touch.y);
+    } catch {
+      return true;
+    }
+  }
+  updateTouchSuppression(touch, pointIsPrivate) {
+    if (touch.pointerId !== void 0) {
+      const pointerKey = `${typeof touch.pointerId}:${String(
+        touch.pointerId
+      )}`;
+      if (pointIsPrivate) {
+        this.suppressedTouchPointers.add(pointerKey);
+      }
+      const suppressed2 = this.suppressedTouchPointers.has(pointerKey);
+      if (touch.phase === "end") {
+        this.suppressedTouchPointers.delete(pointerKey);
+      }
+      return suppressed2;
+    }
+    if (touch.phase === "start") {
+      this.unidentifiedTouchCount += 1;
+    }
+    if (pointIsPrivate) {
+      this.unidentifiedTouchPrivate = true;
+    }
+    const suppressed = this.unidentifiedTouchPrivate;
+    if (touch.phase === "end") {
+      this.unidentifiedTouchCount = Math.max(
+        0,
+        this.unidentifiedTouchCount - 1
+      );
+      if (this.unidentifiedTouchCount === 0) {
+        this.unidentifiedTouchPrivate = false;
+      }
+    }
+    return suppressed;
+  }
+  resetTouchSequences() {
+    this.suppressedTouchPointers.clear();
+    this.unidentifiedTouchCount = 0;
+    this.unidentifiedTouchPrivate = false;
+  }
+  async applyIdentityChange(ref, traits, identityEpoch) {
+    if (identityEpoch !== this.identityCancellationEpoch) {
+      return;
+    }
+    if (!this.running) {
+      this.applyIdentityValues(ref, traits, true);
+      return;
+    }
+    if (ref === this.userRef) {
+      this.applyIdentityValues(ref, traits, false);
+      return;
+    }
+    const wasAcceptingEvents = this.acceptingEvents;
+    this.acceptingEvents = false;
+    try {
+      if (this.policyRefreshPromise) {
+        await this.policyRefreshPromise;
+      }
+      if (!this.running || identityEpoch !== this.identityCancellationEpoch) {
+        return;
+      }
+      if (this.rotationPromise) {
+        await this.rotationPromise;
+      } else {
+        this.rotatingSession = true;
+        const rotation = this.performSessionRotation(
+          this.now(),
+          "identity"
+        );
+        this.rotationPromise = rotation;
+        try {
+          await rotation;
+        } finally {
+          if (this.rotationPromise === rotation) {
+            this.rotationPromise = null;
+          }
+          this.rotatingSession = false;
+        }
+      }
+      if (identityEpoch !== this.identityCancellationEpoch) {
+        return;
+      }
+      this.acceptingEvents = this.running && wasAcceptingEvents;
+      this.triggered = false;
+      this.triggerReason = "sampled" /* Sampled */;
+      this.uploadActive = this.consentState() !== "Unknown" && this.sampled;
+      this.applyIdentityValues(ref, traits, true);
+      const generation = this.lifecycleGeneration;
+      const policyReady = await this.refreshRuntimePolicy(
+        generation,
+        true,
+        "identity"
+      );
+      if (!policyReady || !this.running || !this.isCurrentGeneration(generation) || identityEpoch !== this.identityCancellationEpoch) {
+        return;
+      }
+      if (this.running && this.foreground) {
+        this.forceFullSnapshot = true;
+        void this.captureTick(true);
+      }
+    } finally {
+      if (this.running && identityEpoch === this.identityCancellationEpoch) {
+        this.acceptingEvents = wasAcceptingEvents;
+      }
+    }
+  }
+  applyIdentityValues(ref, traits, clearTraitsWhenMissing) {
+    const changed = ref !== this.userRef;
+    this.userRef = ref;
+    if (traits) {
+      this.traits = traits;
+    } else if (clearTraitsWhenMissing && changed) {
+      this.traits = {};
+    }
+    if (this.options) {
+      const currentOptions = { ...this.options };
+      if (ref) {
+        currentOptions.userRef = ref;
+      } else {
+        delete currentOptions.userRef;
+      }
+      this.options = currentOptions;
+    }
+    this.metaDirty = true;
+    this.appendCustom(IDENTIFY_CUSTOM_EVENT_TAG, {
+      identified: ref !== null,
+      traitKeys: Object.keys(this.traits)
+    });
+  }
+  async refreshTargetingConfig(baseConfig, forceRefresh = false) {
+    if (!this.options || !forceRefresh && !this.userRef) {
+      return baseConfig;
+    }
+    const currentOptions = { ...this.options };
+    if (this.userRef) {
+      currentOptions.userRef = this.userRef;
+    } else {
+      delete currentOptions.userRef;
+    }
+    const targetedConfig = await fetchReplayConfig(
+      currentOptions,
+      Boolean(this.userRef),
+      forceRefresh
+    );
+    return targetedConfig;
+  }
+  async refreshRuntimePolicy(generation, forceRefresh, reason) {
+    if (!this.running || !this.config || !this.options || !this.isCurrentGeneration(generation)) {
+      return false;
+    }
+    if (this.policyRefreshPromise) {
+      const existingResult = await this.policyRefreshPromise;
+      if (!forceRefresh || !existingResult) {
+        return existingResult;
+      }
+    }
+    const nowUnixMs = this.now();
+    if (!forceRefresh && nowUnixMs - this.lastPolicyRefreshAtUnixMs < MOBILE_POLICY_REFRESH_INTERVAL_MS) {
+      return true;
+    }
+    const operation = this.performRuntimePolicyRefresh(
+      generation,
+      reason,
+      nowUnixMs
+    );
+    this.policyRefreshPromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (this.policyRefreshPromise === operation) {
+        this.policyRefreshPromise = null;
+      }
+    }
+  }
+  async performRuntimePolicyRefresh(generation, reason, nowUnixMs) {
+    if (!this.options || !this.config) {
+      return false;
+    }
+    const previousConfig = this.config;
+    const previousConsentState = this.consentState();
+    const wasAcceptingEvents = this.acceptingEvents;
+    this.acceptingEvents = false;
+    try {
+      let currentOptions = this.currentStartOptions();
+      const maySendUserRef = previousConsentState !== "Unknown" && Boolean(currentOptions.userRef);
+      let freshConfig = await fetchReplayConfig(
+        currentOptions,
+        maySendUserRef,
+        true
+      );
+      if (!this.running || !this.isCurrentGeneration(generation)) {
+        return false;
+      }
+      if (freshConfig.enabled && !maySendUserRef && freshConfig.consentMode === "NotRequired" /* NotRequired */ && this.userRef) {
+        currentOptions = this.currentStartOptions();
+        freshConfig = await fetchReplayConfig(currentOptions, true, true);
+        if (!this.running || !this.isCurrentGeneration(generation)) {
+          return false;
+        }
+      }
+      this.lastPolicyRefreshAtUnixMs = nowUnixMs;
+      if (!freshConfig.enabled) {
+        if (reason !== "consent" && isRetryablePolicyFailure(freshConfig)) {
+          this.diagnostic("policy-refresh-failed-using-last-config", {
+            reason
+          });
+          return true;
+        }
+        this.config = freshConfig;
+        await this.discardForPolicyStop(
+          reason === "consent" ? "config-disabled-after-consent" : "config-disabled-after-refresh",
+          freshConfig.disabledReason ?? "not-reported"
+        );
+        return false;
+      }
+      return await this.applyRuntimePolicy(
+        previousConfig,
+        freshConfig,
+        previousConsentState,
+        wasAcceptingEvents,
+        generation
+      );
+    } catch (error) {
+      if (!this.running || !this.isCurrentGeneration(generation)) {
+        return false;
+      }
+      this.lastPolicyRefreshAtUnixMs = nowUnixMs;
+      if (reason !== "consent") {
+        this.diagnostic("policy-refresh-failed-using-last-config", {
+          reason,
+          name: error instanceof Error ? error.name : "Error"
+        });
+        return true;
+      }
+      await this.discardForPolicyStop(
+        "config-disabled-after-consent",
+        "config-fetch-failed"
+      );
+      return false;
+    } finally {
+      if (this.running && this.isCurrentGeneration(generation)) {
+        this.acceptingEvents = wasAcceptingEvents;
+      }
+    }
+  }
+  async applyRuntimePolicy(_previousConfig, freshConfig, previousConsentState, wasAcceptingEvents, generation) {
+    this.config = freshConfig;
+    this.metaDirty = true;
+    const hasConsent = freshConfig.consentMode === "NotRequired" /* NotRequired */ || this.consentGranted;
+    if (!hasConsent) {
+      const mustWithdrawPersistedState = this.identityPersisted || this.uploadActive || previousConsentState !== "Unknown";
+      if (mustWithdrawPersistedState) {
+        this.transport?.destroy();
+        this.chunkBuffer.clear();
+        this.rollingBuffer.clear();
+        this.serializer.reset();
+        await this.closeQueue.catch(() => {
+          return void 0;
+        });
+        await this.outbox?.clear();
+        await this.sessionStore?.clear();
+        if (!this.running || !this.isCurrentGeneration(generation)) {
+          return false;
+        }
+        const nowUnixMs = this.now();
+        this.identity = this.ephemeralIdentity(nowUnixMs);
+        this.identityPersisted = false;
+        this.notifySessionChange();
+        this.sessionLastActivityUnixMs = nowUnixMs;
+        this.sampled = false;
+        this.uploadActive = false;
+        this.forceFullSnapshot = true;
+        this.touchPrivacyMap = CONSERVATIVE_TOUCH_PRIVACY_MAP;
+        this.resetTouchSequences();
+        this.recreateTransport();
+      }
+      this.triggered = freshConfig.isTargeted;
+      this.triggerReason = freshConfig.isTargeted ? "manual" /* Manual */ : "sampled" /* Sampled */;
+      this.diagnosticsStatus = "consent-required";
+      this.acceptingEvents = wasAcceptingEvents;
+      this.diagnostic("policy-now-requires-consent");
+      return true;
+    }
+    if (!this.identityPersisted && this.sessionStore) {
+      const sessionStore = this.sessionStore;
+      const identity = await sessionStore.resolve(
+        this.now()
+      );
+      if (!this.running || !this.isCurrentGeneration(generation) || this.sessionStore !== sessionStore) {
+        return false;
+      }
+      this.identity = identity;
+      this.identityPersisted = true;
+      this.notifySessionChange();
+      this.sessionLastActivityUnixMs = this.now();
+    }
+    if (!this.identity) {
+      return false;
+    }
+    this.sampled = deterministicSample(
+      this.identity.sessionId,
+      freshConfig.samplePercentage
+    );
+    if (freshConfig.isTargeted) {
+      this.triggered = true;
+      this.triggerReason = "manual" /* Manual */;
+    } else if (!this.triggered) {
+      this.triggerReason = "sampled" /* Sampled */;
+    }
+    if (freshConfig.captureTrigger === "Always" /* Always */ && !this.sampled && !freshConfig.isTargeted) {
+      await this.discardForPolicyStop(
+        "not-sampled-after-config-refresh",
+        "not-sampled"
+      );
+      return false;
+    }
+    const shouldUpload = this.sampled || this.triggered || freshConfig.isTargeted;
+    if (!shouldUpload && this.uploadActive) {
+      this.transport?.destroy();
+      this.chunkBuffer.clear();
+      this.rollingBuffer.clear();
+      await this.closeQueue.catch(() => {
+        return void 0;
+      });
+      await this.outbox?.clear();
+      if (!this.running || !this.isCurrentGeneration(generation)) {
+        return false;
+      }
+      this.uploadActive = false;
+      this.recreateTransport();
+    }
+    this.acceptingEvents = wasAcceptingEvents;
+    if (shouldUpload && !this.uploadActive) {
+      await this.activateUpload(generation);
+    }
+    if (!this.running || !this.isCurrentGeneration(generation)) {
+      return false;
+    }
+    this.diagnosticsStatus = this.foreground ? "recording" : "background";
+    this.diagnostic("policy-refreshed", {
+      configEpoch: freshConfig.configEpoch
+    });
+    return true;
+  }
+  currentStartOptions() {
+    const currentOptions = {
+      ...this.options
+    };
+    if (this.userRef) {
+      currentOptions.userRef = this.userRef;
+    } else {
+      delete currentOptions.userRef;
+    }
+    return currentOptions;
+  }
+  recreateTransport() {
+    if (this.options && this.outbox) {
+      this.transport = this.createTransport(this.options, this.outbox);
+    }
+  }
+  async discardForPolicyStop(code, reason) {
+    this.disable(code, { reason });
+    this.haltCapture();
+    this.transport?.destroy();
+    this.chunkBuffer.clear();
+    this.rollingBuffer.clear();
+    this.serializer.reset();
+    this.touchPrivacyMap = CONSERVATIVE_TOUCH_PRIVACY_MAP;
+    this.resetTouchSequences();
+    this.uploadActive = false;
+    await this.closeQueue.catch(() => {
+      return void 0;
+    });
+    await this.outbox?.clear();
+  }
+  ephemeralIdentity(nowUnixMs) {
+    return {
+      sessionId: generateReplayId(),
+      tabId: generateReplayId(),
+      visitorId: generateReplayId(),
+      sessionStartUnixMs: nowUnixMs,
+      chunkIndex: 0
+    };
+  }
+  rotationReason(nowUnixMs) {
+    if (!this.identity) {
+      return null;
+    }
+    if (nowUnixMs - this.identity.sessionStartUnixMs >= SESSION_REPLAY_MAX_SESSION_MS) {
+      return "duration";
+    }
+    if (nowUnixMs - this.sessionLastActivityUnixMs >= SESSION_REPLAY_IDLE_ROLLOVER_MS) {
+      return "idle";
+    }
+    return null;
+  }
+  runExternalActivity(nowUnixMs, action) {
+    if (this.pendingIdentityOperations > 0) {
+      const identityBarrier = this.identityQueue;
+      const lifecycleEpoch = this.lifecycleCancellationEpoch;
+      const identityEpoch = this.identityCancellationEpoch;
+      const wasRunning = this.running;
+      void identityBarrier.then(() => {
+        if (lifecycleEpoch !== this.lifecycleCancellationEpoch || identityEpoch !== this.identityCancellationEpoch) {
+          return;
+        }
+        if (this.running && this.acceptingEvents || !wasRunning && this.diagnosticsStatus === "idle") {
+          action();
+        }
+      });
+      return;
+    }
+    if (!this.running) {
+      action();
+      return;
+    }
+    const shouldDefer = this.rotatingSession || this.rotationReason(nowUnixMs) !== null;
+    if (!shouldDefer) {
+      action();
+      return;
+    }
+    const generation = this.lifecycleGeneration;
+    void this.maybeRotateSession(nowUnixMs).then(() => {
+      if (this.running && this.isCurrentGeneration(generation)) {
+        action();
+      }
+    });
+  }
+  async maybeRotateSession(nowUnixMs) {
+    if (this.rotationPromise) {
+      await this.rotationPromise;
+      return;
+    }
+    if (!this.running || this.rotatingSession || !this.identity || !this.config || !this.sessionStore || !this.options) {
+      return;
+    }
+    const reason = this.rotationReason(nowUnixMs);
+    if (!reason) {
+      return;
+    }
+    this.rotatingSession = true;
+    const operation = this.performSessionRotation(
+      nowUnixMs,
+      reason
+    );
+    this.rotationPromise = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.rotationPromise === operation) {
+        this.rotationPromise = null;
+      }
+      this.rotatingSession = false;
+    }
+  }
+  async performSessionRotation(nowUnixMs, reason) {
+    this.appendCustom("oneuptime.session-rotated", { reason }, void 0, true);
+    await this.closeCurrent(true);
+    await this.closeQueue;
+    if (!this.running) {
+      return;
+    }
+    if (this.uploadActive) {
+      await this.transport?.drain();
+    } else {
+      this.rollingBuffer.clear();
+    }
+    if (!this.running) {
+      return;
+    }
+    await this.completeSessionIdentityRotation(nowUnixMs, reason);
+  }
+  async completeSessionIdentityRotation(nowUnixMs, reason) {
+    if (!this.sessionStore || !this.config || !this.options) {
+      return;
+    }
+    this.identity = this.identityPersisted ? await this.sessionStore.rotate(nowUnixMs) : this.ephemeralIdentity(nowUnixMs);
+    this.notifySessionChange();
+    this.sampled = this.identityPersisted ? deterministicSample(
+      this.identity.sessionId,
+      this.config.samplePercentage
+    ) : false;
+    this.triggered = this.config.isTargeted;
+    this.triggerReason = this.config.isTargeted ? "manual" /* Manual */ : "sampled" /* Sampled */;
+    this.uploadActive = this.consentState() !== "Unknown" && (this.sampled || this.config.isTargeted);
+    this.serializer.reset();
+    this.chunkBuffer.clear();
+    this.rollingBuffer.clear();
+    this.forceFullSnapshot = true;
+    this.lastFullSnapshotAtUnixMs = 0;
+    this.sessionLastActivityUnixMs = nowUnixMs;
+    this.metaDirty = true;
+    this.entryUrl = toAppUrl(this.options.mobileAppIdentifier, this.route);
+    this.diagnostic("session-rotated", { reason });
+    if (this.config.captureTrigger === "Always" /* Always */ && this.identityPersisted && !this.sampled && !this.config.isTargeted) {
+      this.disable("not-sampled");
+      this.haltCapture();
+    }
+  }
+  disable(code, details) {
+    this.diagnosticsStatus = "disabled";
+    this.diagnostic(code, details);
+  }
+  diagnostic(code, details) {
+    const event = {
+      code,
+      atUnixMs: this.now()
+    };
+    if (details) {
+      event.details = details;
+    }
+    this.diagnosticsEvents.push(event);
+    if (this.diagnosticsEvents.length > MAX_DIAGNOSTIC_EVENTS) {
+      this.diagnosticsEvents.shift();
+    }
+    if (this.options?.debug) {
+      console.info(`[OneUptime Replay] ${code}`, details ?? {});
+    }
+  }
+};
+
+// src/ReplayProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultMobileReplayRecorder = new MobileReplayRecorder();
+var ReplayContext = (0, import_react.createContext)(defaultMobileReplayRecorder);
+function touchPointFromEvent(event) {
+  const nativeEvent = event.nativeEvent;
+  const x2 = typeof nativeEvent.pageX === "number" ? nativeEvent.pageX : typeof nativeEvent.locationX === "number" ? nativeEvent.locationX : 0;
+  const y = typeof nativeEvent.pageY === "number" ? nativeEvent.pageY : typeof nativeEvent.locationY === "number" ? nativeEvent.locationY : 0;
+  return {
+    x: Number.isFinite(x2) ? x2 : 0,
+    y: Number.isFinite(y) ? y : 0
+  };
+}
+function OneUptimeReplayProvider(props) {
+  const recorder = props.recorder ?? defaultMobileReplayRecorder;
+  const rootRef = (0, import_react.useRef)(null);
+  const initialOptions = (0, import_react.useRef)(props.options);
+  (0, import_react.useEffect)(() => {
+    const tag = (0, import_react_native3.findNodeHandle)(rootRef.current);
+    recorder.setRootTag(tag);
+    if (initialOptions.current) {
+      void recorder.start(initialOptions.current);
+    }
+    return () => {
+      recorder.setRootTag(null);
+      if (initialOptions.current && props.stopOnUnmount !== false) {
+        void recorder.stop();
+      }
+    };
+  }, [props.stopOnUnmount, recorder]);
+  const record = (phase, event) => {
+    const point = touchPointFromEvent(event);
+    const targetTag = event.nativeEvent.target;
+    const pointerId = event.nativeEvent["identifier"];
+    const touch = {
+      phase,
+      x: point.x,
+      y: point.y,
+      timestamp: Date.now()
+    };
+    if (typeof targetTag === "number" && Number.isSafeInteger(targetTag)) {
+      touch.targetTag = targetTag;
+    }
+    if (typeof pointerId === "number" && Number.isSafeInteger(pointerId) || typeof pointerId === "string") {
+      touch.pointerId = pointerId;
+    }
+    recorder.recordTouch(touch);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ReplayContext.Provider, { value: recorder, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react_native3.View,
+    {
+      ref: rootRef,
+      collapsable: false,
+      style: [{ flex: 1 }, props.style],
+      onTouchStart: (event) => {
+        record("start", event);
+      },
+      onTouchMove: (event) => {
+        record("move", event);
+      },
+      onTouchEnd: (event) => {
+        record("end", event);
+      },
+      children: props.children
+    }
+  ) });
+}
+function useOneUptimeReplay() {
+  return (0, import_react.useContext)(ReplayContext);
+}
+function ReplayMask(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react_native3.View,
+    {
+      collapsable: false,
+      nativeID: "oneuptime-replay-mask",
+      testID: "oneuptime-replay-mask",
+      style: props.style,
+      children: props.children
+    }
+  );
+}
+var ReplayProvider = OneUptimeReplayProvider;
+
+// src/index.ts
+var OneUptimeReplay = defaultMobileReplayRecorder;
+var index_default = OneUptimeReplay;
+//# sourceMappingURL=index.cjs.map