@guidelytech/react-native 0.12.0 → 0.14.0

package/dist/index.js

@@ -4,7 +4,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 
 // src/index.tsx
 import { useContext as useContext3, useEffect as useEffect9, useMemo as useMemo6, useRef as useRef7, useState as useState8 } from "react";
-import { AppState as AppState2, Dimensions, Linking, Platform as Platform6, StyleSheet as StyleSheet10, View as View12 } from "react-native";
+import { AppState as AppState2, Dimensions, Linking, NativeModules, Platform as Platform6, StyleSheet as StyleSheet10, View as View12 } from "react-native";
 import { createStaticFlags as createStaticFlags2, stableStringify as stableStringify3 } from "@guidelytech/flags";
 
 // src/flags.tsx
@@ -1378,14 +1378,14 @@ function quoteValue(value) {
 function attrSelector(name, value) {
   return `[${name}=${quoteValue(value)}]`.slice(0, 300);
 }
-function cleanText(text) {
-  const t = (text ?? "").replace(/\s+/g, " ").trim();
+function cleanText(text2) {
+  const t = (text2 ?? "").replace(/\s+/g, " ").trim();
   return t ? t.slice(0, 100) : void 0;
 }
 function tapProperties(el, x, y, platform, maskAll) {
   const props = { selector: el.selector.slice(0, 300), tag: el.tag || "View", x: Math.round(x) || 0, y: Math.round(y) || 0, platform };
-  const text = maskAll ? void 0 : cleanText(el.text);
-  if (text) props.text = text;
+  const text2 = maskAll ? void 0 : cleanText(el.text);
+  if (text2) props.text = text2;
   return props;
 }
 var r2 = (n) => Math.round(Math.min(1, Math.max(0, n)) * 100) / 100;
@@ -2006,10 +2006,10 @@ function xhrStreamPost() {
       const type = xhr.getResponseHeader("content-type") || "";
       if (!type.includes("text/event-stream")) return;
       streamed = true;
-      const text = xhr.responseText || "";
-      if (text.length > seen) {
-        onChunk(text.slice(seen));
-        seen = text.length;
+      const text2 = xhr.responseText || "";
+      if (text2.length > seen) {
+        onChunk(text2.slice(seen));
+        seen = text2.length;
       }
     };
     xhr.open("POST", url);
@@ -2084,14 +2084,14 @@ function fetchStreamPost(fetchImpl) {
         if (rest) onChunk(rest);
         return { status: res.status, json: null, streamed: true };
       }
-      const text = await race(res.text());
+      const text2 = await race(res.text());
       if (sse) {
-        onChunk(text);
+        onChunk(text2);
         return { status: res.status, json: null, streamed: true };
       }
       let json = null;
       try {
-        json = JSON.parse(text || "null");
+        json = JSON.parse(text2 || "null");
       } catch {
         json = null;
       }
@@ -2204,10 +2204,10 @@ var Messenger = class {
     if (v.kind === "tab" && v.tab === "messages") void this.refreshConversations();
   }
   /** Opens a new thread (optionally pre-filling the composer). */
-  showNewMessage(text = "") {
+  showNewMessage(text2 = "") {
     this.stopThreadPolling();
     if (!this.snapshot.open) this.deps.onOpen();
-    this.set({ open: true, view: { kind: "thread", conversationId: null }, thread: { conversation: null, messages: [], streaming: {}, sending: false, error: null, draft: text } });
+    this.set({ open: true, view: { kind: "thread", conversationId: null }, thread: { conversation: null, messages: [], streaming: {}, sending: false, error: null, draft: text2 } });
   }
   async openConversation(id) {
     const known = this.snapshot.conversations.find((c) => c.id === id) ?? null;
@@ -2251,8 +2251,8 @@ var Messenger = class {
     }
   }
   /** Sends the composer text: starts a conversation or posts to the open one. Streams Scout's reply. */
-  async send(text) {
-    const body = text.trim().slice(0, 4e3);
+  async send(text2) {
+    const body = text2.trim().slice(0, 4e3);
     const thread = this.snapshot.thread;
     if (!body || !thread || thread.sending) return;
     this.setThread({ sending: true, error: null, draft: "" });
@@ -2428,6 +2428,425 @@ var Messenger = class {
   }
 };
 
+// src/core/replay.ts
+var RrwebEvents = {
+  IMG_ID: 8,
+  TOUCH_START: 7,
+  TOUCH_END: 9,
+  CLICK: 2,
+  CSS: "html,body{margin:0;padding:0;width:100%;height:100%;overflow:hidden;background:#000}img{display:block;width:100%;height:100%;object-fit:contain}",
+  dataUrl(base64) {
+    return `data:image/jpeg;base64,${base64}`;
+  },
+  meta(timestamp, href, width, height) {
+    return JSON.stringify({ type: 4, data: { href, width, height }, timestamp });
+  },
+  fullSnapshot(timestamp, dataUrl, width, height) {
+    const style = { type: 2, id: 5, tagName: "style", attributes: {}, childNodes: [{ type: 3, id: 6, textContent: RrwebEvents.CSS, isStyle: true }] };
+    const img = { type: 2, id: 8, tagName: "img", attributes: { src: dataUrl, width, height, alt: "" }, childNodes: [] };
+    const html = { type: 2, id: 3, tagName: "html", attributes: {}, childNodes: [{ type: 2, id: 4, tagName: "head", attributes: {}, childNodes: [style] }, { type: 2, id: 7, tagName: "body", attributes: {}, childNodes: [img] }] };
+    const node = { type: 0, id: 1, childNodes: [{ type: 1, id: 2, name: "html", publicId: "", systemId: "" }, html] };
+    return JSON.stringify({ type: 2, data: { node, initialOffset: { left: 0, top: 0 } }, timestamp });
+  },
+  frame(timestamp, dataUrl) {
+    return JSON.stringify({ type: 3, data: { source: 0, texts: [], attributes: [{ id: 8, attributes: { src: dataUrl } }], removes: [], adds: [] }, timestamp });
+  },
+  /** MouseInteraction (source 2): 7 TouchStart, 9 TouchEnd, 2 Click. */
+  interaction(timestamp, type, x, y) {
+    return JSON.stringify({ type: 3, data: { source: 2, type, id: 8, x: round1(x), y: round1(y) }, timestamp });
+  },
+  touchMove(timestamp, x, y) {
+    return JSON.stringify({ type: 3, data: { source: 6, positions: [{ x: round1(x), y: round1(y), id: 8, timeOffset: 0 }] }, timestamp });
+  },
+  custom(timestamp, tag, payload) {
+    return JSON.stringify({ type: 5, data: { tag, payload }, timestamp });
+  }
+};
+var round1 = (v) => Math.round(v * 10) / 10;
+var UPLOAD_TIMEOUT_MS = 3e4;
+var ReplayUploader = class {
+  constructor(opts) {
+    __publicField(this, "opts", opts);
+    __publicField(this, "windowId", randomId(16));
+    __publicField(this, "buffer", null);
+    __publicField(this, "queue", []);
+    __publicField(this, "queuedBytes", 0);
+    __publicField(this, "seqs", /* @__PURE__ */ new Map());
+    __publicField(this, "inflight", null);
+    __publicField(this, "flushTimer", null);
+    __publicField(this, "retryTimer", null);
+    __publicField(this, "attempt", 0);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "offRecover");
+    this.offRecover = opts.health?.onRecover?.(() => {
+      this.clearRetry();
+      this.attempt = 0;
+      this.flush();
+    }) ?? null;
+  }
+  get pendingChunks() {
+    return this.queue.length;
+  }
+  get bufferedEvents() {
+    return this.buffer?.events.length ?? 0;
+  }
+  push(sessionId, json) {
+    if (this.destroyed) return;
+    if (this.buffer && this.buffer.sessionId !== sessionId) this.seal();
+    const chunk = this.buffer ?? (this.buffer = { sessionId, meta: this.opts.meta(), events: [], bytes: 0 });
+    chunk.events.push(json);
+    chunk.bytes += json.length;
+    if (chunk.bytes > (this.opts.maxBufferBytes ?? 1e6)) this.flush();
+    else if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flush();
+      }, this.opts.flushIntervalMs ?? 1e4);
+    }
+  }
+  /** Seals the buffer and uploads the backlog (one chunk at a time). */
+  flush() {
+    if (this.destroyed) return;
+    this.seal();
+    if (this.retryTimer || this.inflight || !this.queue.length) return;
+    void this.sendNext();
+  }
+  /** Drops everything buffered or queued (consent withdrawn, server disabled replay). */
+  discard() {
+    this.buffer = null;
+    this.queue = [];
+    this.queuedBytes = 0;
+    this.clearFlushTimer();
+    this.clearRetry();
+    this.attempt = 0;
+  }
+  /** Uploads what is left once; no retries afterwards. */
+  destroy() {
+    this.flush();
+    this.destroyed = true;
+    this.offRecover?.();
+    this.clearFlushTimer();
+    this.clearRetry();
+  }
+  clearFlushTimer() {
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.flushTimer = null;
+  }
+  clearRetry() {
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  scheduleRetry(ms) {
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.flush();
+    }, ms);
+  }
+  seal() {
+    this.clearFlushTimer();
+    const chunk = this.buffer;
+    this.buffer = null;
+    if (!chunk || !chunk.events.length) return;
+    this.queue.push(chunk);
+    this.queuedBytes += chunk.bytes;
+    const max = this.opts.maxQueuedBytes ?? 5e6;
+    while (this.queuedBytes > max && this.queue.length > 1) {
+      const i = this.inflight && this.queue[0] === this.inflight ? 1 : 0;
+      const [dropped] = this.queue.splice(i, 1);
+      if (!dropped) break;
+      this.queuedBytes -= dropped.bytes;
+      this.opts.log?.(`replay backlog full: dropped a chunk of ${dropped.events.length} events`);
+    }
+  }
+  nextSeq(chunk) {
+    if (chunk.seq === void 0) {
+      const seq = this.seqs.get(chunk.sessionId) ?? 0;
+      this.seqs.set(chunk.sessionId, seq + 1);
+      chunk.seq = seq;
+    }
+    return chunk.seq;
+  }
+  body(chunk) {
+    const head = JSON.stringify({ sessionId: chunk.sessionId, windowId: this.windowId, seq: this.nextSeq(chunk), ...chunk.meta });
+    return `${head.slice(0, -1)},"events":[${chunk.events.join(",")}]}`;
+  }
+  async sendNext() {
+    const chunk = this.queue[0];
+    if (!chunk) return;
+    const wait = this.destroyed ? 0 : this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.scheduleRetry(wait);
+    this.inflight = chunk;
+    const result = await this.upload(this.body(chunk));
+    this.onResult(chunk, result);
+  }
+  async upload(json) {
+    const f = this.opts.fetch();
+    if (!f) return "drop";
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const timer = ac ? setTimeout(() => ac.abort(), UPLOAD_TIMEOUT_MS) : null;
+    try {
+      let res;
+      try {
+        res = await f(this.opts.url(), { method: "POST", body: json, headers: { "Content-Type": "application/json" }, signal: ac?.signal });
+      } catch {
+        this.opts.health?.failure();
+        return "retry";
+      }
+      if (res.status === 429 || res.status >= 500) this.opts.health?.failure();
+      else this.opts.health?.success();
+      if (res.ok) {
+        const data = await res.json().catch(() => null);
+        return data?.disabled ? "disabled" : "ok";
+      }
+      return res.status >= 400 && res.status < 500 && res.status !== 429 ? "drop" : "retry";
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  onResult(chunk, result) {
+    if (this.inflight === chunk) this.inflight = null;
+    if (result === "retry" && this.queue.includes(chunk)) {
+      if (!this.destroyed) {
+        const max = this.opts.maxAttempts ?? 5;
+        this.attempt = Math.min(this.attempt + 1, max);
+        const delay = this.attempt >= max ? this.opts.slowRetryMs ?? 6e4 : backoffMs(this.attempt - 1, 1e3, 8e3);
+        return this.scheduleRetry(Math.max(delay, this.opts.health?.waitMs() ?? 0));
+      }
+      this.opts.log?.("replay upload failed after the recorder stopped; dropping the chunk");
+    }
+    this.attempt = 0;
+    this.remove(chunk);
+    if (result === "disabled") {
+      for (const c of this.queue.slice()) if (c.sessionId === chunk.sessionId) this.remove(c);
+      if (this.buffer?.sessionId === chunk.sessionId) this.buffer = null;
+      this.opts.onDisabled(chunk.sessionId);
+    }
+    if (this.queue.length && !this.retryTimer && !this.inflight) void this.sendNext();
+  }
+  remove(chunk) {
+    const i = this.queue.indexOf(chunk);
+    if (i >= 0) {
+      this.queue.splice(i, 1);
+      this.queuedBytes -= chunk.bytes;
+    }
+  }
+};
+var TOUCH_SETTLE_MS = 200;
+var IDLE_FRAMES = 3;
+var MAX_IDLE_INTERVAL_MS = 5e3;
+var SessionRecorder = class {
+  constructor(opts) {
+    __publicField(this, "opts", opts);
+    __publicField(this, "intervalMs");
+    __publicField(this, "now");
+    __publicField(this, "sid", null);
+    __publicField(this, "foreground", true);
+    __publicField(this, "generation", 0);
+    __publicField(this, "timer", null);
+    __publicField(this, "timerDue", 0);
+    __publicField(this, "capturing", false);
+    __publicField(this, "needKeyframe", true);
+    __publicField(this, "hasKeyframe", false);
+    __publicField(this, "lastFrame", null);
+    __publicField(this, "unchanged", 0);
+    __publicField(this, "captureSoon", false);
+    __publicField(this, "pendingCustom", []);
+    __publicField(this, "touchDown", false);
+    __publicField(this, "downX", 0);
+    __publicField(this, "downY", 0);
+    __publicField(this, "downAt", 0);
+    __publicField(this, "maxDistance", 0);
+    __publicField(this, "lastMoveAt", 0);
+    __publicField(this, "originX", 0);
+    __publicField(this, "originY", 0);
+    /** Viewport of the last frame (points), for chunk metadata. */
+    __publicField(this, "viewportWidth", 0);
+    __publicField(this, "viewportHeight", 0);
+    this.intervalMs = Math.max(500, opts.intervalMs);
+    this.now = opts.now ?? Date.now;
+  }
+  get sessionId() {
+    return this.sid;
+  }
+  get isRecording() {
+    return this.sid !== null;
+  }
+  get currentIntervalMs() {
+    return this.unchanged >= IDLE_FRAMES ? Math.max(this.intervalMs, Math.min(4 * this.intervalMs, MAX_IDLE_INTERVAL_MS)) : this.intervalMs;
+  }
+  /** Starts (or keeps) recording `sessionId`; another session stops the current one first (uploading it). */
+  start(sessionId) {
+    if (this.sid === sessionId) return;
+    if (this.sid !== null) this.stop(false);
+    this.sid = sessionId;
+    this.generation++;
+    this.needKeyframe = true;
+    this.hasKeyframe = false;
+    this.lastFrame = null;
+    this.unchanged = 0;
+    this.captureSoon = false;
+    this.pendingCustom = [];
+    this.touchDown = false;
+    if (this.foreground) this.schedule(0);
+  }
+  /** Stops recording; buffered events are uploaded unless `discard`. */
+  stop(discard) {
+    if (this.sid === null) return;
+    this.sid = null;
+    this.generation++;
+    this.clearTimer();
+    this.capturing = false;
+    this.pendingCustom = [];
+    this.touchDown = false;
+    if (discard) this.opts.uploader.discard();
+    else this.opts.uploader.flush();
+  }
+  /** App backgrounded: no captures; uploads what is buffered. */
+  pause() {
+    this.foreground = false;
+    this.clearTimer();
+    this.generation++;
+    this.capturing = false;
+    this.touchDown = false;
+    this.opts.uploader.flush();
+  }
+  /** App foregrounded: resume with a keyframe. */
+  resume() {
+    if (this.foreground) return;
+    this.foreground = true;
+    this.needKeyframe = true;
+    this.unchanged = 0;
+    if (this.sid !== null) this.schedule(0);
+  }
+  /** A new screen: the next frame is a keyframe with the new href. */
+  onScreen() {
+    if (this.sid === null) return;
+    this.needKeyframe = true;
+    this.activity();
+  }
+  activity() {
+    const wasIdle = this.unchanged >= IDLE_FRAMES;
+    this.unchanged = 0;
+    if (wasIdle && this.sid !== null && this.foreground && !this.capturing && !this.touchDown) this.schedule(this.intervalMs, true);
+  }
+  /** Adds the `guidely` marker for an analytics event. */
+  addGuidelyEvent(name, customName, guideId) {
+    const id = this.sid;
+    if (id === null) return;
+    const payload = { name };
+    if (customName) payload.customName = customName;
+    if (guideId) payload.guideId = guideId;
+    this.activity();
+    const now = this.now();
+    if (!this.hasKeyframe) {
+      if (this.pendingCustom.length < 50) this.pendingCustom.push([now, payload]);
+      return;
+    }
+    this.opts.uploader.push(id, RrwebEvents.custom(now, "guidely", payload));
+  }
+  /** A primary-pointer touch at (x, y) points from the React root view. */
+  touch(phase, rootX, rootY) {
+    const id = this.sid;
+    if (id === null || !this.foreground) return;
+    const x = rootX + this.originX;
+    const y = rootY + this.originY;
+    const now = this.now();
+    const emit = this.hasKeyframe;
+    const push = (json) => emit && this.opts.uploader.push(id, json);
+    switch (phase) {
+      case "down":
+        this.touchDown = true;
+        this.unchanged = 0;
+        this.downX = x;
+        this.downY = y;
+        this.downAt = now;
+        this.maxDistance = 0;
+        this.lastMoveAt = now;
+        push(RrwebEvents.interaction(now, RrwebEvents.TOUCH_START, x, y));
+        return;
+      case "move":
+        if (!this.touchDown) return;
+        this.maxDistance = Math.max(this.maxDistance, Math.hypot(x - this.downX, y - this.downY));
+        if (now - this.lastMoveAt < 50) return;
+        this.lastMoveAt = now;
+        push(RrwebEvents.touchMove(now, x, y));
+        return;
+      default:
+        if (!this.touchDown) return;
+        this.touchDown = false;
+        this.unchanged = 0;
+        this.maxDistance = Math.max(this.maxDistance, Math.hypot(x - this.downX, y - this.downY));
+        push(RrwebEvents.interaction(now, RrwebEvents.TOUCH_END, x, y));
+        if (phase === "up" && this.maxDistance <= 10 && now - this.downAt < 1e3) push(RrwebEvents.interaction(now, RrwebEvents.CLICK, x, y));
+        if (this.capturing) this.captureSoon = true;
+        else this.schedule(TOUCH_SETTLE_MS, true);
+    }
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  /** Schedules the next capture `delay` ms from now, or keeps an earlier one when `ifSooner`. */
+  schedule(delay, ifSooner = false) {
+    const due = this.now() + delay;
+    if (ifSooner && this.timer && this.timerDue <= due) return;
+    this.clearTimer();
+    this.timerDue = due;
+    const gen = this.generation;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      if (gen === this.generation) void this.tick();
+    }, delay);
+  }
+  async tick() {
+    if (this.sid === null || !this.foreground || this.capturing) return;
+    if (this.touchDown) {
+      this.schedule(this.intervalMs);
+      return;
+    }
+    this.capturing = true;
+    this.captureSoon = false;
+    const gen = this.generation;
+    let frame = null;
+    try {
+      frame = await this.opts.capturer(await this.opts.captureOptions());
+    } catch (err) {
+      this.opts.onError?.(err);
+    }
+    if (gen !== this.generation) return;
+    this.capturing = false;
+    if (frame) this.onFrame(frame, this.now());
+    if (this.sid !== null && this.foreground) this.schedule(this.captureSoon ? TOUCH_SETTLE_MS : this.currentIntervalMs);
+  }
+  onFrame(frame, at) {
+    const id = this.sid;
+    if (id === null || !(frame.width > 0) || !(frame.height > 0) || !frame.base64) return;
+    const sizeChanged = frame.width !== this.viewportWidth || frame.height !== this.viewportHeight;
+    const keyframe = this.needKeyframe || !this.hasKeyframe || sizeChanged;
+    if (!keyframe && this.lastFrame === frame.base64) {
+      this.unchanged++;
+      return;
+    }
+    this.unchanged = 0;
+    this.lastFrame = frame.base64;
+    this.originX = frame.originX ?? 0;
+    this.originY = frame.originY ?? 0;
+    this.viewportWidth = frame.width;
+    this.viewportHeight = frame.height;
+    const url = RrwebEvents.dataUrl(frame.base64);
+    const up = this.opts.uploader;
+    if (!keyframe) return up.push(id, RrwebEvents.frame(at, url));
+    this.needKeyframe = false;
+    up.push(id, RrwebEvents.meta(at, this.opts.href(), frame.width, frame.height));
+    up.push(id, RrwebEvents.fullSnapshot(at, url, frame.width, frame.height));
+    if (!this.hasKeyframe) {
+      this.hasKeyframe = true;
+      for (const [ts, payload] of this.pendingCustom) up.push(id, RrwebEvents.custom(Math.max(ts, at), "guidely", payload));
+      this.pendingCustom = [];
+    }
+  }
+};
+
 // src/core/storage.ts
 var PersistentStore = class {
   constructor(backing, onError = () => {
@@ -2481,7 +2900,7 @@ var PersistentStore = class {
 
 // src/core/client.ts
 var SDK_NAME = "@guidelytech/react-native";
-var SDK_VERSION = "0.12.0";
+var SDK_VERSION = "0.14.0";
 var DEFAULT_API_URL = "https://guidelytech.com";
 var PAGE_SCOPED = /* @__PURE__ */ new Set(["page_load", "url_match", "element_click", "element_visible", "delay"]);
 var CACHED_START_MS = 1500;
@@ -2542,6 +2961,10 @@ var GuidelyClient = class {
     __publicField(this, "lastAudiences", /* @__PURE__ */ new Set());
     __publicField(this, "backgroundedAt", null);
     __publicField(this, "messenger", null);
+    __publicField(this, "replayUploader", null);
+    __publicField(this, "recorder", null);
+    /** Replay decision for the current session (sampled once; forced by start/stopSessionRecording). */
+    __publicField(this, "replayDecision", null);
     __publicField(this, "ui", { steps: [], checklists: [], survey: null, resourceCenterOpen: false, theme: {}, messenger: false });
     __publicField(this, "uiListeners", /* @__PURE__ */ new Set());
     /** Feature flags for this environment: `guidely.flags.isEnabled("new-checkout")`. */
@@ -2693,6 +3116,7 @@ var GuidelyClient = class {
       if (this.destroyed) return;
       this.isReady = true;
       if (this.config) this.emitter.emit("ready", this.config);
+      this.syncReplay();
       this.notify();
       this.evaluate("ready");
     } catch (err) {
@@ -2719,6 +3143,7 @@ var GuidelyClient = class {
         this.syncMessenger();
         if (this.hydrated) this.checkLaunch();
         this.emitter.emit("config", this.config);
+        this.syncReplay();
         this.log("config loaded", this.config.configVersion, `${this.config.guides.length} guides`);
         return true;
       }
@@ -2771,6 +3196,7 @@ var GuidelyClient = class {
       void this.outbox?.flush();
       void this.store.flush();
       void this.flags.flush();
+      this.recorder?.pause();
       this.messenger?.setForeground(false);
     } else if (state === "active" && this.backgroundedAt !== null) {
       this.messenger?.setForeground(true);
@@ -2780,7 +3206,10 @@ var GuidelyClient = class {
         this.session = newSession();
         this.persistSession();
         this.firedDelays.clear();
+        this.recorder?.stop(false);
       }
+      this.recorder?.resume();
+      this.syncReplay();
       this.cameToForeground();
       void this.flags.refresh();
       if (Date.now() - this.configFetchedAt > this.options.configRefreshMs && this.api.health.canSend()) void this.refresh();
@@ -2803,6 +3232,9 @@ var GuidelyClient = class {
     this.queued = [];
     this.messenger?.destroy();
     this.messenger = null;
+    this.recorder?.stop(!this.analyticsEnabled());
+    this.recorder = null;
+    this.replayUploader?.destroy();
     this.visibilityWatchers.forEach((stop) => stop());
     this.visibilityWatchers.clear();
     this.timers.forEach((t) => clearTimeout(t));
@@ -2917,6 +3349,7 @@ var GuidelyClient = class {
       this.store.set(KEYS.anon, this.anonymousId);
       this.state = emptyState();
       this.persistState();
+      this.recorder?.stop(false);
       this.session = newSession();
       this.persistSession();
       this.lastAudiences = /* @__PURE__ */ new Set();
@@ -2924,6 +3357,7 @@ var GuidelyClient = class {
       this.firstVisit = true;
       this.exposures.clear();
       this.syncFlagAttributes();
+      this.syncReplay();
       this.emitter.emit("identify", { userId: null, anonymousId: this.anonymousId });
       this.notify();
       if (this.isReady) this.evaluate("identify");
@@ -2938,6 +3372,7 @@ var GuidelyClient = class {
     this.whenHydrated(() => {
       if (consent === "denied") this.queue?.clear();
       else if (consent === "granted") void this.queue?.flush();
+      this.syncReplay();
     });
   }
   analyticsEnabled() {
@@ -2966,6 +3401,7 @@ var GuidelyClient = class {
     const locale = extra.guideId ? this.guideLocales.get(extra.guideId) : void 0;
     if (locale) event.properties = { ...event.properties ?? {}, locale };
     this.queue.enqueue(event);
+    this.recorder?.addGuidelyEvent(name, event.customName, event.guideId);
     this.emitter.emit("track", event);
     return event;
   }
@@ -3003,6 +3439,7 @@ var GuidelyClient = class {
       }
       this.screenName = name;
       this.targets.setScreen(name);
+      if (changed) this.recorder?.onScreen();
       if (changed) this.syncFlagAttributes();
       const url = this.currentUrl();
       if (changed) {
@@ -3037,6 +3474,112 @@ var GuidelyClient = class {
     if (this.isReady) this.evaluate("click", { targetId });
   }
   // ---------------------------------------------------------------------------
+  // Session replay
+  // ---------------------------------------------------------------------------
+  replaySettings() {
+    const r = this.config?.settings?.replay;
+    if (!r?.enabled || !this.options.sessionReplay?.enabled || !this.bridge.capturer) return null;
+    return r;
+  }
+  /** Reconciles recording with config, consent, readiness, the session and its sample decision. Idempotent. */
+  syncReplay() {
+    if (this.destroyed || !this.hydrated) return;
+    const r = this.isReady && this.analyticsEnabled() ? this.replaySettings() : null;
+    const id = this.session.id;
+    if (r && this.replayDecision?.sessionId !== id) {
+      this.replayDecision = { sessionId: id, record: rolloutBucket(id, "replay") < (r.sampleRate ?? 100) };
+      this.log(`replay ${this.replayDecision.record ? "sampled" : "not sampled"} for session ${id}`);
+    }
+    if (!r || !this.replayDecision?.record) {
+      if (this.recorder?.isRecording) this.recorder.stop(!this.analyticsEnabled());
+      return;
+    }
+    const rec = this.recorder ?? this.createRecorder();
+    if (rec && rec.sessionId !== id) {
+      this.log(`recording session ${id}`);
+      rec.start(id);
+    }
+  }
+  createRecorder() {
+    const capturer = this.bridge.capturer;
+    if (!capturer) return null;
+    const uploader = this.replayUploader ?? (this.replayUploader = new ReplayUploader({
+      url: () => this.api.url("/replay"),
+      fetch: () => this.options.fetch ?? (typeof fetch === "function" ? fetch : null),
+      health: this.api.health,
+      meta: () => {
+        const rec2 = this.recorder;
+        return {
+          anonymousId: this.anonymousId,
+          userId: this.user?.id || null,
+          ...this.collectUrls() && this.screenName ? { url: this.currentUrl() } : {},
+          device: { type: this.bridge.device.deviceType, os: this.bridge.device.platform },
+          ...rec2 && rec2.viewportWidth > 0 && rec2.viewportHeight > 0 ? { viewport: { width: rec2.viewportWidth, height: rec2.viewportHeight } } : {},
+          sdk: { name: SDK_NAME, version: SDK_VERSION }
+        };
+      },
+      onDisabled: (sid) => {
+        if (sid !== this.session.id) return;
+        this.log(`replay disabled by the server for session ${sid}`);
+        this.replayDecision = { sessionId: sid, record: false };
+        this.recorder?.stop(true);
+      },
+      log: (m) => this.log(m)
+    }));
+    const opts = this.options.sessionReplay ?? {};
+    const rec = new SessionRecorder({
+      capturer,
+      uploader,
+      intervalMs: opts.captureIntervalMs ?? 1e3,
+      captureOptions: () => this.replayCaptureOptions(),
+      href: () => this.currentUrl(),
+      onError: (err) => this.reportError(err)
+    });
+    if (this.backgroundedAt !== null) rec.pause();
+    this.recorder = rec;
+    return rec;
+  }
+  async replayCaptureOptions() {
+    const r = this.config?.settings?.replay;
+    const opts = this.options.sessionReplay ?? {};
+    const ids = new Set((r?.blockSelectors ?? []).map((sel) => guidelyIdFromSelector(sel)).filter((id) => !!id));
+    const rects = await Promise.all(Array.from(ids, (id) => this.targets.measure(id)));
+    return { maskAllText: !!opts.maskAllText || !!r?.maskAllText, maskAllImages: !!opts.maskAllImages, blockRects: rects.filter((rect) => !!rect) };
+  }
+  /**
+   * Records this session even when it was not sampled (still needs `sessionReplay.enabled`, replay
+   * enabled for the project, analytics consent and the native replay module). Sticks until the session ends.
+   */
+  startSessionRecording() {
+    this.whenHydrated(() => {
+      this.replayDecision = { sessionId: this.session.id, record: true };
+      this.syncReplay();
+    });
+  }
+  /** Stops recording for the rest of this session; what was recorded is uploaded. */
+  stopSessionRecording() {
+    this.whenHydrated(() => {
+      this.replayDecision = { sessionId: this.session.id, record: false };
+      this.recorder?.stop(false);
+    });
+  }
+  /** True while this session is being recorded. */
+  isRecording() {
+    return !!this.recorder?.isRecording;
+  }
+  /** The current analytics session id (also the replay id). */
+  getSessionId() {
+    return this.session.id;
+  }
+  /** True when touches should be passed to {@link recordTouch}. */
+  isRecordingTouches() {
+    return !!this.recorder?.isRecording;
+  }
+  /** A primary-pointer touch on the app, in window points (the provider's touch observer calls this). */
+  recordTouch(phase, x, y) {
+    this.recorder?.touch(phase, x, y);
+  }
+  // ---------------------------------------------------------------------------
   // Product analytics (autocapture)
   // ---------------------------------------------------------------------------
   captureAllowed() {
@@ -3083,7 +3626,7 @@ var GuidelyClient = class {
     }
     if (this.destroyed) return;
     const platform = this.bridge.device.platform;
-    const maskAll = !!this.config?.settings?.replay?.maskAllText;
+    const maskAll = !!this.config?.settings?.replay?.maskAllText || !!this.options.sessionReplay?.maskAllText;
     const eventUrl = this.collectUrls() && url ? url : void 0;
     if (on.clicks && el) this.enqueue("click", { url: eventUrl, properties: { ...tapProperties(el, tap.x, tap.y, platform, maskAll) } });
     const count = this.rage.add(tap.x, tap.y, t);
@@ -3129,12 +3672,12 @@ var GuidelyClient = class {
   /** `{ appVersion, build }` of this launch, without unknown keys. */
   appInfo() {
     const appVersion = this.options.appVersion ?? this.bridge.device.appVersion;
-    const build = this.options.appBuild;
+    const build = this.options.appBuild ?? (this.options.appVersion ? void 0 : this.bridge.device.appBuild);
     return { ...appVersion ? { appVersion: String(appVersion) } : {}, ...build ? { build: String(build) } : {} };
   }
   /**
    * Once per launch, as soon as a config is known: `app_install` / `app_update` from the stored
-   * version (when the app passes `appVersion` and `storage`), then `app_open` with `coldStart: true`.
+   * version (when the app version is known and the app passes `storage`), then `app_open` with `coldStart: true`.
    */
   checkLaunch() {
     if (this.launchChecked || !this.config || this.destroyed || !this.hydrated) return;
@@ -3951,8 +4494,8 @@ var GuidelyClient = class {
     this.messenger?.close();
   }
   /** Opens a new messenger conversation, optionally pre-filling the message. */
-  showNewMessage(text) {
-    this.whenHydrated(() => this.messenger?.showNewMessage(text));
+  showNewMessage(text2) {
+    this.whenHydrated(() => this.messenger?.showNewMessage(text2));
   }
   // ---------------------------------------------------------------------------
   // Feature flags
@@ -3976,7 +4519,7 @@ var GuidelyClient = class {
   /** Device facts on every screen view, read by the Pages devices / browsers breakdowns. */
   deviceProperties() {
     const d = this.bridge.device;
-    return { platform: d.platform, deviceType: d.deviceType, os: d.platform };
+    return { platform: d.platform, deviceType: d.deviceType, os: d.platform, ...d.osVersion ? { osVersion: d.osVersion } : {} };
   }
   /** Attributes flags are evaluated with: identity, traits, account, audiences, screen and device. */
   flagContext() {
@@ -3987,6 +4530,7 @@ var GuidelyClient = class {
       deviceType: d.deviceType,
       locale: d.locale,
       appVersion: this.options.appVersion ?? d.appVersion,
+      osVersion: d.osVersion,
       environment: this.options.environment,
       ...this.screenName ? { screen: this.screenName, path: this.currentUrl() } : {},
       ...this.user?.traits ?? {},
@@ -4077,6 +4621,51 @@ function withoutCode(guide) {
   return { ...guide, config: { ...guide.config, steps: guide.config.steps.map(({ code: _code, ...step }) => step) } };
 }
 
+// src/core/device.ts
+function text(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value !== "string") return void 0;
+  const v = value.trim();
+  return v ? v.slice(0, 64) : void 0;
+}
+function constant(mod, key) {
+  if (!mod || typeof mod !== "object" && typeof mod !== "function") return void 0;
+  const m = mod;
+  try {
+    const fromGetter = typeof m.getConstants === "function" ? m.getConstants()?.[key] : void 0;
+    return fromGetter ?? m[key];
+  } catch {
+    return void 0;
+  }
+}
+function read(mod, versionKey, buildKey) {
+  const appVersion = text(constant(mod, versionKey));
+  if (!appVersion) return null;
+  const appBuild = text(constant(mod, buildKey));
+  return { appVersion, ...appBuild ? { appBuild } : {} };
+}
+function inExpoGo(src) {
+  const c = src.expoModules?.ExponentConstants ?? src.nativeModules.ExponentConstants;
+  return constant(c, "executionEnvironment") === "storeClient" || constant(c, "appOwnership") === "expo";
+}
+function detectAppVersion(src) {
+  try {
+    const expo = inExpoGo(src) ? null : src.expoModules?.ExpoApplication ?? src.nativeModules.ExpoApplication;
+    return read(src.nativeModules.GuidelyReplay, "appVersion", "appBuild") ?? read(expo, "nativeApplicationVersion", "nativeBuildVersion") ?? read(src.nativeModules.RNDeviceInfo, "appVersion", "buildNumber") ?? {};
+  } catch {
+    return {};
+  }
+}
+function detectOsVersion(src) {
+  try {
+    const c = src.platform.constants ?? {};
+    if (src.platform.OS === "android") return text(c.Release) ?? text(src.platform.Version);
+    return text(c.osVersion) ?? text(src.platform.Version);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/ui/Autocapture.tsx
 import { useMemo as useMemo5, useRef as useRef5 } from "react";
 import { View as View10 } from "react-native";
@@ -4208,8 +4797,8 @@ function describe(f, masked, opts, withText) {
     if (!sub.masked) {
       const hostProps = host?.memoizedProps && typeof host.memoizedProps === "object" ? host.memoizedProps : {};
       const label = props.accessibilityLabel ?? props["aria-label"] ?? hostProps.accessibilityLabel ?? hostProps["aria-label"];
-      const text = cleanText(sub.text) ?? (typeof label === "string" ? cleanText(label) : void 0);
-      if (text) el.text = text;
+      const text2 = cleanText(sub.text) ?? (typeof label === "string" ? cleanText(label) : void 0);
+      if (text2) el.text = text2;
     }
   }
   if (host) el.measure = () => measureHost(host);
@@ -4365,17 +4954,17 @@ function parseHtml(html) {
     flush();
     current = { kind, level, marker, runs: [] };
   };
-  const push = (text) => {
-    if (!text) return;
+  const push = (text2) => {
+    if (!text2) return;
     if (!current) current = { kind: "paragraph", level: 1, runs: [] };
-    const run = { text };
+    const run = { text: text2 };
     if (style.bold) run.bold = true;
     if (style.italic) run.italic = true;
     if (style.underline) run.underline = true;
     if (style.code) run.code = true;
     if (hrefs.length) run.href = hrefs[hrefs.length - 1];
     const last = current.runs[current.runs.length - 1];
-    if (last && last.bold === run.bold && last.italic === run.italic && last.underline === run.underline && last.code === run.code && last.href === run.href) last.text += text;
+    if (last && last.bold === run.bold && last.italic === run.italic && last.underline === run.underline && last.code === run.code && last.href === run.href) last.text += text2;
     else current.runs.push(run);
   };
   const size = (attrs, name) => {
@@ -4391,18 +4980,18 @@ function parseHtml(html) {
   const re = /<!--[\s\S]*?-->|<\/?([a-zA-Z][a-zA-Z0-9]*)\b([^>]*)>|([^<]+|<)/g;
   let m;
   while (m = re.exec(html || "")) {
-    const [token, rawTag, attrs = "", text] = m;
-    if (text !== void 0) {
+    const [token, rawTag, attrs = "", text2] = m;
+    if (text2 !== void 0) {
       if (skipping) continue;
       if (pdf) {
-        if (pdf.inLink) pdf.name += decodeEntities(text);
+        if (pdf.inLink) pdf.name += decodeEntities(text2);
         continue;
       }
       if (fileLink) {
-        fileLink.name += decodeEntities(text);
+        fileLink.name += decodeEntities(text2);
         continue;
       }
-      push(decodeEntities(text.replace(/\s+/g, " ")));
+      push(decodeEntities(text2.replace(/\s+/g, " ")));
       continue;
     }
     if (!rawTag) continue;
@@ -4976,13 +5565,13 @@ function Conversations({ store, palette: p }) {
     /* @__PURE__ */ jsx5(GButton, { label: "New conversation", palette: p, onPress: () => store.showNewMessage(), style: styles4.fullWidth })
   ] });
 }
-function Bubble({ m, text, name, palette: p, onArticle, onGuide }) {
+function Bubble({ m, text: text2, name, palette: p, onArticle, onGuide }) {
   if (m.author === "system")
-    return /* @__PURE__ */ jsx5(Text4, { accessibilityRole: "text", style: [styles4.system, { color: p.muted }], children: text });
+    return /* @__PURE__ */ jsx5(Text4, { accessibilityRole: "text", style: [styles4.system, { color: p.muted }], children: text2 });
   const mine = m.author === "user";
   return /* @__PURE__ */ jsxs3(View4, { style: [styles4.bubbleWrap, mine ? styles4.mine : styles4.theirs], children: [
     !mine ? /* @__PURE__ */ jsx5(Text4, { style: [styles4.author, { color: p.muted }], children: m.author === "agent" ? m.authorName || "Team" : name }) : null,
-    /* @__PURE__ */ jsx5(View4, { style: [styles4.bubble, { borderRadius: Math.max(12, p.radius) }, mine ? { backgroundColor: p.primary } : { backgroundColor: p.surface }], children: m.status === "pending" && !text ? /* @__PURE__ */ jsx5(TypingDots, { color: p.muted }) : /* @__PURE__ */ jsx5(Text4, { style: [styles4.bubbleText, { color: mine ? p.onPrimary : p.text }], children: text }) }),
+    /* @__PURE__ */ jsx5(View4, { style: [styles4.bubble, { borderRadius: Math.max(12, p.radius) }, mine ? { backgroundColor: p.primary } : { backgroundColor: p.surface }], children: m.status === "pending" && !text2 ? /* @__PURE__ */ jsx5(TypingDots, { color: p.muted }) : /* @__PURE__ */ jsx5(Text4, { style: [styles4.bubbleText, { color: mine ? p.onPrimary : p.text }], children: text2 }) }),
     m.citations.length || m.suggestedGuides.length ? /* @__PURE__ */ jsxs3(View4, { style: styles4.chips, children: [
       m.citations.map((c) => /* @__PURE__ */ jsx5(Pressable4, { accessibilityRole: "link", accessibilityLabel: `Article: ${c.title}`, onPress: () => onArticle(c.articleId), style: [styles4.chip, { borderColor: p.border }], children: /* @__PURE__ */ jsxs3(Text4, { style: [styles4.chipText, { color: p.text }], children: [
         "\u{1F4C4} ",
@@ -5001,7 +5590,7 @@ function TypingDots({ color }) {
 function Thread({ store, palette: p, bottomInset }) {
   const snap = useMessenger(store);
   const t = snap.thread;
-  const [text, setText] = useState3(t?.draft ?? "");
+  const [text2, setText] = useState3(t?.draft ?? "");
   const scroll = useRef2(null);
   const convo = t?.conversation ?? null;
   useEffect3(() => {
@@ -5010,7 +5599,7 @@ function Thread({ store, palette: p, bottomInset }) {
   const streamingIds = useMemo3(() => Object.keys(t?.streaming ?? {}).filter((id) => !t?.messages.some((m) => m.id === id)), [t]);
   if (!t) return null;
   const send = () => {
-    const value = text;
+    const value = text2;
     setText("");
     void store.send(value);
   };
@@ -5032,7 +5621,7 @@ function Thread({ store, palette: p, bottomInset }) {
       /* @__PURE__ */ jsx5(
         TextInput,
         {
-          value: text,
+          value: text2,
           onChangeText: (v) => setText(v.slice(0, 4e3)),
           placeholder: convo ? "Reply\u2026" : "Write a message\u2026",
           placeholderTextColor: p.muted,
@@ -5041,7 +5630,7 @@ function Thread({ store, palette: p, bottomInset }) {
           style: [styles4.input, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(18, p.radius + 6) }]
         }
       ),
-      /* @__PURE__ */ jsx5(GButton, { label: "Send", palette: p, onPress: send, disabled: !text.trim() || t.sending })
+      /* @__PURE__ */ jsx5(GButton, { label: "Send", palette: p, onPress: send, disabled: !text2.trim() || t.sending })
     ] })
   ] });
 }
@@ -5955,15 +6544,15 @@ function palette(theme, systemScheme, explicit) {
   const wantsDark = theme.dark === "dark" || theme.dark === "auto" && systemScheme === "dark";
   const dark = wantsDark && !explicit?.backgroundColor;
   const background = dark ? DARK.background : theme.backgroundColor ?? "#ffffff";
-  const text = dark ? DARK.text : theme.textColor ?? "#111827";
+  const text2 = dark ? DARK.text : theme.textColor ?? "#111827";
   return {
     primary,
     onPrimary: luminance(primary) > 0.45 ? "#111827" : "#ffffff",
     background,
-    text,
-    muted: dark ? DARK.muted : mix(text, 0.65),
-    border: dark ? DARK.border : mix(text, 0.12),
-    surface: dark ? DARK.surface : mix(text, 0.05),
+    text: text2,
+    muted: dark ? DARK.muted : mix(text2, 0.65),
+    border: dark ? DARK.border : mix(text2, 0.12),
+    surface: dark ? DARK.surface : mix(text2, 0.05),
     radius: theme.borderRadius ?? 12,
     overlay: `rgba(15, 23, 42, ${theme.overlayOpacity ?? 0.55})`,
     fontFamily: nativeFont(theme.fontFamily)
@@ -6052,8 +6641,9 @@ function rcLauncherLabel(client) {
 
 // src/ui/Autocapture.tsx
 import { jsx as jsx11 } from "react/jsx-runtime";
+var GUIDELY_MASK_NATIVE_ID = "guidely-mask";
 function GuidelyMask({ children, ...rest }) {
-  return /* @__PURE__ */ jsx11(View10, { ...rest, children });
+  return /* @__PURE__ */ jsx11(View10, { collapsable: false, ...rest, nativeID: GUIDELY_MASK_NATIVE_ID, children });
 }
 var RESOLVE = {
   isIgnored: (type) => type === GuidelyOverlay,
@@ -6064,6 +6654,18 @@ function useTapObserver(client) {
   clientRef.current = client;
   return useMemo5(() => {
     const tracker = new TapTracker();
+    let replayPointer = null;
+    const replay = (phase, e) => {
+      const c = clientRef.current;
+      const n = e.nativeEvent;
+      if (!c?.isRecordingTouches()) return void (replayPointer = null);
+      if (phase === "down") {
+        if (replayPointer !== null) return;
+        replayPointer = n.identifier;
+      } else if (n.identifier !== replayPointer) return;
+      if (phase === "up" || phase === "cancel") replayPointer = null;
+      c.recordTouch(phase, n.pageX, n.pageY);
+    };
     const guard = (fn) => (e) => {
       try {
         fn(e);
@@ -6073,12 +6675,17 @@ function useTapObserver(client) {
     };
     return {
       onTouchStartCapture: guard((e) => {
+        replay("down", e);
         const n = e.nativeEvent;
         if (!clientRef.current?.isTapCaptureOn()) return tracker.cancel();
         tracker.begin(n.pageX, n.pageY, Date.now(), Array.isArray(n.touches) ? n.touches.length : 1, n.identifier);
       }),
-      onTouchMoveCapture: guard((e) => tracker.move(e.nativeEvent.pageX, e.nativeEvent.pageY, e.nativeEvent.identifier)),
+      onTouchMoveCapture: guard((e) => {
+        replay("move", e);
+        tracker.move(e.nativeEvent.pageX, e.nativeEvent.pageY, e.nativeEvent.identifier);
+      }),
       onTouchEndCapture: guard((e) => {
+        replay("up", e);
         const n = e.nativeEvent;
         const tap = tracker.end(n.pageX, n.pageY, Date.now(), n.identifier);
         const c = clientRef.current;
@@ -6086,7 +6693,10 @@ function useTapObserver(client) {
         const r = resolveTapTarget(e, RESOLVE);
         if (!r.ignored) c.recordTap({ x: tap.x, y: tap.y, t: Date.now(), element: r.element, hit: r.hit });
       }),
-      onTouchCancelCapture: guard(() => tracker.cancel())
+      onTouchCancelCapture: guard((e) => {
+        replay("cancel", e);
+        tracker.cancel();
+      })
     };
   }, []);
 }
@@ -6169,20 +6779,37 @@ function deviceLocale() {
     return void 0;
   }
 }
-function defaultBridge(appVersion) {
+function nativeSources() {
+  return {
+    platform: Platform6,
+    nativeModules: NativeModules,
+    expoModules: globalThis.expo?.modules
+  };
+}
+function defaultBridge(appVersion, appBuild) {
   const { width, height } = Dimensions.get("window");
+  const sources = nativeSources();
+  const detected = appVersion ? {} : detectAppVersion(sources);
   return {
     device: {
       platform: Platform6.OS === "android" ? "android" : "ios",
       deviceType: Platform6.OS === "ios" && Platform6.isPad || Math.min(width, height) >= 600 ? "tablet" : "mobile",
       locale: deviceLocale(),
-      appVersion
+      appVersion: appVersion ?? detected.appVersion,
+      appBuild: appBuild ?? detected.appBuild,
+      osVersion: detectOsVersion(sources)
     },
     openExternal: (url) => void Linking.openURL(url).catch(() => {
     }),
-    windowSize: () => Dimensions.get("window")
+    windowSize: () => Dimensions.get("window"),
+    capturer: nativeCapturer()
   };
 }
+function nativeCapturer() {
+  const mod = NativeModules.GuidelyReplay;
+  if (!mod || typeof mod.capture !== "function") return void 0;
+  return (options) => mod.capture(options);
+}
 function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPayload, flagAttributes, ...options }) {
   const [client, setClient] = useState8(null);
   const optionsRef = useRef7(options);
@@ -6215,7 +6842,7 @@ function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPay
           onNavigate: (url) => optionsRef.current.onNavigate?.(url),
           onError: (err) => optionsRef.current.onError?.(err)
         },
-        defaultBridge(latest.appVersion)
+        defaultBridge(latest.appVersion, latest.appBuild)
       );
     } catch (err) {
       optionsRef.current.onError?.(err instanceof Error ? err : new Error(String(err)));
@@ -6252,7 +6879,7 @@ function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPay
   const flags = useMemo6(() => ({ client: client?.flags ?? null, bootstrap }), [client, bootstrap]);
   const tapObserver = useTapObserver(client);
   return /* @__PURE__ */ jsx13(GuidelyContext.Provider, { value: client, children: /* @__PURE__ */ jsxs9(FlagsContext.Provider, { value: flags, children: [
-    options.autocapture === false ? children : /* @__PURE__ */ jsx13(View12, { style: styles10.root, ...tapObserver, children }),
+    options.autocapture === false && !options.sessionReplay?.enabled ? children : /* @__PURE__ */ jsx13(View12, { style: styles10.root, ...tapObserver, children }),
     client ? /* @__PURE__ */ jsx13(GuidelyOverlay, { client, insets, launcherOffset }) : null
   ] }) });
 }
@@ -6272,6 +6899,9 @@ var NOOP_RESULTS = {
   getMessenger: null,
   isGuideCompleted: false,
   isClientReady: false,
+  isRecording: false,
+  isRecordingTouches: false,
+  getSessionId: "",
   getScreen: "",
   on: () => {
   },
@@ -6405,12 +7035,17 @@ export {
   InMemoryStickyBucketStore,
   Messenger,
   RageClickDetector,
+  ReplayUploader,
+  RrwebEvents,
   SDK_NAME,
   SDK_VERSION,
+  SessionRecorder,
   TapTracker,
   TargetRegistry,
   createFlagsClient3 as createFlagsClient,
   createSseParser,
+  detectAppVersion,
+  detectOsVersion,
   guidelyScreenLayout,
   htmlToText,
   noopClient,