clintplay-react-native 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1461 @@
+import { View, TextInput, Image, Dimensions, AppState, Platform, TurboModuleRegistry, NativeModules } from 'react-native';
+import React5, { useCallback, useRef, useEffect } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+// src/index.ts
+
+// src/buffer.ts
+var EventBuffer = class {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.events = [];
+  }
+  push(event) {
+    this.events.push(event);
+    const excess = this.events.length - this.maxSize;
+    if (excess > 0) {
+      this.events.splice(0, excess);
+    }
+  }
+  size() {
+    return this.events.length;
+  }
+  drain() {
+    const out = this.events;
+    this.events = [];
+    return out;
+  }
+  peek() {
+    return this.events;
+  }
+};
+
+// src/session.ts
+function uuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+var SessionManager = class {
+  constructor(now = Date.now) {
+    this.now = now;
+    this.state = this.create();
+  }
+  create() {
+    const ts = this.now();
+    return { sessionId: uuid(), startedAt: ts, lastActivity: ts, userId: null };
+  }
+  current() {
+    return this.state;
+  }
+  touch() {
+    this.state.lastActivity = this.now();
+  }
+  setUser(userId) {
+    const prev = this.state.userId;
+    if (prev !== null && (userId === null || prev !== userId)) {
+      const next = this.create();
+      next.userId = userId;
+      this.state = next;
+      return true;
+    }
+    this.state.userId = userId;
+    return false;
+  }
+  isStale() {
+    return this.now() - this.state.lastActivity > IDLE_TIMEOUT_MS;
+  }
+  // Rotates the session id if the gap since last activity exceeds the
+  // idle window. Caller should emit a fresh meta event under the new
+  // id when this returns true.
+  rotateIfStale() {
+    if (this.isStale()) {
+      const prevUser = this.state.userId;
+      this.state = this.create();
+      this.state.userId = prevUser;
+      return true;
+    }
+    return false;
+  }
+  reset() {
+    this.state = this.create();
+  }
+};
+
+// src/transport.ts
+var DEFAULT_BACKOFF = (attempt) => 500 * (attempt + 1);
+var MAX_RETRIES_CAP = 10;
+var MAX_BACKOFF_MS = 3e4;
+var Transport = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  // Returns true on a 2xx. Drops the batch on 4xx (caller-side error,
+  // no point retrying), retries on 5xx up to maxRetries, and returns
+  // false on network errors / timeout after exhausting retries.
+  async sendDetailed(batch) {
+    const maxRetries = Math.min(this.cfg.maxRetries ?? 2, MAX_RETRIES_CAP);
+    const timeoutMs = this.cfg.timeoutMs ?? 8e3;
+    const rawBackoff = this.cfg.backoffMs ?? DEFAULT_BACKOFF;
+    const backoff = (attempt) => Math.min(rawBackoff(attempt), MAX_BACKOFF_MS);
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        let res;
+        try {
+          res = await fetch(this.cfg.apiUrl, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(batch),
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timer);
+        }
+        if (res.ok) return { ok: true, status: res.status };
+        if (res.status >= 400 && res.status < 500) {
+          return { ok: false, status: res.status, retryable: false };
+        }
+      } catch {
+      }
+      if (attempt < maxRetries) {
+        await new Promise((r) => setTimeout(() => r(), backoff(attempt)));
+      }
+    }
+    return { ok: false, retryable: true };
+  }
+  async send(batch) {
+    const res = await this.sendDetailed(batch);
+    return res.ok;
+  }
+  headers() {
+    const h = { "content-type": "application/json" };
+    if (this.cfg.apiKey) {
+      h.authorization = `Bearer ${this.cfg.apiKey}`;
+      h["x-api-key"] = this.cfg.apiKey;
+    }
+    if (this.cfg.projectId) {
+      h["x-project-id"] = this.cfg.projectId;
+    }
+    return h;
+  }
+};
+function mapAppState(state2) {
+  if (state2 === "active") return "active";
+  if (state2 === "background") return "background";
+  return "inactive";
+}
+function orientationFor(width, height) {
+  return width > height ? "landscape" : "portrait";
+}
+function createRecorder(deps) {
+  const cleanups = [];
+  let started = false;
+  let wireframeTimer = null;
+  function takeWireframeSnapshot() {
+    if (!deps.captureViewHierarchy) return;
+    try {
+      const raw = deps.captureViewHierarchy();
+      if (!raw || typeof raw !== "string") return;
+      const payload = JSON.parse(raw);
+      if (payload && Array.isArray(payload.nodes)) {
+        deps.onEvent({
+          type: "wireframe",
+          ts: deps.now(),
+          version: typeof payload.version === "number" ? payload.version : 1,
+          nodes: payload.nodes
+        });
+      }
+    } catch {
+    }
+  }
+  function startWireframeTimer() {
+    if (!deps.captureWireframe || !deps.captureViewHierarchy) return;
+    if (wireframeTimer) return;
+    takeWireframeSnapshot();
+    const rawInterval = deps.wireframeIntervalMs;
+    const intervalMs = typeof rawInterval === "number" && Number.isFinite(rawInterval) && rawInterval > 0 ? Math.max(500, rawInterval) : 1e3;
+    wireframeTimer = setInterval(() => {
+      takeWireframeSnapshot();
+    }, intervalMs);
+  }
+  function stopWireframeTimer() {
+    if (wireframeTimer) {
+      clearInterval(wireframeTimer);
+      wireframeTimer = null;
+    }
+  }
+  return {
+    takeWireframeSnapshot,
+    start() {
+      if (started) return;
+      started = true;
+      const { width, height, scale } = Dimensions.get("window");
+      deps.onEvent({
+        type: "screen",
+        ts: deps.now(),
+        width,
+        height,
+        scale,
+        orientation: orientationFor(width, height)
+      });
+      const appStateSub = AppState.addEventListener("change", (state2) => {
+        const mapped = mapAppState(state2);
+        deps.onEvent({
+          type: "lifecycle",
+          ts: deps.now(),
+          state: mapped
+        });
+        if (deps.captureWireframe && deps.captureViewHierarchy) {
+          if (mapped === "active") {
+            startWireframeTimer();
+          } else {
+            stopWireframeTimer();
+          }
+        }
+      });
+      cleanups.push(() => appStateSub.remove());
+      const dimSub = Dimensions.addEventListener("change", ({ window }) => {
+        deps.onEvent({
+          type: "screen",
+          ts: deps.now(),
+          width: window.width,
+          height: window.height,
+          scale: window.scale,
+          orientation: orientationFor(window.width, window.height)
+        });
+      });
+      cleanups.push(() => dimSub.remove());
+      if (deps.installErrorHandler) {
+        const g = globalThis;
+        const eu = g.ErrorUtils;
+        if (eu) {
+          let handlerActive = true;
+          const original = eu.getGlobalHandler();
+          const ourHandler = (error, isFatal) => {
+            if (handlerActive) {
+              try {
+                deps.onEvent({
+                  type: "error",
+                  ts: deps.now(),
+                  message: error?.message ?? String(error),
+                  stack: error?.stack,
+                  name: error?.name,
+                  fatal: !!isFatal
+                });
+              } catch {
+              }
+            }
+            if (original) original(error, isFatal);
+          };
+          eu.setGlobalHandler(ourHandler);
+          cleanups.push(() => {
+            handlerActive = false;
+            if (eu.getGlobalHandler() === ourHandler) {
+              eu.setGlobalHandler(original);
+            }
+          });
+        }
+      }
+      if (deps.captureWireframe && deps.captureViewHierarchy) {
+        if (AppState.currentState === "active" || !AppState.currentState) {
+          startWireframeTimer();
+        }
+        cleanups.push(() => stopWireframeTimer());
+      }
+    },
+    stop() {
+      if (!started) return;
+      started = false;
+      stopWireframeTimer();
+      for (const fn of cleanups.splice(0)) {
+        try {
+          fn();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/modules/network-interceptor.ts
+var MAX_URL_LENGTH = 2048;
+var stripQuery = (raw) => {
+  if (typeof raw !== "string") return "";
+  if (raw.startsWith("data:")) {
+    const commaIdx = raw.indexOf(",");
+    if (commaIdx !== -1) {
+      return `${raw.slice(0, commaIdx + 1)}[data-url]`;
+    }
+    return "data:[data-url]";
+  }
+  const strippedCredentials = raw.replace(
+    /^((?:[a-zA-Z][a-zA-Z\d+.-]*:)?\/\/)[^/?#]+@/,
+    "$1"
+  );
+  const cutIdx = strippedCredentials.search(/[?#]/);
+  const cleaned = cutIdx === -1 ? strippedCredentials : strippedCredentials.substring(0, cutIdx);
+  return cleaned.length > MAX_URL_LENGTH ? cleaned.slice(0, MAX_URL_LENGTH) + "\u2026" : cleaned;
+};
+var xhrMetadataMap = /* @__PURE__ */ new WeakMap();
+var NetworkInterceptor = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.originalFetch = null;
+    this.wrappedFetch = null;
+    this.originalXHROpen = null;
+    this.wrappedXHROpen = null;
+    this.originalXHRSend = null;
+    this.wrappedXHRSend = null;
+    this.started = false;
+    this.isCallingFetchSync = false;
+    this.ingestOrigin = null;
+    this.ingestPath = null;
+    this.sanitize = deps.sanitizeUrl ?? stripQuery;
+    if (deps.apiUrl) {
+      try {
+        const parsed = typeof URL !== "undefined" ? new URL(deps.apiUrl) : null;
+        if (parsed) {
+          this.ingestOrigin = parsed.origin;
+          const cleanPath = parsed.pathname.replace(/\/+$/, "");
+          this.ingestPath = cleanPath || "/";
+        }
+      } catch {
+        this.ingestOrigin = null;
+        this.ingestPath = null;
+      }
+    }
+  }
+  isSelfIngestUrl(url) {
+    if (!url) return false;
+    try {
+      const parsed = typeof URL !== "undefined" ? new URL(url, "http://localhost") : null;
+      if (parsed) {
+        if (this.ingestOrigin && parsed.origin === this.ingestOrigin) {
+          if (this.ingestPath === "/" || !this.ingestPath) {
+            return true;
+          }
+          const reqPath = parsed.pathname.replace(/\/+$/, "") || "/";
+          if (reqPath === this.ingestPath || reqPath.startsWith(this.ingestPath + "/")) {
+            return true;
+          }
+          return false;
+        }
+        if (/(^|\.)clintplay\./i.test(parsed.hostname || parsed.host || "")) {
+          return true;
+        }
+        return false;
+      }
+    } catch {
+    }
+    return /(^|\.)clintplay\./i.test(url);
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    if (typeof globalThis.fetch === "function") {
+      if (globalThis.fetch !== this.wrappedFetch) {
+        this.originalFetch = globalThis.fetch;
+      }
+      const self = this;
+      const wrapped = async (input, init2) => {
+        if (!self.started || !self.originalFetch) {
+          return (self.originalFetch ?? globalThis.fetch)(input, init2);
+        }
+        const startedAt = self.deps.now();
+        const url = self.extractUrl(input);
+        const method = self.extractMethod(input, init2);
+        const skipTelemetry = !self.started || self.isSelfIngestUrl(url);
+        self.isCallingFetchSync = true;
+        let promise;
+        try {
+          promise = self.originalFetch(input, init2);
+        } finally {
+          self.isCallingFetchSync = false;
+        }
+        try {
+          const res = await promise;
+          if (!skipTelemetry && self.started) {
+            try {
+              self.deps.onEvent({
+                type: "network",
+                ts: startedAt,
+                method,
+                url: self.sanitize(url),
+                status: res.status,
+                durationMs: Math.max(0, self.deps.now() - startedAt)
+              });
+            } catch {
+            }
+          }
+          return res;
+        } catch (err) {
+          if (!skipTelemetry && self.started) {
+            try {
+              self.deps.onEvent({
+                type: "network",
+                ts: startedAt,
+                method,
+                url: self.sanitize(url),
+                durationMs: Math.max(0, self.deps.now() - startedAt),
+                error: err instanceof Error ? err.message : String(err)
+              });
+            } catch {
+            }
+          }
+          throw err;
+        }
+      };
+      this.wrappedFetch = wrapped;
+      globalThis.fetch = this.wrappedFetch;
+    }
+    const g = globalThis;
+    if (g.XMLHttpRequest && g.XMLHttpRequest.prototype) {
+      const xhrProto = g.XMLHttpRequest.prototype;
+      if (xhrProto.open !== this.wrappedXHROpen) {
+        this.originalXHROpen = xhrProto.open;
+      }
+      if (xhrProto.send !== this.wrappedXHRSend) {
+        this.originalXHRSend = xhrProto.send;
+      }
+      const self = this;
+      const wrappedOpen = function(method, url, ...rest) {
+        if (self.started) {
+          try {
+            const urlStr = self.extractUrl(url);
+            const normalizedMethod = typeof method === "string" ? method.toUpperCase() : "GET";
+            const isFromFetch = self.isCallingFetchSync;
+            const meta = {
+              method: normalizedMethod,
+              url: self.sanitize(urlStr),
+              rawUrl: urlStr,
+              startTime: 0,
+              isFromFetch
+            };
+            if (this && typeof this === "object") {
+              xhrMetadataMap.set(this, meta);
+            }
+          } catch {
+          }
+        }
+        if (self.originalXHROpen) {
+          return self.originalXHROpen.apply(this, [method, url, ...rest]);
+        }
+      };
+      const wrappedSend = function(body) {
+        if (self.started && this && typeof this === "object") {
+          try {
+            const meta = xhrMetadataMap.get(this);
+            if (meta && !meta.isFromFetch && !self.isSelfIngestUrl(meta.rawUrl || meta.url)) {
+              meta.startTime = self.deps.now();
+              let emitted = false;
+              const cleanupListeners = () => {
+                if (typeof this.removeEventListener === "function") {
+                  this.removeEventListener("load", handleLoad);
+                  this.removeEventListener("error", handleError);
+                  this.removeEventListener("abort", handleAbort);
+                  this.removeEventListener("timeout", handleTimeout);
+                }
+              };
+              const emitOnce = (event) => {
+                cleanupListeners();
+                if (this && typeof this === "object") {
+                  xhrMetadataMap.delete(this);
+                }
+                if (emitted || !self.started) return;
+                emitted = true;
+                try {
+                  self.deps.onEvent(event);
+                } catch {
+                }
+              };
+              const handleLoad = () => {
+                emitOnce({
+                  type: "network",
+                  ts: meta.startTime,
+                  method: meta.method,
+                  url: meta.url,
+                  status: typeof this.status === "number" ? this.status : 200,
+                  durationMs: Math.max(0, self.deps.now() - meta.startTime)
+                });
+              };
+              const handleError = (e) => {
+                emitOnce({
+                  type: "network",
+                  ts: meta.startTime,
+                  method: meta.method,
+                  url: meta.url,
+                  durationMs: Math.max(0, self.deps.now() - meta.startTime),
+                  error: e && e.message || "Network request failed"
+                });
+              };
+              const handleAbort = () => {
+                emitOnce({
+                  type: "network",
+                  ts: meta.startTime,
+                  method: meta.method,
+                  url: meta.url,
+                  durationMs: Math.max(0, self.deps.now() - meta.startTime),
+                  error: "Request aborted"
+                });
+              };
+              const handleTimeout = () => {
+                emitOnce({
+                  type: "network",
+                  ts: meta.startTime,
+                  method: meta.method,
+                  url: meta.url,
+                  durationMs: Math.max(0, self.deps.now() - meta.startTime),
+                  error: "Request timed out"
+                });
+              };
+              if (typeof this.addEventListener === "function") {
+                this.addEventListener("load", handleLoad);
+                this.addEventListener("error", handleError);
+                this.addEventListener("abort", handleAbort);
+                this.addEventListener("timeout", handleTimeout);
+              }
+            }
+          } catch {
+          }
+        }
+        if (self.originalXHRSend) {
+          return self.originalXHRSend.apply(this, [body]);
+        }
+      };
+      this.wrappedXHROpen = wrappedOpen;
+      this.wrappedXHRSend = wrappedSend;
+      xhrProto.open = wrappedOpen;
+      xhrProto.send = wrappedSend;
+    }
+  }
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.originalFetch && this.wrappedFetch) {
+      if (globalThis.fetch === this.wrappedFetch) {
+        globalThis.fetch = this.originalFetch;
+      }
+    }
+    const g = globalThis;
+    if (g.XMLHttpRequest && g.XMLHttpRequest.prototype) {
+      const xhrProto = g.XMLHttpRequest.prototype;
+      if (this.originalXHROpen && xhrProto.open === this.wrappedXHROpen) {
+        xhrProto.open = this.originalXHROpen;
+      }
+      if (this.originalXHRSend && xhrProto.send === this.wrappedXHRSend) {
+        xhrProto.send = this.originalXHRSend;
+      }
+    }
+  }
+  extractUrl(input) {
+    if (typeof input === "string") return input;
+    if (typeof URL !== "undefined" && input instanceof URL) return input.toString();
+    if (input && typeof input === "object" && "url" in input && typeof input.url === "string") {
+      return input.url;
+    }
+    return String(input ?? "");
+  }
+  extractMethod(input, init2) {
+    const fromInit = init2?.method;
+    if (fromInit) return fromInit.toUpperCase();
+    if (input && typeof input === "object" && "method" in input && typeof input.method === "string") {
+      return input.method.toUpperCase();
+    }
+    return "GET";
+  }
+};
+
+// src/modules/console-interceptor.ts
+var DEFAULT_MAX_LENGTH = 1e3;
+var ConsoleInterceptor = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.originals = /* @__PURE__ */ new Map();
+    this.wrapped = /* @__PURE__ */ new Map();
+    this.started = false;
+    this.isEmitting = false;
+    this.maxLength = deps.maxMessageLength ?? DEFAULT_MAX_LENGTH;
+  }
+  start() {
+    if (this.started) return;
+    if (typeof console === "undefined") return;
+    this.started = true;
+    const methods = this.deps.captureConsoleLog ? ["log", "warn", "error"] : ["warn", "error"];
+    for (const method of methods) {
+      this.wrapMethod(method);
+    }
+  }
+  wrapMethod(method) {
+    const c = console;
+    const original = c[method];
+    if (typeof original !== "function") return;
+    this.originals.set(method, original);
+    const wrappedFn = (...args) => {
+      if (this.started && !this.isEmitting) {
+        this.isEmitting = true;
+        try {
+          this.deps.onEvent({
+            type: "log",
+            ts: this.deps.now(),
+            level: method === "log" ? "info" : method,
+            message: this.formatMessage(args)
+          });
+        } catch {
+        } finally {
+          this.isEmitting = false;
+        }
+      }
+      original.apply(console, args);
+    };
+    this.wrapped.set(method, wrappedFn);
+    c[method] = wrappedFn;
+  }
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.isEmitting = false;
+    const c = console;
+    for (const [method, original] of this.originals) {
+      if (c[method] === this.wrapped.get(method)) {
+        c[method] = original;
+      }
+    }
+    this.originals.clear();
+    this.wrapped.clear();
+  }
+  formatMessage(args) {
+    const text = args.map((a) => {
+      if (a === void 0) return "undefined";
+      if (typeof a === "string") return a;
+      if (typeof a === "number") return String(a);
+      if (typeof a === "boolean") return String(a);
+      if (typeof a === "symbol") return a.toString();
+      if (typeof a === "function") {
+        return a.name ? `[Function: ${a.name}]` : "[Function]";
+      }
+      if (a instanceof Error) return a.stack || `${a.name}: ${a.message}`;
+      try {
+        const json = JSON.stringify(a);
+        return json !== void 0 ? json : String(a);
+      } catch {
+        return String(a);
+      }
+    }).join(" ");
+    return text.length > this.maxLength ? text.slice(0, this.maxLength) + "\u2026" : text;
+  }
+};
+
+// src/modules/offline-queue.ts
+var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_PREFIX = "clintplay:batch:";
+var OfflineQueue = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.currentBytes = 0;
+    // Monotonic sequence number appended to the storage key. Two batches
+    // enqueued in the same millisecond would otherwise tie on the
+    // timestamp prefix and sort non-deterministically. The padded seq
+    // resolves ties while preserving lex order = enqueue order.
+    this.seq = 0;
+    this.hydrationPromise = null;
+    this.prefix = deps.keyPrefix ?? DEFAULT_PREFIX;
+    this.maxBytes = deps.maxBytes ?? DEFAULT_MAX_BYTES;
+  }
+  // Compute the on-disk footprint from existing keys. Cheap on first
+  // boot, marginal on subsequent boots — called once from `init()`.
+  // Per-key getItem errors are isolated so a single flaky entry can't
+  // wedge accounting for the entire queue. `getAllKeys` failure is
+  // the only hard stop (no keys → no work).
+  hydrate(force = false) {
+    if (force) {
+      this.hydrationPromise = null;
+    }
+    if (!this.hydrationPromise) {
+      this.hydrationPromise = (async () => {
+        let keys;
+        try {
+          keys = (await this.deps.storage.getAllKeys()).filter(
+            (k) => k.startsWith(this.prefix)
+          );
+        } catch (err) {
+          this.deps.debug?.(
+            `offline-queue hydrate getAllKeys failed: ${String(err)}`
+          );
+          this.hydrationPromise = null;
+          return;
+        }
+        let total = 0;
+        for (const k of keys) {
+          try {
+            const raw = await this.deps.storage.getItem(k);
+            if (raw) total += raw.length;
+          } catch (err) {
+            this.deps.debug?.(
+              `offline-queue hydrate getItem ${k} failed: ${String(err)}`
+            );
+          }
+        }
+        this.currentBytes = total;
+      })().catch((err) => {
+        this.hydrationPromise = null;
+        throw err;
+      });
+    }
+    return this.hydrationPromise;
+  }
+  // Persist a single batch. Caller invokes after a live send fails.
+  // Silently drops batches that exceed the per-batch ceiling — those
+  // are unrecoverable even with retries, and keeping them around would
+  // wedge the queue.
+  async persist(batch) {
+    if (this.hydrationPromise) {
+      await this.hydrationPromise;
+    }
+    const json = JSON.stringify(batch);
+    const bytes = json.length;
+    if (bytes > this.maxBytes) {
+      this.deps.debug?.(
+        `offline-queue batch too large (${bytes} > ${this.maxBytes})`
+      );
+      return;
+    }
+    await this.evictUntilFits(bytes);
+    const ts = Date.now().toString().padStart(13, "0");
+    const seqStr = (this.seq++).toString().padStart(6, "0");
+    const key = `${this.prefix}${ts}-${seqStr}`;
+    try {
+      await this.deps.storage.setItem(key, json);
+      this.currentBytes += bytes;
+    } catch (err) {
+      this.deps.debug?.(`offline-queue setItem failed: ${String(err)}`);
+    }
+  }
+  // Replay all persisted batches in enqueue order. Stops at the first
+  // failed send — a network outage that caused the queue to fill up is
+  // typically still ongoing on the next boot; pushing more batches at
+  // a dead endpoint just burns retries and drops events on the floor.
+  async drain() {
+    if (this.hydrationPromise) {
+      await this.hydrationPromise;
+    }
+    let sent = 0;
+    try {
+      const keys = (await this.deps.storage.getAllKeys()).filter((k) => k.startsWith(this.prefix)).sort();
+      for (const key of keys) {
+        const raw = await this.deps.storage.getItem(key);
+        if (!raw) {
+          await this.deps.storage.removeItem(key);
+          continue;
+        }
+        try {
+          const batch = JSON.parse(raw);
+          const result = await this.deps.send(batch);
+          const ok = typeof result === "boolean" ? result : !!result?.ok;
+          const isNonRetryable = typeof result === "object" && result !== null && (typeof result.status === "number" && result.status >= 400 && result.status < 500 || result.retryable === false);
+          if (!ok) {
+            if (isNonRetryable) {
+              this.deps.debug?.(
+                `offline-queue drop 4xx non-retryable batch for key: ${key}`
+              );
+              await this.deps.storage.removeItem(key);
+              this.currentBytes = Math.max(0, this.currentBytes - raw.length);
+              continue;
+            }
+            break;
+          }
+          await this.deps.storage.removeItem(key);
+          this.currentBytes = Math.max(0, this.currentBytes - raw.length);
+          sent++;
+        } catch (err) {
+          this.deps.debug?.(`offline-queue drop bad batch: ${String(err)}`);
+          await this.deps.storage.removeItem(key);
+          this.currentBytes = Math.max(0, this.currentBytes - raw.length);
+        }
+      }
+    } catch (err) {
+      this.deps.debug?.(`offline-queue drain failed: ${String(err)}`);
+    }
+    return sent;
+  }
+  async clear() {
+    try {
+      const keys = (await this.deps.storage.getAllKeys()).filter(
+        (k) => k.startsWith(this.prefix)
+      );
+      if (keys.length > 0) {
+        await this.deps.storage.multiRemove(keys);
+      }
+      this.currentBytes = 0;
+      this.hydrationPromise = null;
+    } catch (err) {
+      this.deps.debug?.(`offline-queue clear failed: ${String(err)}`);
+    }
+  }
+  async evictUntilFits(bytesNeeded) {
+    if (this.currentBytes + bytesNeeded <= this.maxBytes) return;
+    const toFree = this.currentBytes + bytesNeeded - this.maxBytes;
+    let keys;
+    try {
+      keys = (await this.deps.storage.getAllKeys()).filter((k) => k.startsWith(this.prefix)).sort();
+    } catch (err) {
+      this.deps.debug?.(`evict getAllKeys failed: ${String(err)}`);
+      return;
+    }
+    let freed = 0;
+    const toRemove = [];
+    for (const key of keys) {
+      if (freed >= toFree) break;
+      let raw;
+      try {
+        raw = await this.deps.storage.getItem(key);
+      } catch (err) {
+        this.deps.debug?.(`evict getItem ${key} failed: ${String(err)}`);
+        continue;
+      }
+      if (raw != null) freed += raw.length;
+      toRemove.push(key);
+    }
+    if (toRemove.length === 0) return;
+    try {
+      await this.deps.storage.multiRemove(toRemove);
+      this.currentBytes = Math.max(0, this.currentBytes - freed);
+    } catch (err) {
+      this.deps.debug?.(`evict multiRemove failed: ${String(err)}`);
+      await this.hydrate(true);
+    }
+  }
+};
+
+// src/runtime-bridge.ts
+var sink = null;
+function _setSink(next) {
+  sink = next;
+}
+function emit(event) {
+  if (sink) {
+    try {
+      sink(event);
+    } catch {
+    }
+  }
+}
+var cachedModule = null;
+function resolveNativeModule() {
+  if (cachedModule) return cachedModule;
+  try {
+    const turbo = TurboModuleRegistry.get("ClintplayRN");
+    if (turbo) {
+      cachedModule = turbo;
+      return cachedModule;
+    }
+  } catch {
+  }
+  try {
+    const paper = NativeModules.ClintplayRN ?? null;
+    if (paper) {
+      cachedModule = paper;
+      return cachedModule;
+    }
+  } catch {
+  }
+  return null;
+}
+function captureViewHierarchy() {
+  const n = resolveNativeModule();
+  if (!n) return null;
+  try {
+    return n.captureViewHierarchy();
+  } catch {
+    return null;
+  }
+}
+
+// package.json
+var version = "0.1.0";
+var CLINTPLAY_MASK_ID = "clintplay-mask";
+var ClintplayMaskView = React5.forwardRef(function ClintplayMaskView2({ children, testID, ...rest }, ref) {
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      ref,
+      testID: testID ?? CLINTPLAY_MASK_ID,
+      ...rest,
+      collapsable: false,
+      nativeID: CLINTPLAY_MASK_ID,
+      children
+    }
+  );
+});
+var ClintplayMaskTextInput = React5.forwardRef(function ClintplayMaskTextInput2({ testID, accessibilityLabel, ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      ref,
+      testID: testID ?? CLINTPLAY_MASK_ID,
+      accessibilityLabel,
+      ...props,
+      nativeID: CLINTPLAY_MASK_ID
+    }
+  );
+});
+var ClintplayMaskImage = React5.forwardRef(function ClintplayMaskImage2({ testID, accessibilityLabel, ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    Image,
+    {
+      ref,
+      testID: testID ?? CLINTPLAY_MASK_ID,
+      accessibilityLabel,
+      ...props,
+      nativeID: CLINTPLAY_MASK_ID
+    }
+  );
+});
+function ClintplayCaptureProvider({
+  children,
+  style,
+  enabled = true,
+  onTouchStart,
+  onTouchEnd,
+  onTouchCancel,
+  ...rest
+}) {
+  const onStart = useCallback(
+    (e) => {
+      const nativeEvent = e?.nativeEvent;
+      if (!nativeEvent) return;
+      const { locationX = 0, locationY = 0, pageX, pageY } = nativeEvent;
+      emit({
+        type: "touch",
+        ts: Date.now(),
+        x: locationX,
+        y: locationY,
+        screenX: pageX,
+        screenY: pageY,
+        kind: "start"
+      });
+      onTouchStart?.(e);
+    },
+    [onTouchStart]
+  );
+  const onEnd = useCallback(
+    (e) => {
+      const nativeEvent = e?.nativeEvent;
+      if (!nativeEvent) return;
+      const { locationX = 0, locationY = 0, pageX, pageY } = nativeEvent;
+      emit({
+        type: "touch",
+        ts: Date.now(),
+        x: locationX,
+        y: locationY,
+        screenX: pageX,
+        screenY: pageY,
+        kind: "end"
+      });
+      onTouchEnd?.(e);
+    },
+    [onTouchEnd]
+  );
+  const onCancel = useCallback(
+    (e) => {
+      const nativeEvent = e?.nativeEvent;
+      if (!nativeEvent) return;
+      const { locationX = 0, locationY = 0, pageX, pageY } = nativeEvent;
+      emit({
+        type: "touch",
+        ts: Date.now(),
+        x: locationX,
+        y: locationY,
+        screenX: pageX,
+        screenY: pageY,
+        kind: "end"
+      });
+      onTouchCancel?.(e);
+    },
+    [onTouchCancel]
+  );
+  if (!enabled) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      ...rest,
+      style: [{ flex: 1 }, style],
+      onTouchStart: onStart,
+      onTouchEnd: onEnd,
+      onTouchCancel: onCancel,
+      children
+    }
+  );
+}
+var sharedLastTrackedRoute = void 0;
+function _resetLastTrackedRoute() {
+  sharedLastTrackedRoute = void 0;
+}
+function useClintplayNavigationTracking(routeNameOrPath, options) {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const trackScreen2 = useCallback((to, from) => {
+    const cleanTo = sanitizeRoute(to);
+    if (!cleanTo || cleanTo === sharedLastTrackedRoute) return;
+    const cleanFrom = sanitizeRoute(from);
+    const initialFrom = sanitizeRoute(optionsRef.current?.from);
+    const previousRoute = cleanFrom ?? sharedLastTrackedRoute ?? (initialFrom && initialFrom !== cleanTo ? initialFrom : void 0);
+    sharedLastTrackedRoute = cleanTo;
+    emit({
+      type: "navigation",
+      ts: Date.now(),
+      to: cleanTo,
+      ...previousRoute ? { from: previousRoute } : {}
+    });
+    try {
+      optionsRef.current?.onRouteChanged?.(cleanTo, previousRoute);
+    } catch {
+    }
+  }, []);
+  useEffect(() => {
+    const clean = sanitizeRoute(routeNameOrPath);
+    if (clean && clean !== sharedLastTrackedRoute) {
+      trackScreen2(clean);
+    }
+  }, [routeNameOrPath, trackScreen2]);
+  const handleStateChange = useCallback(
+    (state2) => {
+      const nextRoute = getActiveRouteName(state2);
+      if (nextRoute) {
+        trackScreen2(nextRoute);
+      }
+    },
+    [trackScreen2]
+  );
+  const result = Object.assign(handleStateChange, {
+    onStateChange: handleStateChange,
+    trackScreen: trackScreen2
+  });
+  return result;
+}
+function sanitizeRoute(route) {
+  if (!route || typeof route !== "string") return void 0;
+  const clean = route.split(/[?#]/)[0];
+  return clean || void 0;
+}
+function getActiveRouteName(state2, depth = 0) {
+  if (depth > 20) return void 0;
+  if (!state2 || typeof state2 !== "object") {
+    return void 0;
+  }
+  const s = state2;
+  if (!Array.isArray(s.routes) || s.routes.length === 0) {
+    if (typeof s.name === "string") {
+      return s.name;
+    }
+    return void 0;
+  }
+  const index = typeof s.index === "number" && s.index >= 0 && s.index < s.routes.length ? s.index : s.routes.length - 1;
+  const currentRoute = s.routes[index];
+  if (!currentRoute) return void 0;
+  if (currentRoute.state) {
+    if (depth >= 20) return void 0;
+    const childRoute = getActiveRouteName(currentRoute.state, depth + 1);
+    if (childRoute !== void 0) {
+      return childRoute;
+    }
+    const childState = currentRoute.state;
+    if (childState && typeof childState === "object" && (!Array.isArray(childState.routes) || childState.routes.length === 0)) {
+      return currentRoute.name;
+    }
+    return void 0;
+  }
+  return currentRoute.name;
+}
+function createClintplayNavigationStateListener(options) {
+  const opts = typeof options === "function" ? { onRouteChanged: options } : options ?? {};
+  let currentRoute = void 0;
+  const initialRoute = sanitizeRoute(opts.initialRouteName);
+  let isFirst = true;
+  return function onStateChange(state2) {
+    const rawRoute = getActiveRouteName(state2);
+    const nextRoute = sanitizeRoute(rawRoute);
+    if (!nextRoute) return;
+    if (isFirst) {
+      isFirst = false;
+      const from = initialRoute && initialRoute !== nextRoute ? initialRoute : void 0;
+      currentRoute = nextRoute;
+      emit({
+        type: "navigation",
+        ts: Date.now(),
+        to: nextRoute,
+        ...from ? { from } : {}
+      });
+      try {
+        opts.onRouteChanged?.(nextRoute, from);
+      } catch {
+      }
+      return;
+    }
+    if (nextRoute === currentRoute) return;
+    const previousRoute = currentRoute;
+    currentRoute = nextRoute;
+    emit({
+      type: "navigation",
+      ts: Date.now(),
+      to: nextRoute,
+      ...previousRoute ? { from: previousRoute } : {}
+    });
+    try {
+      opts.onRouteChanged?.(nextRoute, previousRoute);
+    } catch {
+    }
+  };
+}
+function ClintplayNavigationTracker({
+  children,
+  pathname,
+  onStateChange,
+  initialRouteName,
+  onRouteChanged
+}) {
+  const tracking = useClintplayNavigationTracking(pathname, {
+    from: initialRouteName,
+    onRouteChanged
+  });
+  const handleStateChange = useCallback(
+    (state2) => {
+      tracking.onStateChange(state2);
+      try {
+        onStateChange?.(state2);
+      } catch {
+      }
+    },
+    [tracking, onStateChange]
+  );
+  const childOnStateChangeRef = useRef(void 0);
+  const mergedOnStateChange = useCallback(
+    (state2) => {
+      handleStateChange(state2);
+      try {
+        childOnStateChangeRef.current?.(state2);
+      } catch {
+      }
+    },
+    [handleStateChange]
+  );
+  if (typeof children === "function") {
+    return /* @__PURE__ */ jsx(Fragment, { children: children({ onStateChange: handleStateChange }) });
+  }
+  if (React5.isValidElement(children)) {
+    childOnStateChangeRef.current = children.props?.onStateChange;
+    return React5.cloneElement(children, {
+      onStateChange: mergedOnStateChange
+    });
+  }
+  if (Array.isArray(children) || children && React5.Children.count(children) > 1) {
+    let targetIndex = -1;
+    let firstValidIndex = -1;
+    let scanIndex = 0;
+    React5.Children.forEach(children, (child) => {
+      if (React5.isValidElement(child)) {
+        if (firstValidIndex === -1) {
+          firstValidIndex = scanIndex;
+        }
+        if (typeof child.props?.onStateChange === "function" && targetIndex === -1) {
+          targetIndex = scanIndex;
+        }
+      }
+      scanIndex++;
+    });
+    const chosenIndex = targetIndex !== -1 ? targetIndex : firstValidIndex;
+    let mapIndex = 0;
+    const clonedChildren = React5.Children.map(children, (child) => {
+      const currentIdx = mapIndex++;
+      if (!React5.isValidElement(child)) return child;
+      if (currentIdx === chosenIndex) {
+        childOnStateChangeRef.current = child.props?.onStateChange;
+        return React5.cloneElement(child, {
+          onStateChange: mergedOnStateChange
+        });
+      }
+      return child;
+    });
+    return /* @__PURE__ */ jsx(Fragment, { children: clonedChildren });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: children ?? null });
+}
+
+// src/index.ts
+var SDK_VERSION = version;
+var state = null;
+function deviceInfo() {
+  const os = Platform.OS;
+  const platform = os === "ios" ? "ios" : os === "android" ? "android" : "web";
+  return { platform, osVersion: String(Platform.Version ?? "") };
+}
+function debugLog(cfg, ...args) {
+  if (!cfg.debug) return;
+  if (typeof console !== "undefined" && console.log) {
+    console.log("[clintplay-rn]", ...args);
+  }
+}
+function formatEventForBatch(event, defaultSessionId) {
+  const ev = event;
+  const timestamp = typeof ev.timestamp === "number" ? ev.timestamp : typeof ev.ts === "number" ? ev.ts : Date.now();
+  const sessionId = ev.sessionId || defaultSessionId;
+  const type = ev.type;
+  if (ev.data !== void 0) {
+    return {
+      type,
+      timestamp,
+      sessionId,
+      data: ev.data
+    };
+  }
+  const { type: _t, ts: _ts, timestamp: _tms, sessionId: _s, ...rest } = ev;
+  return {
+    type,
+    timestamp,
+    sessionId,
+    data: rest
+  };
+}
+async function flushOnce(s) {
+  try {
+    if (s.buffer.size() === 0) return;
+    const currentSessionId = s.session.current().sessionId;
+    const rawEvents = s.buffer.drain();
+    const events = rawEvents.map(
+      (e) => formatEventForBatch(e, currentSessionId)
+    );
+    const batch = {
+      projectId: s.config.projectId,
+      sessionId: currentSessionId,
+      sdkVersion: SDK_VERSION,
+      events,
+      sentAt: Date.now(),
+      ...s.config.anonId ? { anonId: s.config.anonId } : {}
+    };
+    const ok = await s.transport.send(batch);
+    if (!ok && s.offlineQueue) {
+      await s.offlineQueue.persist(batch);
+    }
+    debugLog(s.config, ok ? "flushed" : "flush failed", events.length);
+  } catch (err) {
+    debugLog(s.config, "flush failed with error", String(err));
+  }
+}
+function init(rawConfig) {
+  if (state?.active) return;
+  if (!rawConfig.apiUrl) return;
+  if (rawConfig.enabled === false) return;
+  const sampleRate = rawConfig.sampleRate ?? 1;
+  if (sampleRate < 1 && Math.random() > sampleRate) return;
+  const config = {
+    apiUrl: rawConfig.apiUrl,
+    apiKey: rawConfig.apiKey,
+    projectId: rawConfig.projectId ?? rawConfig.apiKey ?? "",
+    anonId: rawConfig.anonId,
+    flushIntervalMs: rawConfig.flushIntervalMs ?? 5e3,
+    flushSize: rawConfig.flushSize ?? 50,
+    maxBufferSize: rawConfig.maxBufferSize ?? 1e3,
+    debug: rawConfig.debug ?? false,
+    captureWireframe: rawConfig.captureWireframe ?? false
+  };
+  const buffer = new EventBuffer(config.maxBufferSize);
+  const session = new SessionManager();
+  const transport = new Transport({
+    apiUrl: config.apiUrl,
+    apiKey: config.apiKey,
+    projectId: config.projectId
+  });
+  const excluded = new Set(rawConfig.excludeEventTypes ?? []);
+  const local = {
+    config,
+    buffer,
+    session,
+    transport,
+    recorder: { start: () => {
+    }, stop: () => {
+    }, takeWireframeSnapshot: () => {
+    } },
+    networkInterceptor: null,
+    consoleInterceptor: null,
+    offlineQueue: rawConfig.asyncStorage ? new OfflineQueue({
+      storage: rawConfig.asyncStorage,
+      send: (b) => transport.sendDetailed(b),
+      debug: (msg) => debugLog(config, msg)
+    }) : null,
+    flushTimer: null,
+    excluded,
+    active: true
+  };
+  state = local;
+  const onEvent = (event) => {
+    if (excluded.has(event.type)) return;
+    buffer.push(event);
+    session.touch();
+    if (buffer.size() >= config.flushSize) {
+      void flushOnce(local);
+    }
+  };
+  const recorder = createRecorder({
+    onEvent,
+    now: Date.now,
+    installErrorHandler: true,
+    captureWireframe: rawConfig.captureWireframe,
+    wireframeIntervalMs: rawConfig.wireframeIntervalMs,
+    captureViewHierarchy
+  });
+  local.recorder = recorder;
+  if (rawConfig.captureNetwork !== false) {
+    local.networkInterceptor = new NetworkInterceptor({
+      onEvent,
+      now: Date.now,
+      sanitizeUrl: rawConfig.sanitizeUrl,
+      apiUrl: config.apiUrl
+    });
+  }
+  if (rawConfig.captureConsole === true) {
+    local.consoleInterceptor = new ConsoleInterceptor({
+      onEvent,
+      now: Date.now,
+      captureConsoleLog: rawConfig.captureConsoleLog
+    });
+  }
+  buffer.push({
+    type: "meta",
+    ts: Date.now(),
+    sessionId: session.current().sessionId,
+    sdkVersion: SDK_VERSION,
+    device: deviceInfo()
+  });
+  recorder.start();
+  local.networkInterceptor?.start();
+  local.consoleInterceptor?.start();
+  _setSink(onEvent);
+  if (local.offlineQueue) {
+    const q = local.offlineQueue;
+    void q.hydrate().then(() => q.drain()).catch(
+      (err) => debugLog(config, "offline queue init failed", String(err))
+    );
+  }
+  local.flushTimer = setInterval(async () => {
+    if (local.session.isStale()) {
+      await flushOnce(local);
+      if (local.session.rotateIfStale()) {
+        local.buffer.push({
+          type: "meta",
+          ts: Date.now(),
+          sessionId: local.session.current().sessionId,
+          sdkVersion: SDK_VERSION,
+          device: deviceInfo()
+        });
+      }
+    }
+    void flushOnce(local);
+  }, config.flushIntervalMs);
+  debugLog(config, "init", { sessionId: session.current().sessionId });
+}
+function identify(userId, traits) {
+  if (!state?.active) return;
+  const prevUser = state.session.current().userId;
+  const isUserChange = prevUser !== null && (userId === null || prevUser !== userId);
+  if (isUserChange) {
+    void flushOnce(state);
+  }
+  const rotated = state.session.setUser(userId);
+  if (rotated) {
+    state.buffer.push({
+      type: "meta",
+      ts: Date.now(),
+      sessionId: state.session.current().sessionId,
+      sdkVersion: SDK_VERSION,
+      device: deviceInfo()
+    });
+  }
+  state.buffer.push({
+    type: "identify",
+    ts: Date.now(),
+    userId,
+    traits
+  });
+}
+function reset(options) {
+  if (!state?.active) return;
+  void flushOnce(state);
+  state.session.reset();
+  if (options?.clearOfflineQueue && state.offlineQueue) {
+    void state.offlineQueue.clear();
+  }
+  state.buffer.push({
+    type: "meta",
+    ts: Date.now(),
+    sessionId: state.session.current().sessionId,
+    sdkVersion: SDK_VERSION,
+    device: deviceInfo()
+  });
+}
+function trackScreen(path, from) {
+  if (!state?.active) return;
+  state.buffer.push({
+    type: "navigation",
+    ts: Date.now(),
+    to: path,
+    ...from ? { from } : {}
+  });
+  state.session.touch();
+  if (state.config.captureWireframe) {
+    state.recorder.takeWireframeSnapshot();
+  }
+}
+function reportError(err) {
+  if (!state?.active) return;
+  const error = err instanceof Error ? err : new Error(String(err));
+  state.buffer.push({
+    type: "error",
+    ts: Date.now(),
+    message: error.message,
+    stack: error.stack,
+    name: error.name,
+    fatal: false
+  });
+}
+async function flush() {
+  if (!state?.active) return;
+  await flushOnce(state);
+}
+async function stop() {
+  if (!state?.active) return;
+  const s = state;
+  s.active = false;
+  state = null;
+  _setSink(null);
+  if (s.flushTimer) clearInterval(s.flushTimer);
+  s.consoleInterceptor?.stop();
+  s.networkInterceptor?.stop();
+  s.recorder.stop();
+  await flushOnce(s);
+}
+function current() {
+  if (!state?.active) return null;
+  const s = state.session.current();
+  return { sessionId: s.sessionId, userId: s.userId };
+}
+var Clintplay = {
+  init,
+  identify,
+  reset,
+  trackScreen,
+  reportError,
+  flush,
+  stop,
+  current
+};
+
+export { CLINTPLAY_MASK_ID, Clintplay, ClintplayCaptureProvider, ClintplayMaskImage, ClintplayMaskTextInput, ClintplayMaskView, ClintplayNavigationTracker, SDK_VERSION, _resetLastTrackedRoute, createClintplayNavigationStateListener, formatEventForBatch, getActiveRouteName, sanitizeRoute, useClintplayNavigationTracking };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map