@lucida-analytics/react-native 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -37,6 +37,8 @@ interface AsyncStorageLike {
     multiGet(keys: readonly string[]): Promise<ReadonlyArray<readonly [string, string | null]>>;
     setItem(key: string, value: string): Promise<void>;
     removeItem(key: string): Promise<void>;
+    /** The real module has it; used to find spilled replay chunks (`lc_replay.<id>`) to hydrate. Without it they are not reloaded after a restart. */
+    getAllKeys?(): Promise<readonly string[]>;
 }
 /** Keys the SDK persists; hydrated up front because the core's Storage port is synchronous. */
 declare const PERSISTED_KEYS: readonly ["lc_identity", "lc_session", "lc_props", "lc_groups", "lc_consent", "lc_flags", "lc_offline", "lc_app_version", "lc_guide_seen", "lc_person_identified"];
@@ -72,8 +74,8 @@ interface QueueCipher {
     /** null when the value cannot be decrypted (key rotated, corrupt): the queue then starts empty. */
     decrypt(cipher: string): string | null;
 }
-/** Decorator: values under `keys` are stored encrypted, everything else passes through. */
-declare function encryptedStorage(inner: Storage, cipher: QueueCipher, keys: readonly string[]): Storage;
+/** Decorator: values under `keys` (or a key starting with one of `prefixes`) are stored encrypted, everything else passes through. */
+declare function encryptedStorage(inner: Storage, cipher: QueueCipher, keys: readonly string[], prefixes?: readonly string[]): Storage;
 
 interface RageTapConfig {
     enabled?: boolean;
@@ -315,6 +317,17 @@ interface ReplayConfig {
     throttleMs?: number;
     /** Hold chunks until the session has been recorded this long; a session that ends sooner (or `stop()`) is never sent. Default 0 (off). */
     minDurationMs?: number;
+    /**
+     * Disk budget for chunks that wait (min duration, offline, upload backoff); over it the oldest whole session is dropped
+     * and `onSpoolDrop` fires. Default 10 MiB. Needs `asyncStorage` to survive a restart.
+     */
+    spoolBudgetBytes?: number;
+    /** A whole session was dropped because the spool exceeded its budget (also logged in debug mode). */
+    onSpoolDrop?: (info: {
+        sessionId: string;
+        chunks: number;
+        bytes: number;
+    }) => void;
     /** Fetch `GET /v1/config` and honour the project kill switch, sample rate and minimum duration (tightening only). Default true. */
     useRemoteConfig?: boolean;
     /** Start recording only while this flag is on. */
@@ -352,6 +365,8 @@ interface ReplayService {
     setScreen(name: string): void;
     /** A tap at screen point (x, y); ignored without consent, before the first snapshot, while paused or on a gated screen. */
     tap(x: number, y: number): void;
+    /** Erase every spilled chunk (opt-out, reset). */
+    clearSpool(): void;
     /** One capture pass (the interval calls this); exposed for tests. */
     tick(): Promise<void>;
     /** P-M46: a swipe passed the touch slop; its start structure is captured now. */
@@ -363,11 +378,14 @@ interface ReplayService {
 }
 interface ReplayDeps {
     core: Core;
+    /** Where waiting chunks are spilled (the client's storage, encrypted with the queue cipher when one is set). */
+    storage: Storage;
     fetch: typeof fetch;
     apiHost: string;
     apiKey: string;
     config: ReplayConfig;
     now?: () => number;
+    log?: (...a: unknown[]) => void;
     /** Reads `config.linkedFlag`. */
     isFlagOn?: (key: string) => boolean;
 }
@@ -577,7 +595,7 @@ interface NativeConfig {
 }
 
 declare const LIB = "lucida-react-native";
-declare const LIB_VERSION = "0.0.0";
+declare const LIB_VERSION = "0.1.1";
 /**
  * Hydrates storage, then builds the client. Nothing is persisted before consent in opt_in mode;
  * `$app_opened` fires on creation and on every foreground, `$app_backgrounded` flushes the queue.
@@ -640,6 +658,42 @@ declare function withBaggage(existing: string | null | undefined, sessionId: str
 /** A fetch that adds the tracing headers when the target host matches; everything else passes through untouched. */
 declare function tracedFetch(fetchImpl: typeof fetch, headersFor: (url: string, baggage?: string | null) => Record<string, string>): typeof fetch;
 
+interface SpoolEntry {
+    id: number;
+    sid: string;
+    seq: number;
+    /** Waiting for the minimum session duration (dropped if the session ends first); false = waiting for upload. */
+    held: boolean;
+    /** Body size in bytes. */
+    n: number;
+    /** Number of parts the body is split into (`lc_replay.<id>.<i>`). */
+    p: number;
+    /** Body length in UTF-16 units: a torn or truncated body no longer adds up and is discarded. */
+    len: number;
+}
+/**
+ * Durable, ordered spill for replay chunks that cannot be sent yet (min duration, offline, upload backoff).
+ * `lc_replay` is the index (JSON list of entries), `lc_replay.<id>.<i>` holds part i of one chunk body (no api key), split
+ * into parts under 1 MB. Write order: `lc_replay.pending` names the entry in flight, then its parts, then the index, then
+ * pending is cleared; a crash in between leaves parts the index never lists, which load deletes. Pass a storage
+ * wrapped with `encryptedStorage(..., [SPOOL_KEY], [`${SPOOL_KEY}.`])` to encrypt at rest. Over `budget` bytes the oldest
+ * whole session is dropped (never single chunks, so a kept session has no hole) and `onDrop` reports it.
+ */
+declare function createReplaySpool(storage: Storage, budget?: number, onDrop?: (sid: string, chunks: number, bytes: number) => void): {
+    entries: () => readonly SpoolEntry[];
+    totalBytes: () => number;
+    add(sid: string, seq: number, held: boolean, body: string): void;
+    /** The whole body, or null when a part is missing or the length does not add up (torn write): the caller discards it. */
+    read(e: SpoolEntry): string | null;
+    remove(e: SpoolEntry): void;
+    /** Held chunks of every session except `keep`; returned so the caller can give their seq numbers back. */
+    removeHeld(keep?: string): SpoolEntry[];
+    /** The session reached its minimum duration: its held chunks become plain pending uploads. */
+    release(sid: string): void;
+    nextSeq: (sid: string) => number;
+    clear(): void;
+};
+
 /**
  * P-M17 masked screens and P-M46 text patterns. The native encoders apply both (they receive `maskScreen` and
  * `maskTextPatterns` with every capture, screenshots included); [maskSnapshotText] re-applies the patterns to the
@@ -781,4 +835,4 @@ interface FeatureGateProps {
 }
 declare function FeatureGate({ flag, variant, fallback, children }: FeatureGateProps): react.JSX.Element;
 
-export { type AppStateLike, type AppStateStatus, type AsyncStorageLike, type Autocapture, type AutocaptureConfig, type Bootstrap, type CaptureOptions, DEAD_SWIPE_MIN_DISTANCE, type DeadSwipeInput, type ExposureKey, FeatureGate, type FeatureGateProps, type FiberLike, type FlagOptions, type Flags, GuideAnchor, type GuideAnchorSpec, type GuideButton, type GuideStep, type GuideTokens, type GuideView, type GuidesDeps, type GuidesService, type InstallInfo, LIB, LIB_VERSION, LucidaGuides, LucidaMask, LucidaProvider, type LucidaProviderProps, LucidaTouchCapture, LucidaUnmask, type Measurable, type MobileGuide, type NativeCipherModule, type NativeClient, type NativeConfig, type NativeInstallModule, type NativeReplayModule, type NativeSensitiveModule, type NavigationRefLike, PERSISTED_KEYS, PersonMode, type QueueCipher, REPLAY_MARKERS, type RageTapConfig, type ReplayConfig, type ReplayControl, type ReplayService, SENSITIVE_MAX_PLAIN_BYTES, type SensitiveCapture, type SwipeDirection, type TapElement, type TouchEventLike, appLifecycle, appStoreInstallProps, asyncStorageAdapter, bubbleOrigin, chainFromFiber, compilePatterns, createAutocapture, createClient, createGuides, createReplay, createSensitiveCapture, deadSwipeDecision, effectiveMinDurationMs, effectiveSampleRate, encryptSensitive, encryptedStorage, exposureKeyOf, fetchTransport, guideAnchor, guideButtons, guideTokens, installReferrerProps, maskPatterns, maskSnapshotText, matches as matchGuideScreen, measureAnchor, memoryStorage, nativeQueueCipher, registerAnchor, replayMarker, resolveInstallProps, runHooks, sampleHook, screenAllowed, screenExcluded, screenMasked, screenTracker, splitBatches, swipeDirection, touchHandler, tracedFetch, tracingHeaders, truncateUtf8, useActiveFeatureFlags, useCapture, useFeatureFlag, useFeatureFlagPayload, useFeatureFlagVariant, useLucida, useReplay, useScreen, withBaggage, withTimeout };
+export { type AppStateLike, type AppStateStatus, type AsyncStorageLike, type Autocapture, type AutocaptureConfig, type Bootstrap, type CaptureOptions, DEAD_SWIPE_MIN_DISTANCE, type DeadSwipeInput, type ExposureKey, FeatureGate, type FeatureGateProps, type FiberLike, type FlagOptions, type Flags, GuideAnchor, type GuideAnchorSpec, type GuideButton, type GuideStep, type GuideTokens, type GuideView, type GuidesDeps, type GuidesService, type InstallInfo, LIB, LIB_VERSION, LucidaGuides, LucidaMask, LucidaProvider, type LucidaProviderProps, LucidaTouchCapture, LucidaUnmask, type Measurable, type MobileGuide, type NativeCipherModule, type NativeClient, type NativeConfig, type NativeInstallModule, type NativeReplayModule, type NativeSensitiveModule, type NavigationRefLike, PERSISTED_KEYS, PersonMode, type QueueCipher, REPLAY_MARKERS, type RageTapConfig, type ReplayConfig, type ReplayControl, type ReplayService, SENSITIVE_MAX_PLAIN_BYTES, type SensitiveCapture, type SpoolEntry, type SwipeDirection, type TapElement, type TouchEventLike, appLifecycle, appStoreInstallProps, asyncStorageAdapter, bubbleOrigin, chainFromFiber, compilePatterns, createAutocapture, createClient, createGuides, createReplay, createReplaySpool, createSensitiveCapture, deadSwipeDecision, effectiveMinDurationMs, effectiveSampleRate, encryptSensitive, encryptedStorage, exposureKeyOf, fetchTransport, guideAnchor, guideButtons, guideTokens, installReferrerProps, maskPatterns, maskSnapshotText, matches as matchGuideScreen, measureAnchor, memoryStorage, nativeQueueCipher, registerAnchor, replayMarker, resolveInstallProps, runHooks, sampleHook, screenAllowed, screenExcluded, screenMasked, screenTracker, splitBatches, swipeDirection, touchHandler, tracedFetch, tracingHeaders, truncateUtf8, useActiveFeatureFlags, useCapture, useFeatureFlag, useFeatureFlagPayload, useFeatureFlagVariant, useLucida, useReplay, useScreen, withBaggage, withTimeout };

package/dist/index.js

@@ -16,13 +16,13 @@ var PERSISTED_KEYS = [
 ];
 function asyncStorageAdapter(as) {
   const mem = /* @__PURE__ */ new Map();
-  const ready = as.multiGet(PERSISTED_KEYS).then(
-    (rows) => {
-      for (const [k, v] of rows) if (v !== null) mem.set(k, v);
-    },
-    () => void 0
-    // unreadable storage: start empty rather than fail init
-  );
+  const load = async (keys) => {
+    for (const [k, v] of await as.multiGet(keys)) if (v !== null) mem.set(k, v);
+  };
+  const ready = load(PERSISTED_KEYS).then(async () => {
+    const all = await as.getAllKeys?.() ?? [];
+    await load(all.filter((k) => k === "lc_replay" || k.startsWith("lc_replay.")));
+  }).catch(() => void 0);
   const swallow = (p) => void p.catch(() => void 0);
   return {
     ready,
@@ -104,14 +104,15 @@ function withTimeout(inner, ms) {
     })
   };
 }
-function encryptedStorage(inner, cipher, keys) {
+function encryptedStorage(inner, cipher, keys, prefixes = []) {
   const enc = new Set(keys);
+  const covers = (k) => enc.has(k) || prefixes.some((p) => k.startsWith(p));
   return {
     get: (k) => {
       const v = inner.get(k);
-      return v !== null && enc.has(k) ? cipher.decrypt(v) : v;
+      return v !== null && covers(k) ? cipher.decrypt(v) : v;
     },
-    set: (k, v) => inner.set(k, enc.has(k) ? cipher.encrypt(v) : v),
+    set: (k, v) => inner.set(k, covers(k) ? cipher.encrypt(v) : v),
     remove: (k) => inner.remove(k)
   };
 }
@@ -235,6 +236,7 @@ function appStoreInstallProps(json) {
   }
   return out;
 }
+var retryableStatus = (s) => s === 404 || s === 408 || s === 429 || s >= 500;
 async function resolveInstallProps(native, d) {
   let fallback = {};
   try {
@@ -252,7 +254,8 @@ async function resolveInstallProps(native, d) {
       try {
         const r = await d.fetch(ASA_URL, { method: "POST", headers: { "Content-Type": "text/plain" }, body: info.token, signal: ctl?.signal ?? null });
         if (r.ok) return appStoreInstallProps(await r.json());
-        if (r.status !== 404) break;
+        if (!retryableStatus(r.status)) break;
+      } catch {
       } finally {
         if (timer) clearTimeout(timer);
       }
@@ -823,6 +826,114 @@ function maskSnapshotText(node, patterns) {
   return out;
 }
 
+// src/replay-spool.ts
+var SPOOL_KEY = "lc_replay";
+var DEFAULT_SPOOL_BUDGET_BYTES = 10 * 1024 * 1024;
+var SPOOL_PART_CHARS = 3e5;
+var PENDING_KEY = "lc_replay.pending";
+var byteLength = (s) => {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    n += c < 128 ? 1 : c < 2048 ? 2 : c >= 55296 && c < 56320 ? (i++, 4) : 3;
+  }
+  return n;
+};
+function createReplaySpool(storage, budget = DEFAULT_SPOOL_BUDGET_BYTES, onDrop) {
+  let items = [];
+  let nextId = 0;
+  const partKey = (id, i) => `${SPOOL_KEY}.${id}.${i}`;
+  const removeParts = (id, count) => {
+    for (let i = 0; i < count; i++) storage.remove(partKey(id, i));
+  };
+  const complete = (e) => {
+    for (let i = 0; i < e.p; i++) if (storage.get(partKey(e.id, i)) === null) return false;
+    return true;
+  };
+  let listed = [];
+  try {
+    const raw = storage.get(SPOOL_KEY);
+    const parsed = raw === null ? [] : JSON.parse(raw);
+    if (Array.isArray(parsed)) listed = parsed;
+  } catch {
+    listed = [];
+  }
+  items = listed.filter((e) => typeof e.p === "number" && complete(e));
+  for (const e of listed) if (!items.includes(e)) removeParts(e.id, typeof e.p === "number" ? e.p : 0);
+  const pending = storage.get(PENDING_KEY);
+  if (pending !== null) {
+    const [pid, pcount] = pending.split(":").map(Number);
+    if (pid !== void 0 && pcount !== void 0 && !items.some((e) => e.id === pid)) removeParts(pid, pcount);
+    storage.remove(PENDING_KEY);
+  }
+  nextId = Math.max(listed.reduce((m, e) => Math.max(m, e.id + 1), 0), items.reduce((m, e) => Math.max(m, e.id + 1), 0));
+  if (items.length !== listed.length) storage.set(SPOOL_KEY, JSON.stringify(items));
+  const save = () => items.length === 0 ? storage.remove(SPOOL_KEY) : storage.set(SPOOL_KEY, JSON.stringify(items));
+  const drop = (gone) => {
+    for (const e of gone) removeParts(e.id, e.p);
+    items = items.filter((e) => !gone.includes(e));
+  };
+  return {
+    entries: () => items,
+    totalBytes: () => items.reduce((a, e) => a + e.n, 0),
+    add(sid, seq, held, body) {
+      const parts = [];
+      for (let at = 0; at < body.length || parts.length === 0; ) {
+        let end = Math.min(body.length, at + SPOOL_PART_CHARS);
+        const last = body.charCodeAt(end - 1);
+        if (end < body.length && last >= 55296 && last < 56320) end -= 1;
+        parts.push(body.slice(at, end));
+        at = end;
+      }
+      const e = { id: nextId++, sid, seq, held, n: byteLength(body), p: parts.length, len: body.length };
+      storage.set(PENDING_KEY, `${e.id}:${e.p}`);
+      parts.forEach((part, i) => storage.set(partKey(e.id, i), part));
+      items.push(e);
+      const dropped = [];
+      while (items.length > 0 && items.reduce((a, x) => a + x.n, 0) > budget) {
+        const first = items[0];
+        const gone = items.filter((x) => x.sid === first.sid);
+        drop(gone);
+        dropped.push([first.sid, gone.length, gone.reduce((a, x) => a + x.n, 0)]);
+      }
+      save();
+      storage.remove(PENDING_KEY);
+      for (const [s, c, b] of dropped) onDrop?.(s, c, b);
+    },
+    /** The whole body, or null when a part is missing or the length does not add up (torn write): the caller discards it. */
+    read(e) {
+      let out = "";
+      for (let i = 0; i < e.p; i++) {
+        const part = storage.get(partKey(e.id, i));
+        if (part === null) return null;
+        out += part;
+      }
+      return out.length === e.len ? out : null;
+    },
+    remove(e) {
+      drop([e]);
+      save();
+    },
+    /** Held chunks of every session except `keep`; returned so the caller can give their seq numbers back. */
+    removeHeld(keep) {
+      const gone = items.filter((e) => e.held && e.sid !== keep);
+      drop(gone);
+      save();
+      return gone;
+    },
+    /** The session reached its minimum duration: its held chunks become plain pending uploads. */
+    release(sid) {
+      items = items.map((e) => e.held && e.sid === sid ? { ...e, held: false } : e);
+      save();
+    },
+    nextSeq: (sid) => items.filter((e) => e.sid === sid).reduce((m, e) => Math.max(m, e.seq), -1) + 1,
+    clear() {
+      drop([...items]);
+      save();
+    }
+  };
+}
+
 // src/sensitive.ts
 import { sha256Hex } from "@lucida-analytics/sdk-core";
 var SENSITIVE_MAX_PLAIN_BYTES = 190;
@@ -913,8 +1024,10 @@ function createReplay(d) {
   let remote = null;
   let remoteLoaded = false;
   let sessionStart = 0;
-  let held = [];
-  const maxHeld = 20;
+  const spool = createReplaySpool(d.storage, config.spoolBudgetBytes, (sessionId, chunks, bytes) => {
+    d.log?.(`replay spool over budget: dropped session ${sessionId} (${chunks} chunks, ${bytes} bytes)`);
+    config.onSpoolDrop?.({ sessionId, chunks, bytes });
+  });
   let touches = [];
   let tapTarget = 0;
   let tapTree;
@@ -991,15 +1104,38 @@ function createReplay(d) {
     core.capture("$sensitive_capture", p);
     return true;
   }
-  async function send(events, sessionId, windowId) {
-    const body = JSON.stringify({ api_key: d.apiKey, session_id: sessionId, window_id: windowId, seq, events });
+  function store(events, sessionId, windowId, held) {
+    const body = JSON.stringify({ session_id: sessionId, window_id: windowId, seq, events });
     if (body.length > (config.maxEventBytes ?? 5e6)) return;
-    try {
-      const r = await d.fetch(`${d.apiHost}/v1/replay`, { method: "POST", headers: { "Content-Type": "application/json" }, body });
-      if (r.ok) seq += 1;
-      else lastFp = null;
-    } catch {
-      lastFp = null;
+    spool.add(sessionId, seq, held, body);
+    seq += 1;
+  }
+  async function drain() {
+    for (const e of [...spool.entries()]) {
+      if (e.held) continue;
+      const stored = spool.read(e);
+      if (stored === null) {
+        spool.remove(e);
+        continue;
+      }
+      let status = 0;
+      try {
+        const r = await d.fetch(`${d.apiHost}/v1/replay`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ api_key: d.apiKey, ...JSON.parse(stored) })
+        });
+        status = r.ok ? 200 : r.status;
+      } catch {
+      }
+      if (status === 200) spool.remove(e);
+      else if (status === 0 || status === 408 || status === 429 || status >= 500) {
+        lastFp = null;
+        return;
+      } else {
+        spool.remove(e);
+        d.log?.(`replay chunk rejected with ${status}; dropped`);
+      }
     }
   }
   async function tick() {
@@ -1007,7 +1143,7 @@ function createReplay(d) {
       lastFp = null;
       hasSnapshot = false;
       touches = [];
-      held = [];
+      spool.clear();
       return;
     }
     await loadRemote();
@@ -1046,10 +1182,10 @@ function createReplay(d) {
     const { sessionId, windowId } = core.session.touch();
     const rotated = sessionId !== lastSession;
     if (rotated) {
-      seq = 0;
       lastSession = sessionId;
       sessionStart = now();
-      held = [];
+      spool.removeHeld(sessionId);
+      seq = spool.nextSeq(sessionId);
     }
     const fp = fingerprint(events);
     const ts = now();
@@ -1066,16 +1202,12 @@ function createReplay(d) {
       tapTree = events.find((e) => e.type === 2)?.data.node;
       hasSnapshot = true;
     }
-    if (out.length === 0) return;
     const minMs = effectiveMinDurationMs(config.minDurationMs ?? 0, remote);
-    if (minMs > 0 && now() - sessionStart < minMs) {
-      held.push(out);
-      if (held.length > maxHeld) held.shift();
-      return;
-    }
-    const backlog = held;
-    held = [];
-    for (const chunk of [...backlog, out]) await send(chunk, sessionId, windowId);
+    const holding = minMs > 0 && now() - sessionStart < minMs;
+    if (out.length > 0) store(out, sessionId, windowId, holding);
+    if (holding) return;
+    spool.release(sessionId);
+    await drain();
   }
   return {
     start() {
@@ -1086,7 +1218,8 @@ function createReplay(d) {
       if (timer === void 0) return;
       (config.clearInterval ?? ((h) => clearInterval(h)))(timer);
       timer = void 0;
-      held = [];
+      const back = spool.removeHeld().filter((e) => e.sid === lastSession).map((e) => e.seq);
+      if (back.length > 0) seq = Math.min(...back);
     },
     pause() {
       paused = true;
@@ -1106,6 +1239,7 @@ function createReplay(d) {
         data: { source: 2, type: 2, id: hitTest(tapTree, x, y, tapTarget), x, y }
       });
     },
+    clearSpool: () => spool.clear(),
     tick,
     swipeBegan() {
       if (config.captureDeadSwipes === false || !touchesRecording()) return;
@@ -1119,8 +1253,8 @@ function createReplay(d) {
 
 // src/client.ts
 var LIB = "lucida-react-native";
-var LIB_VERSION = "0.0.0";
-var DEFAULT_HOST = "https://app.lucida.dev";
+var LIB_VERSION = "0.1.1";
+var DEFAULT_HOST = "https://capture.lucidace.com";
 var VERSION_KEY = "lc_app_version";
 var noop = { send: async () => ({ status: 200 }) };
 async function createClient(apiKey, config = {}) {
@@ -1137,7 +1271,7 @@ async function createClient(apiKey, config = {}) {
     await a.ready;
     storage = a.storage;
   }
-  if (config.queueCipher) storage = encryptedStorage(storage, config.queueCipher, ["lc_offline"]);
+  if (config.queueCipher) storage = encryptedStorage(storage, config.queueCipher, ["lc_offline", "lc_replay"], ["lc_replay."]);
   let transport = config.transport ?? fetchTransport(fetchImpl, config.requestTimeoutMs);
   if (config.maxBatchSize) transport = splitBatches(transport, config.maxBatchSize);
   if (config.transport && config.requestTimeoutMs) transport = withTimeout(transport, config.requestTimeoutMs);
@@ -1237,7 +1371,7 @@ async function createClient(apiKey, config = {}) {
       if (c === "identify" || c === "reset" || c === "group") load();
     });
   }
-  const replay = config.replay?.enabled && !config.disabled ? createReplay({ core, fetch: fetchImpl, apiHost, apiKey, config: config.replay, isFlagOn: (k) => {
+  const replay = config.replay?.enabled && !config.disabled ? createReplay({ core, storage, log, fetch: fetchImpl, apiHost, apiKey, config: config.replay, isFlagOn: (k) => {
     const v = flags.all()[k];
     return v !== void 0 && v !== false;
   } }) : void 0;
@@ -1280,6 +1414,7 @@ async function createClient(apiKey, config = {}) {
     },
     reset() {
       person.reset();
+      replay?.clearSpool();
       core.reset({ reuseAnonymousId: !!config.reuseAnonymousId });
     },
     register: (p) => core.register(p),
@@ -1287,7 +1422,10 @@ async function createClient(apiKey, config = {}) {
     unregister: (k) => core.unregister(k),
     group: (t, k, p) => core.group(t, k, p),
     optIn: () => core.optIn(),
-    optOut: () => core.optOut(),
+    optOut: () => {
+      replay?.clearSpool();
+      core.optOut();
+    },
     getFlag: (k) => flags.get(k),
     getFlagPayload: (k) => flags.payload(k),
     getFlagResult: (k, o) => flags.result(k, o),
@@ -1719,6 +1857,7 @@ export {
   createClient,
   createGuides,
   createReplay,
+  createReplaySpool,
   createSensitiveCapture,
   deadSwipeDecision,
   effectiveMinDurationMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucida-analytics/react-native",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "react": ">=18"
   },
   "dependencies": {
-    "@lucida-analytics/sdk-core": "0.1.0"
+    "@lucida-analytics/sdk-core": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",