@guidelytech/react-native 0.16.0 → 0.17.0

package/dist/index.js

@@ -96,7 +96,7 @@ function FlagsProvider({ children, client: external, payload, ...options }) {
   return /* @__PURE__ */ jsx(FlagsContext.Provider, { value, children });
 }
 
-// ../shared/dist/chunk-7PWYIAJI.js
+// ../shared/dist/chunk-YL65O3FS.js
 function fnv1a(input) {
   let h = 2166136261;
   for (let i = 0; i < input.length; i++) {
@@ -109,18 +109,18 @@ function rolloutBucket(subject, salt) {
   return fnv1a(`${salt}:${subject}`) % 100;
 }
 var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-function randomId(size = 16) {
+function randomId(size2 = 16) {
   const g = typeof globalThis !== "undefined" ? globalThis : {};
   let bytes;
   if (g.crypto && typeof g.crypto.getRandomValues === "function") {
-    bytes = new Uint8Array(size);
+    bytes = new Uint8Array(size2);
     g.crypto.getRandomValues(bytes);
   } else {
-    bytes = new Uint8Array(size);
-    for (let i = 0; i < size; i++) bytes[i] = Math.floor(Math.random() * 256);
+    bytes = new Uint8Array(size2);
+    for (let i = 0; i < size2; i++) bytes[i] = Math.floor(Math.random() * 256);
   }
   let out = "";
-  for (let i = 0; i < size; i++) out += ALPHABET[bytes[i] % ALPHABET.length];
+  for (let i = 0; i < size2; i++) out += ALPHABET[bytes[i] % ALPHABET.length];
   return out;
 }
 function getPath(obj, path) {
@@ -390,24 +390,92 @@ function evaluateRules(group, ctx) {
   const value = group.op === "and" ? results.every(Boolean) : results.some(Boolean);
   return group.negate ? !value : value;
 }
+var MAX_EXCEPTION_DETAIL_BYTES = 64 * 1024;
+var MAX_EXCEPTION_DETAIL_RAW_BYTES = 1024 * 1024;
+var MAX_BREADCRUMBS = 100;
+var MAX_EXCEPTION_CHAIN = 20;
+var MAX_DETAIL_FRAMES = 250;
+var MAX_DETAIL_THREADS = 100;
+var MAX_DEBUG_IMAGES = 500;
+var MAX_ERROR_TAGS = 50;
+var size = (v) => {
+  try {
+    return JSON.stringify(v)?.length ?? 0;
+  } catch {
+    return Infinity;
+  }
+};
+function normalizeTags(tags) {
+  const out = {};
+  for (const [k, v] of Object.entries(tags ?? {})) {
+    if (Object.keys(out).length >= MAX_ERROR_TAGS) break;
+    if (!k || v === void 0 || v === null) continue;
+    out[k.slice(0, 32)] = String(v).slice(0, 200);
+  }
+  return out;
+}
+function trimExceptionDetail(detail, max = MAX_EXCEPTION_DETAIL_BYTES) {
+  const d = detail;
+  if (d.breadcrumbs?.values && d.breadcrumbs.values.length > MAX_BREADCRUMBS) d.breadcrumbs.values = d.breadcrumbs.values.slice(-MAX_BREADCRUMBS);
+  if (d.exception?.values && d.exception.values.length > MAX_EXCEPTION_CHAIN) d.exception.values = d.exception.values.slice(-MAX_EXCEPTION_CHAIN);
+  if (d.threads?.values && d.threads.values.length > MAX_DETAIL_THREADS) d.threads.values = d.threads.values.slice(0, MAX_DETAIL_THREADS);
+  if (d.debug_meta?.images && d.debug_meta.images.length > MAX_DEBUG_IMAGES) d.debug_meta.images = d.debug_meta.images.slice(0, MAX_DEBUG_IMAGES);
+  const stacks = () => [...d.exception?.values ?? [], ...d.threads?.values ?? []].map((x) => x.stacktrace).filter((s) => !!s);
+  for (const s of stacks()) if (s.frames && s.frames.length > MAX_DETAIL_FRAMES) s.frames = s.frames.slice(-MAX_DETAIL_FRAMES);
+  if (size(d) <= max) return d;
+  while (d.breadcrumbs?.values.length && size(d) > max) d.breadcrumbs.values = d.breadcrumbs.values.slice(Math.ceil(d.breadcrumbs.values.length / 2));
+  if (size(d) <= max) return d;
+  for (const s of stacks())
+    for (const f of s.frames ?? []) {
+      delete f.vars;
+      delete f.pre_context;
+      delete f.post_context;
+    }
+  if (size(d) <= max) return d;
+  if (d.threads?.values) d.threads.values = d.threads.values.filter((t) => t.crashed || t.current);
+  if (size(d) <= max) return d;
+  if (d.extra) d.extra = { _trimmed: true };
+  if (d.request) delete d.request.data;
+  for (const s of stacks()) while (s.frames && s.frames.length > 20 && size(d) > max) s.frames.splice(Math.floor(s.frames.length / 2) - 5, 10);
+  if (d.debug_meta?.images && size(d) > max) d.debug_meta.images = d.debug_meta.images.slice(0, 50);
+  return d;
+}
+var matches = (patterns, value) => patterns.some((p) => typeof p === "string" ? p !== "" && value.includes(p) : safeTest(p, value));
+function safeTest(re, value) {
+  re.lastIndex = 0;
+  return re.test(value);
+}
+function errorFilterDrops(e, opts) {
+  const message = e.message ?? "";
+  if (opts.ignoreErrors?.length && (matches(opts.ignoreErrors, `${e.type || "Error"}: ${message}`) || matches(opts.ignoreErrors, message))) return true;
+  if (!e.file) return false;
+  if (opts.denyUrls?.length && matches(opts.denyUrls, e.file)) return true;
+  if (opts.allowUrls?.length && !matches(opts.allowUrls, e.file)) return true;
+  return false;
+}
 var SENSITIVE_PROPERTY_PATTERN = /(password|passwd|secret|token|credit|card|cvv|ssn|iban)/i;
 var MAX_PROPERTY_BYTES = 8 * 1024;
 function sanitizeProperties(props) {
   if (!props) return {};
   const out = {};
-  let size = 0;
+  let size2 = 0;
   for (const [k, v] of Object.entries(props)) {
     if (SENSITIVE_PROPERTY_PATTERN.test(k)) continue;
     if (typeof v === "function" || typeof v === "symbol") continue;
     const str2 = typeof v === "string" ? v : JSON.stringify(v ?? null);
-    size += k.length + (str2?.length ?? 0);
-    if (size > MAX_PROPERTY_BYTES) break;
+    size2 += k.length + (str2?.length ?? 0);
+    if (size2 > MAX_PROPERTY_BYTES) break;
     out[k.slice(0, 100)] = typeof v === "string" ? v.slice(0, 1e3) : v;
   }
   return out;
 }
+function reactNativeBundleUrl(file) {
+  const base = file.replace(/[?#].*$/, "").split("/").pop() || file;
+  return `app:///${base}`;
+}
 var SOURCEMAP_MAX_FILE_BYTES = 100 * 1024 * 1024;
 var MAX_COMPLAINT_ATTACHMENT_BYTES = 2 * 1024 * 1024;
+var MAX_BUG_REPORT_SCREENSHOT_BYTES = 4 * 1024 * 1024;
 var MEDIA_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
 var MEDIA_VIDEO_MAX_BYTES = 200 * 1024 * 1024;
 var MEDIA_FILE_MAX_BYTES = 50 * 1024 * 1024;
@@ -1032,7 +1100,22 @@ var KEYS = {
   launcher: (key) => `guidely:launcher:${key}`
 };
 
-// ../sdk-core/dist/chunk-2E2YUQAG.js
+// ../sdk-core/dist/chunk-GFLVZRTS.js
+var MAX_PERSISTED_QUEUE_CHARS = 1024 * 1024;
+function fitPersisted(events) {
+  let size2 = JSON.stringify(events).length;
+  if (size2 <= MAX_PERSISTED_QUEUE_CHARS) return events;
+  const out = events.slice();
+  for (let i = 0; i < out.length && size2 > MAX_PERSISTED_QUEUE_CHARS; i++) {
+    const e = out[i];
+    if (!e.detail) continue;
+    size2 -= JSON.stringify(e.detail).length;
+    const rest = { ...e };
+    delete rest.detail;
+    out[i] = rest;
+  }
+  return out;
+}
 var EventQueue = class {
   constructor(opts) {
     __publicField2(this, "opts", opts);
@@ -1088,7 +1171,7 @@ var EventQueue = class {
     this.schedule();
   }
   persist() {
-    writeJson(this.opts.store, this.opts.storageKey, this.events);
+    writeJson(this.opts.store, this.opts.storageKey, fitPersisted(this.events));
   }
   schedule() {
     if (this.timer || this.retryTimer || this.destroyed) return;
@@ -1338,6 +1421,13 @@ function dismissedAfterMerge(local, server) {
   if (server.dismissResetAt && server.dismissResetAt !== local?.dismissResetAt) return server.dismissedAt ?? null;
   return local?.dismissedAt ?? server.dismissedAt ?? null;
 }
+function environmentFromKey(key) {
+  const prefix = /^pk_([a-z0-9]+)_/.exec(key)?.[1];
+  if (!prefix || prefix === "dev") return "development";
+  if (prefix === "prod") return "production";
+  if (prefix === "stg" || prefix === "stag") return "staging";
+  return prefix;
+}
 
 // src/core/client.ts
 import { createFlagsClient as createFlagsClient2 } from "@guidelytech/flags";
@@ -1494,6 +1584,593 @@ var TapTracker = class {
   }
 };
 
+// src/core/breadcrumbs.ts
+var BreadcrumbBuffer = class {
+  constructor(max = MAX_BREADCRUMBS) {
+    __publicField(this, "max", max);
+    __publicField(this, "items", []);
+  }
+  /** Adds a breadcrumb; `max` (at most the buffer's own) lowers how many are kept. */
+  add(crumb, max = this.max) {
+    const limit = Math.min(max, this.max);
+    this.items.push(crumb);
+    if (this.items.length > limit) this.items.splice(0, this.items.length - limit);
+  }
+  /** Copies, oldest first (an event keeps the crumbs it was captured with). */
+  values() {
+    return this.items.map((c) => ({ ...c, ...c.data ? { data: { ...c.data } } : {} }));
+  }
+  get size() {
+    return this.items.length;
+  }
+  clear() {
+    this.items = [];
+  }
+};
+function stripUrl(url) {
+  return String(url).replace(/[?#].*$/, "").replace(/^([a-z][\w+.-]*:\/\/)[^/@]*@/i, "$1").slice(0, 500);
+}
+function describeArg(value) {
+  if (typeof value === "string") return value.slice(0, 500);
+  if (value instanceof Error) return `${value.name}: ${value.message}`.slice(0, 500);
+  try {
+    return (JSON.stringify(value) ?? String(value)).slice(0, 500);
+  } catch {
+    return String(value).slice(0, 500);
+  }
+}
+function instrumentConsole(target, emit) {
+  if (!target) return () => {
+  };
+  const undo = [];
+  let inside = false;
+  for (const [method, level] of [
+    ["warn", "warning"],
+    ["error", "error"]
+  ]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    const wrapped = function(...args) {
+      const result = original.apply(this, args);
+      if (!inside && !(typeof args[0] === "string" && args[0].startsWith("[Guidely]"))) {
+        inside = true;
+        try {
+          const parts = args.slice(0, 5).map(describeArg);
+          emit({ type: "debug", category: "console", level, message: parts.join(" ").slice(0, 1e3), data: { arguments: parts, logger: "console" } });
+        } catch {
+        } finally {
+          inside = false;
+        }
+      }
+      return result;
+    };
+    target[method] = wrapped;
+    undo.push(() => {
+      if (target[method] === wrapped) target[method] = original;
+    });
+  }
+  return () => undo.forEach((fn) => fn());
+}
+function httpLevel(status) {
+  if (!status) return "error";
+  return status >= 500 ? "error" : status >= 400 ? "warning" : "info";
+}
+var XHR_INFO = "__guidelyXhr";
+function instrumentHttp(g, emit, skip, now = Date.now) {
+  if (!g) return () => {
+  };
+  const undo = [];
+  let inFetch = 0;
+  const record2 = (category, method, url, start, status) => {
+    try {
+      const data = { method, url: stripUrl(url), ...status ? { status_code: status } : {}, duration_ms: Math.max(0, Math.round(now() - start)) };
+      emit({ type: "http", category, level: httpLevel(status), data });
+    } catch {
+    }
+  };
+  const originalFetch = g.fetch;
+  if (typeof originalFetch === "function") {
+    const wrappedFetch = function(...args) {
+      const [input, init] = args;
+      let url = "";
+      let method = "GET";
+      try {
+        const req = input;
+        url = typeof req === "string" ? req : typeof req?.url === "string" ? req.url : String(input);
+        method = String(init?.method ?? (req && typeof req === "object" ? req.method : void 0) ?? "GET").toUpperCase();
+      } catch {
+      }
+      if (skip(url)) return originalFetch.apply(this, args);
+      const start = now();
+      let result;
+      inFetch += 1;
+      try {
+        result = originalFetch.apply(this, args);
+      } finally {
+        inFetch -= 1;
+      }
+      if (!result || typeof result.then !== "function") return result;
+      return result.then(
+        (res) => {
+          record2("fetch", method, url, start, typeof res?.status === "number" ? res.status : void 0);
+          return res;
+        },
+        (err) => {
+          record2("fetch", method, url, start, void 0);
+          throw err;
+        }
+      );
+    };
+    g.fetch = wrappedFetch;
+    undo.push(() => {
+      if (g.fetch === wrappedFetch) g.fetch = originalFetch;
+    });
+  }
+  const proto = g.XMLHttpRequest?.prototype;
+  const originalOpen = proto?.open;
+  const originalSend = proto?.send;
+  if (proto && typeof originalOpen === "function" && typeof originalSend === "function") {
+    const open = function(...args) {
+      try {
+        this[XHR_INFO] = { method: String(args[0] ?? "GET").toUpperCase(), url: String(args[1] ?? ""), viaFetch: inFetch > 0 };
+      } catch {
+      }
+      return originalOpen.apply(this, args);
+    };
+    const send = function(...args) {
+      try {
+        const info = this[XHR_INFO];
+        if (info && !info.viaFetch && !skip(info.url) && typeof this.addEventListener === "function") {
+          info.start = now();
+          this.addEventListener("readystatechange", () => {
+            if (this.readyState !== 4 || info.done) return;
+            info.done = true;
+            record2("xhr", info.method, info.url, info.start ?? now(), typeof this.status === "number" && this.status > 0 ? this.status : void 0);
+          });
+        }
+      } catch {
+      }
+      return originalSend.apply(this, args);
+    };
+    proto.open = open;
+    proto.send = send;
+    undo.push(() => {
+      if (proto.open === open) proto.open = originalOpen;
+      if (proto.send === send) proto.send = originalSend;
+    });
+  }
+  return () => undo.forEach((fn) => fn());
+}
+
+// src/core/crashHandlers.ts
+var FATAL_FLUSH_MS = 2e3;
+var isThenable = (v) => !!v && typeof v.then === "function";
+function installGlobalHandler(g, report, waitMs = FATAL_FLUSH_MS) {
+  const eu = g.ErrorUtils;
+  if (!eu || typeof eu.setGlobalHandler !== "function") return () => {
+  };
+  let previous;
+  try {
+    previous = eu.getGlobalHandler?.();
+  } catch {
+    previous = void 0;
+  }
+  let active = true;
+  let handlingFatal = false;
+  const handler = (error, isFatal) => {
+    const fatal = !!isFatal;
+    const callPrevious = () => previous?.(error, isFatal);
+    if (!active || fatal && handlingFatal) return callPrevious();
+    let pending;
+    try {
+      pending = report(error, fatal);
+    } catch {
+    }
+    if (!fatal || g.__DEV__ || !isThenable(pending)) return callPrevious();
+    handlingFatal = true;
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      handlingFatal = false;
+      try {
+        callPrevious();
+      } catch {
+      }
+    };
+    const timer = setTimeout(finish, waitMs);
+    pending.then(finish, finish);
+  };
+  try {
+    eu.setGlobalHandler(handler);
+  } catch {
+    return () => {
+    };
+  }
+  return () => {
+    active = false;
+    try {
+      if (previous && eu.getGlobalHandler?.() === handler) eu.setGlobalHandler(previous);
+    } catch {
+    }
+  };
+}
+function describeRejection(rejection) {
+  if (rejection instanceof Error) return rejection.stack || `${rejection.name}: ${rejection.message}`;
+  try {
+    return typeof rejection === "string" ? rejection : JSON.stringify(rejection) ?? String(rejection);
+  } catch {
+    return String(rejection);
+  }
+}
+function hermesTracker(g) {
+  const h = g.HermesInternal;
+  try {
+    if (!h || typeof h.enablePromiseRejectionTracker !== "function" || typeof h.hasPromise === "function" && !h.hasPromise()) return null;
+  } catch {
+    return null;
+  }
+  return { enable: (options) => h.enablePromiseRejectionTracker(options) };
+}
+function installRejectionTracking(g, report, tracker) {
+  let active = true;
+  const warn = (message) => {
+    try {
+      g.console?.warn?.(message);
+    } catch {
+    }
+  };
+  const options = {
+    allRejections: true,
+    onUnhandled: (id, rejection) => {
+      if (active) {
+        try {
+          report(rejection);
+        } catch {
+        }
+      }
+      if (g.__DEV__) warn(`Possible unhandled promise rejection (id: ${id}):
+${describeRejection(rejection)}`);
+    },
+    onHandled: (id) => {
+      if (g.__DEV__) warn(`Promise rejection handled (id: ${id})
+This means you can ignore any previous messages of the form "Possible unhandled promise rejection (id: ${id}):"`);
+    }
+  };
+  const t = tracker ?? hermesTracker(g);
+  if (t && typeof t.enable === "function") {
+    try {
+      t.enable(options);
+      return () => {
+        active = false;
+      };
+    } catch {
+    }
+  }
+  if (typeof g.addEventListener === "function") {
+    const listener = (event) => {
+      if (active) report(event?.reason);
+    };
+    try {
+      g.addEventListener("unhandledrejection", listener);
+      return () => {
+        active = false;
+        g.removeEventListener?.("unhandledrejection", listener);
+      };
+    } catch {
+    }
+  }
+  return () => {
+    active = false;
+  };
+}
+function runtimeContext(g) {
+  const h = g.HermesInternal;
+  if (!h) return { name: "jsc" };
+  try {
+    const version = h.getRuntimeProperties?.()?.["OSS Release Version"];
+    return { name: "hermes", ...typeof version === "string" && version ? { version: version.slice(0, 50) } : {} };
+  } catch {
+    return { name: "hermes" };
+  }
+}
+
+// src/core/stack.ts
+var AT = /^\s*at (?:(.+?) \()?(?:address at )?(.+?):(\d+):(\d+)\)?\s*$/;
+var AT_NATIVE = /^\s*at (?:(.+?) \()?(?:native|\[native code\])\)?\s*$/;
+var JSC = /^\s*([^@]*)@(.+?):(\d+):(\d+)\s*$/;
+var JSC_BARE = /^\s*(\S+?):(\d+):(\d+)\s*$/;
+var JSC_NATIVE = /^\s*(?:([^@]*)@)?\[native code\]\s*$/;
+var BUNDLE = /\.(jsbundle|bundle|hbc)$/i;
+function normalizeBundleFile(file) {
+  const f = file.trim();
+  if (/^https?:\/\//i.test(f)) return f.replace(/[?#].*$/, "");
+  const path = f.replace(/^file:\/\//i, "").replace(/[?#].*$/, "");
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  return BUNDLE.test(base) ? reactNativeBundleUrl(path) : path;
+}
+function inAppFor(file) {
+  if (!file) return false;
+  if (/(^|\/)node_modules\//.test(file) || /(^|\/)InternalBytecode\.js$/.test(file)) return false;
+  if (file.startsWith("app:///") || /^https?:\/\//i.test(file)) return void 0;
+  return true;
+}
+function frame(fn, file, line, col) {
+  const name = (fn || "").trim();
+  const normalized = file ? normalizeBundleFile(file).slice(0, 500) : void 0;
+  const inApp = inAppFor(normalized);
+  return {
+    ...name ? { fn: name.slice(0, 200) } : {},
+    ...normalized ? { file: normalized } : {},
+    ...line ? { line: Number(line) } : {},
+    ...col ? { col: Number(col) } : {},
+    ...inApp !== void 0 ? { inApp } : {}
+  };
+}
+function parseReactNativeStack(stack, max = MAX_DETAIL_FRAMES) {
+  if (!stack || typeof stack !== "string") return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    if (frames.length >= max) break;
+    const line = raw.slice(0, 1e3);
+    let m;
+    if (m = AT_NATIVE.exec(line)) frames.push(frame(m[1], void 0));
+    else if (m = AT.exec(line)) frames.push(frame(m[1], m[2], m[3], m[4]));
+    else if (m = JSC_NATIVE.exec(line)) frames.push(frame(m[1], void 0));
+    else if (m = JSC.exec(line)) frames.push(frame(m[1], m[2], m[3], m[4]));
+    else if (m = JSC_BARE.exec(line)) frames.push(frame(void 0, m[1], m[2], m[3]));
+  }
+  return frames;
+}
+function toDetailFrames(frames) {
+  return frames.slice().reverse().map((f) => ({
+    ...f.fn ? { function: f.fn } : {},
+    ...f.file ? { filename: f.file, abs_path: f.file } : {},
+    ...f.line !== void 0 ? { lineno: f.line } : {},
+    ...f.col !== void 0 ? { colno: f.col } : {},
+    ...f.inApp !== void 0 ? { in_app: f.inApp } : {}
+  }));
+}
+var MAX_FRAMES_BYTES = 6e3;
+function fitPropertyFrames(frames) {
+  const out = frames.slice(0, 30);
+  while (out.length > 1 && JSON.stringify(out).length > MAX_FRAMES_BYTES) out.pop();
+  return out;
+}
+
+// src/core/errors.ts
+var CONTEXT_KEYS = ["tags", "extra", "level", "fingerprint", "contexts", "user"];
+function splitHint(hint) {
+  const ctx = {};
+  const properties = {};
+  for (const [k, v] of Object.entries(hint && typeof hint === "object" ? hint : {})) (CONTEXT_KEYS.includes(k) ? ctx : properties)[k] = v;
+  return { ctx, properties };
+}
+var nowSeconds = () => Date.now() / 1e3;
+var ErrorScope = class {
+  constructor(opts) {
+    __publicField(this, "opts", opts);
+    __publicField(this, "tags", {});
+    __publicField(this, "extra", {});
+    __publicField(this, "contexts", {});
+    __publicField(this, "user", {});
+    __publicField(this, "crumbs", new BreadcrumbBuffer(MAX_BREADCRUMBS));
+  }
+  get max() {
+    return Math.max(0, Math.min(MAX_BREADCRUMBS, this.opts()?.maxBreadcrumbs ?? MAX_BREADCRUMBS));
+  }
+  addBreadcrumb(crumb, hint) {
+    if (!crumb || typeof crumb !== "object") return;
+    let c = { timestamp: nowSeconds(), ...crumb };
+    const before = this.opts()?.beforeBreadcrumb;
+    if (before) {
+      try {
+        c = before(c, hint);
+      } catch {
+      }
+    }
+    const max = this.max;
+    if (!c || !max) return;
+    this.crumbs.add(c, max);
+  }
+  breadcrumbs() {
+    return this.crumbs.values();
+  }
+  clear() {
+    this.tags = {};
+    this.extra = {};
+    this.contexts = {};
+    this.user = {};
+    this.crumbs.clear();
+  }
+};
+var isError = (v) => v instanceof Error || !!v && typeof v === "object" && typeof v.message === "string" && typeof v.stack === "string";
+function describe(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function exceptionFromValue(error, source, handled, fallbackType = "Error") {
+  const e = error;
+  const ok = isError(error);
+  return {
+    type: (ok && e.name || fallbackType).slice(0, 200),
+    message: (ok ? e.message : describe(error)).slice(0, 1e3),
+    frames: ok ? fitPropertyFrames(parseReactNativeStack(e.stack)) : [],
+    source,
+    handled
+  };
+}
+function exceptionChain(error, main, mechanism) {
+  const mainFrames = isError(error) ? parseReactNativeStack(error.stack) : main.frames;
+  const chain = [{ type: main.type, value: main.message, mechanism: { type: mechanism, handled: main.handled !== false, exception_id: 0 }, ...mainFrames.length ? { stacktrace: { frames: toDetailFrames(mainFrames) } } : {} }];
+  const seen = /* @__PURE__ */ new Set([error]);
+  let cur = isError(error) ? error.cause : void 0;
+  while (cur !== void 0 && cur !== null && !seen.has(cur) && chain.length < MAX_EXCEPTION_CHAIN) {
+    seen.add(cur);
+    const e = cur;
+    const id = chain.length;
+    const frames = isError(e) ? parseReactNativeStack(e.stack, 50) : [];
+    chain.push({
+      type: (isError(e) && e.name || "Error").slice(0, 200),
+      value: (isError(e) ? e.message : describe(cur)).slice(0, 1e3),
+      mechanism: { type: "chained", source: "cause", handled: true, exception_id: id, parent_id: id - 1 },
+      ...frames.length ? { stacktrace: { frames: toDetailFrames(frames) } } : {}
+    });
+    cur = isError(e) ? e.cause : void 0;
+  }
+  return chain.reverse();
+}
+var SENSITIVE_KEY = new RegExp(`${SENSITIVE_PROPERTY_PATTERN.source}|authorization|cookie|api[-_]?key`, "i");
+function normalizeValue(value, depth = 5, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "string") return value.slice(0, 5e3);
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") return void 0;
+  if (value instanceof Date) return Number.isFinite(value.getTime()) ? value.toISOString() : String(value);
+  if (isError(value)) return { name: value.name, message: value.message.slice(0, 1e3) };
+  if (typeof value !== "object" || seen.has(value)) return "[Circular]";
+  if (depth <= 0) return Array.isArray(value) ? "[Array]" : "[Object]";
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.slice(0, MAX_DETAIL_FRAMES).map((v) => normalizeValue(v, depth - 1, seen) ?? null);
+    const out = {};
+    let n = 0;
+    for (const [k, v] of Object.entries(value)) {
+      if (n++ >= 100) break;
+      if (SENSITIVE_KEY.test(k)) out[k] = "[Filtered]";
+      else {
+        const nv = normalizeValue(v, depth - 1, seen);
+        if (nv !== void 0) out[k] = nv;
+      }
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+var record = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var jsonSize = (v) => {
+  try {
+    return JSON.stringify(v)?.length ?? 0;
+  } catch {
+    return Infinity;
+  }
+};
+function finalizeDetail(detail, max = MAX_EXCEPTION_DETAIL_BYTES) {
+  let d = normalizeValue(detail, 12);
+  if (!d || typeof d !== "object") return void 0;
+  if (d.tags) d.tags = normalizeTags(Object.fromEntries(Object.entries(d.tags).filter(([k]) => !SENSITIVE_KEY.test(k))));
+  d = trimExceptionDetail(d, max);
+  if (jsonSize(d) <= max) return d;
+  const slim = { ...d.level ? { level: d.level } : {}, ...d.exception ? { exception: d.exception } : {}, ...d.tags ? { tags: d.tags } : {}, ...d.fingerprint ? { fingerprint: d.fingerprint } : {}, ...d.release ? { release: d.release } : {}, ...d.dist ? { dist: d.dist } : {} };
+  return jsonSize(slim) <= max ? slim : void 0;
+}
+function buildDetail(input) {
+  const { scope, ctx } = input;
+  const contexts = { ...input.contexts, ...scope.contexts };
+  for (const [k, v] of Object.entries(record(ctx.contexts))) {
+    if (v && typeof v === "object") contexts[k] = v;
+    else delete contexts[k];
+  }
+  const user = { ...input.userId ? { id: input.userId } : {}, ...scope.user, ...record(ctx.user) };
+  const message = input.props.type === "Message";
+  return {
+    level: input.level,
+    platform: "javascript",
+    timestamp: nowSeconds(),
+    ...input.release ? { release: input.release } : {},
+    ...input.dist ? { dist: input.dist } : {},
+    ...input.environment ? { environment: input.environment } : {},
+    ...message ? { message: { formatted: input.props.message } } : { exception: { values: exceptionChain(input.error, input.props, input.mechanism) } },
+    breadcrumbs: { values: scope.breadcrumbs() },
+    contexts,
+    tags: normalizeTags({ ...scope.tags, ...record(ctx.tags) }),
+    extra: { ...scope.extra, ...record(ctx.extra) },
+    ...Object.keys(user).length ? { user } : {},
+    ...Array.isArray(ctx.fingerprint) && ctx.fingerprint.length ? { fingerprint: ctx.fingerprint.map(String) } : {},
+    sdk: input.sdk
+  };
+}
+function prepareError(props, extraProperties, detail, opts, fatal, release) {
+  const file = props.frames.find((f) => f.file)?.file;
+  if (opts && errorFilterDrops({ type: props.type, message: props.message, file }, opts)) return null;
+  if (typeof opts?.sampleRate === "number" && opts.sampleRate < 1 && Math.random() >= Math.max(0, opts.sampleRate)) return null;
+  const values = detail.exception?.values ?? [];
+  const thrown = values[values.length - 1];
+  const mechanism = thrown?.mechanism?.type ?? props.source;
+  let properties = { ...props, level: detail.level ?? "error", platform: "javascript", ...mechanism ? { mechanism } : {} };
+  if (release) properties.release = release.slice(0, 100);
+  if (detail.fingerprint?.length) properties.fingerprintParts = detail.fingerprint.slice(0, 20);
+  for (const [k, v] of Object.entries(extraProperties)) if (!(k in properties)) properties[k] = v;
+  let d = detail;
+  if (opts?.beforeSend) {
+    try {
+      const out = opts.beforeSend({ properties, detail: d });
+      if (out === null) return null;
+      if (out && typeof out === "object") {
+        if (out.properties && typeof out.properties === "object") properties = out.properties;
+        if (out.detail && typeof out.detail === "object") d = out.detail;
+      }
+    } catch {
+    }
+  }
+  const finalDetail = finalizeDetail(d);
+  return { eventId: randomId(24), occurredAt: (/* @__PURE__ */ new Date()).toISOString(), properties, ...finalDetail ? { detail: finalDetail } : {}, fatal };
+}
+var ExceptionThrottle = class {
+  constructor(max = 5) {
+    __publicField(this, "max", max);
+    __publicField(this, "seen", /* @__PURE__ */ new Map());
+  }
+  allow(props) {
+    const frames = Array.isArray(props.frames) ? props.frames : [];
+    const top = frames[0];
+    const key = `${String(props.type)}|${String(props.message)}|${top ? `${top.file}:${top.line}:${top.col}` : ""}`;
+    const n = this.seen.get(key) ?? 0;
+    if (n >= this.max) return false;
+    if (this.seen.size > 500) this.seen.clear();
+    this.seen.set(key, n + 1);
+    return true;
+  }
+};
+function rnVersion(v) {
+  if (!v) return void 0;
+  if (typeof v === "string") return v;
+  if (typeof v.major !== "number") return void 0;
+  return `${v.major}.${v.minor ?? 0}.${v.patch ?? 0}${v.prerelease ? `-${v.prerelease}` : ""}`;
+}
+function reactNativeContexts(device, app, g) {
+  const runtime = g ? runtimeContext(g) : void 0;
+  const version = rnVersion(device.reactNativeVersion);
+  return {
+    os: { name: device.platform === "android" ? "Android" : "iOS", ...device.osVersion ? { version: device.osVersion } : {} },
+    device: {
+      family: device.deviceType === "tablet" ? "Tablet" : "Mobile",
+      ...device.model ? { model: device.model } : {},
+      ...device.manufacturer ? { manufacturer: device.manufacturer } : {},
+      ...device.brand ? { brand: device.brand } : {},
+      ...device.simulator !== void 0 ? { simulator: device.simulator } : {}
+    },
+    app: {
+      ...app.appVersion ? { app_version: app.appVersion } : {},
+      ...app.build ? { app_build: app.build } : {},
+      ...app.inForeground !== void 0 ? { in_foreground: app.inForeground } : {}
+    },
+    ...runtime ? { runtime } : {},
+    react_native_context: {
+      ...runtime ? { js_engine: runtime.name } : {},
+      ...version ? { react_native_version: version } : {},
+      ...g ? { turbo_module: !!g.__turboModuleProxy || !!g.RN$Bridgeless, fabric: !!g.nativeFabricUIManager, expo: !!g.expo } : {}
+    }
+  };
+}
+
 // src/core/targets.ts
 var TargetTimeoutError = class extends Error {
   constructor(ids) {
@@ -2824,38 +3501,38 @@ var SessionRecorder = class {
     this.capturing = true;
     this.captureSoon = false;
     const gen = this.generation;
-    let frame = null;
+    let frame2 = null;
     try {
-      frame = await this.opts.capturer(await this.opts.captureOptions());
+      frame2 = 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 (frame2) this.onFrame(frame2, this.now());
     if (this.sid !== null && this.foreground) this.schedule(this.captureSoon ? TOUCH_SETTLE_MS : this.currentIntervalMs);
   }
-  onFrame(frame, at) {
+  onFrame(frame2, 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;
+    if (id === null || !(frame2.width > 0) || !(frame2.height > 0) || !frame2.base64) return;
+    const sizeChanged = frame2.width !== this.viewportWidth || frame2.height !== this.viewportHeight;
     const keyframe = this.needKeyframe || !this.hasKeyframe || sizeChanged;
-    if (!keyframe && this.lastFrame === frame.base64) {
+    if (!keyframe && this.lastFrame === frame2.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);
+    this.lastFrame = frame2.base64;
+    this.originX = frame2.originX ?? 0;
+    this.originY = frame2.originY ?? 0;
+    this.viewportWidth = frame2.width;
+    this.viewportHeight = frame2.height;
+    const url = RrwebEvents.dataUrl(frame2.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));
+    up.push(id, RrwebEvents.meta(at, this.opts.href(), frame2.width, frame2.height));
+    up.push(id, RrwebEvents.fullSnapshot(at, url, frame2.width, frame2.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));
@@ -2917,7 +3594,7 @@ var PersistentStore = class {
 
 // src/core/client.ts
 var SDK_NAME = "@guidelytech/react-native";
-var SDK_VERSION = "0.16.0";
+var SDK_VERSION = "0.17.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;
@@ -2932,6 +3609,10 @@ function settlesWithin(promise, ms) {
   });
 }
 var appVersionKey = (key) => `guidely:app:${key}`;
+var crashKey = (key) => `guidely:crash:${key}`;
+var earlyCrashKey = (key) => `guidely:crash-early:${key}`;
+var MAX_STORED_CRASHES = 10;
+var MAX_SESSION_EXCEPTIONS = 50;
 var UNKNOWN_VIEW = { selector: "View", tag: "View" };
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 var emptyState = () => ({ guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] });
@@ -2948,6 +3629,8 @@ var GuidelyClient = class {
     /** Survey answers, guide completions/dismissals and checklist progress, kept until the server has them. */
     __publicField(this, "outbox", null);
     __publicField(this, "config", null);
+    /** The `environment` option as passed (the resolved one is in `options.environment`). */
+    __publicField(this, "envOption");
     __publicField(this, "configFetchedAt", 0);
     __publicField(this, "etag", null);
     __publicField(this, "anonymousId", "");
@@ -3011,6 +3694,16 @@ var GuidelyClient = class {
     __publicField(this, "localizedRc", null);
     /** "What's new" last-seen time when the resource center opened (entries after it read as new). */
     __publicField(this, "announcementsSeenAtOpen", null);
+    // Error monitoring.
+    __publicField(this, "errorScope", new ErrorScope(() => this.options.errors));
+    __publicField(this, "exceptionThrottle", new ExceptionThrottle());
+    /** Errors captured before storage and a config were loaded (whether error tracking is on is unknown until then). */
+    __publicField(this, "earlyErrors", []);
+    /** Crash reports left by earlier launches, sent once a config says error tracking is on. */
+    __publicField(this, "storedCrashes", []);
+    /** This launch's crash reports (normally one: the app ends right after). */
+    __publicField(this, "launchCrashes", []);
+    __publicField(this, "lastAppState", null);
     __publicField(this, "customListeners", /* @__PURE__ */ new Map());
     __publicField(this, "eventBus", {
       on: (name, cb) => {
@@ -3024,9 +3717,10 @@ var GuidelyClient = class {
       }
     });
     if (!options || !options.projectId) throw new Error("[Guidely] `projectId` (your environment public key, e.g. pk_dev_\u2026) is required.");
+    this.envOption = options.environment || void 0;
     this.options = {
       ...options,
-      environment: options.environment ?? (options.projectId.startsWith("pk_prod") ? "production" : options.projectId.startsWith("pk_stag") ? "staging" : "development"),
+      environment: options.environment || environmentFromKey(options.projectId),
       apiUrl: options.apiUrl ?? DEFAULT_API_URL,
       analytics: options.analytics ?? true,
       configRefreshMs: options.configRefreshMs ?? 5 * 60 * 1e3,
@@ -3042,6 +3736,7 @@ var GuidelyClient = class {
     if (options.user) this.user = { ...options.user };
     this.locale = options.locale ? normalizeLocale(options.locale) || null : null;
     this.flags = this.createFlags(options.flags);
+    this.installErrorMonitoring();
   }
   createFlags(opts) {
     const base = { sdkKey: this.options.projectId, apiUrl: this.options.apiUrl, fetch: this.options.fetch, sdk: { name: SDK_NAME, version: SDK_VERSION } };
@@ -3089,7 +3784,7 @@ var GuidelyClient = class {
   async bootstrap() {
     const key = this.options.projectId;
     try {
-      await this.store.hydrate([KEYS.anon, KEYS.seen, KEYS.session, KEYS.config(key), KEYS.etag(key), KEYS.state(key), KEYS.user(key), KEYS.queue(key), KEYS.outbox(key), KEYS.conversations(key), appVersionKey(key), LAUNCHER_PLACEMENT_KEY]);
+      await this.store.hydrate([KEYS.anon, KEYS.seen, KEYS.session, KEYS.config(key), KEYS.etag(key), KEYS.state(key), KEYS.user(key), KEYS.queue(key), KEYS.outbox(key), KEYS.conversations(key), appVersionKey(key), LAUNCHER_PLACEMENT_KEY, crashKey(key), earlyCrashKey(key)]);
       if (this.destroyed) return;
       this.anonymousId = this.store.get(KEYS.anon) || "";
       this.hadIdentity = !!this.anonymousId;
@@ -3102,7 +3797,9 @@ var GuidelyClient = class {
       this.state = { ...emptyState(), ...readJson(this.store, KEYS.state(key), {}) };
       this.user = this.options.user ? { ...this.options.user } : readJson(this.store, KEYS.user(key), null);
       const saved = readJson(this.store, KEYS.session, null);
-      this.session = saved?.id && !this.sessionExpired(Date.parse(saved.lastActiveAt)) ? saved : newSession();
+      this.loadStoredCrashes();
+      const crashed = !!saved?.id && this.storedCrashes.some((c) => c.sessionId === saved.id);
+      this.session = saved?.id && !crashed && !this.sessionExpired(Date.parse(saved.lastActiveAt)) ? saved : newSession();
       this.persistSession();
       this.lastAudiences = new Set(this.state.audienceIds);
       this.syncFlagAttributes();
@@ -3121,9 +3818,10 @@ var GuidelyClient = class {
       this.hydrated = true;
       const cached = readJson(this.store, KEYS.config(key), null);
       this.etag = this.store.get(KEYS.etag(key));
-      if (cached && Array.isArray(cached.guides)) this.config = forPlatform(cached, this.bridge.device.platform);
+      if (cached && Array.isArray(cached.guides)) this.useConfig(forPlatform(cached, this.bridge.device.platform));
       this.syncMessenger();
       this.pending.splice(0).forEach((fn) => fn());
+      this.drainErrors();
       const before = this.config?.configVersion;
       const fresh = this.fetchConfig();
       if (!this.config) await fresh;
@@ -3148,22 +3846,33 @@ var GuidelyClient = class {
     if (this.hydrated) fn();
     else this.pending.push(fn);
   }
+  /** Environment guides and flags target: the `environment` option, else the one the loaded config names, else a guess from the key. */
+  get environment() {
+    return this.envOption ?? this.config?.environment ?? this.options.environment;
+  }
+  useConfig(config) {
+    const env = this.environment;
+    this.config = config;
+    if (this.environment !== env) this.syncFlagAttributes();
+  }
   async fetchConfig() {
     try {
       const res = await this.api.get("/config", { etag: this.etag, params: { platform: this.bridge.device.platform } });
       this.configFetchedAt = Date.now();
       if (res.status === 304) return true;
       if (res.ok && res.data && Array.isArray(res.data.guides)) {
-        this.config = forPlatform(res.data, this.bridge.device.platform);
+        const config = forPlatform(res.data, this.bridge.device.platform);
+        this.useConfig(config);
         this.etag = res.etag;
         writeJson(this.store, KEYS.config(this.options.projectId), res.data);
         if (res.etag) this.store.set(KEYS.etag(this.options.projectId), res.etag);
         else this.store.remove(KEYS.etag(this.options.projectId));
         this.syncMessenger();
         if (this.hydrated) this.checkLaunch();
-        this.emitter.emit("config", this.config);
+        this.drainErrors();
+        this.emitter.emit("config", config);
         this.syncReplay();
-        this.log("config loaded", this.config.configVersion, `${this.config.guides.length} guides`);
+        this.log("config loaded", config.configVersion, `${config.guides.length} guides`);
         return true;
       }
       this.reportError(new Error(`[Guidely] config request failed (${res.status})${this.config ? "; using cached config" : ""}`));
@@ -3204,7 +3913,12 @@ var GuidelyClient = class {
   }
   /** Called by the provider with React Native `AppState` changes. */
   setAppState(state) {
-    if (this.destroyed || !this.hydrated) return;
+    if (this.destroyed) return;
+    if (state !== this.lastAppState) {
+      this.lastAppState = state;
+      this.autoBreadcrumb("appLifecycle", { type: "navigation", category: "app.lifecycle", message: state, data: { state } });
+    }
+    if (!this.hydrated) return;
     if (state === "background") {
       const wasForeground = this.backgroundedAt === null;
       this.backgroundedAt = Date.now();
@@ -3389,8 +4103,13 @@ var GuidelyClient = class {
   setConsent(consent) {
     this.consent = consent;
     this.whenHydrated(() => {
-      if (consent === "denied") this.queue?.clear();
-      else if (consent === "granted") void this.queue?.flush();
+      if (consent === "denied") {
+        this.queue?.clear();
+        this.earlyErrors = [];
+        this.storedCrashes = [];
+        this.launchCrashes = [];
+        void this.writeCrashes();
+      } else if (consent === "granted") void this.queue?.flush();
       this.syncReplay();
     });
   }
@@ -3414,6 +4133,7 @@ var GuidelyClient = class {
       accountId: this.user?.account?.id || null,
       sessionId: this.session.id,
       url: this.collectUrls() && this.screenName ? this.currentUrl() : void 0,
+      ...this.appInfo().appVersion ? { appVersion: this.appInfo().appVersion } : {},
       ...extra
     };
     if (extra.properties) event.properties = sanitizeProperties(extra.properties);
@@ -3453,6 +4173,7 @@ var GuidelyClient = class {
     this.whenHydrated(() => {
       const changed = name !== this.screenName;
       if (changed) {
+        this.autoBreadcrumb("navigation", { type: "navigation", category: "navigation", data: { ...this.screenName ? { from: this.screenName } : {}, to: name } });
         this.leaveScreen();
         this.flushHeatmap();
       }
@@ -3616,7 +4337,11 @@ var GuidelyClient = class {
   }
   /** True when taps are worth observing (clicks, rage taps or heatmaps are on); the provider skips resolving views otherwise. */
   isTapCaptureOn() {
-    return this.hydrated && (this.autocaptureOn("clicks") || this.autocaptureOn("rageClicks") || this.autocaptureOn("heatmaps"));
+    return this.hydrated && (this.autocaptureOn("clicks") || this.autocaptureOn("rageClicks") || this.autocaptureOn("heatmaps") || this.tapBreadcrumbsOn());
+  }
+  /** Taps become `ui.click` breadcrumbs while errors can be reported (even with click autocapture off). */
+  tapBreadcrumbsOn() {
+    return this.crumbsOn("taps") && this.errorTrackingAllowed();
   }
   /**
    * Records a tap observed by the provider: `click` for an interactive element, `rage_click` for
@@ -3626,8 +4351,8 @@ var GuidelyClient = class {
   recordTap(tap) {
     try {
       if (!this.hydrated || this.destroyed || !Number.isFinite(tap.x) || !Number.isFinite(tap.y)) return;
-      const on = { clicks: this.autocaptureOn("clicks"), rage: this.autocaptureOn("rageClicks"), heat: this.autocaptureOn("heatmaps") };
-      if (!on.clicks && !on.rage && !on.heat) return;
+      const on = { clicks: this.autocaptureOn("clicks"), rage: this.autocaptureOn("rageClicks"), heat: this.autocaptureOn("heatmaps"), crumb: this.tapBreadcrumbsOn() };
+      if (!on.clicks && !on.rage && !on.heat && !on.crumb) return;
       const t = tap.t ?? Date.now();
       const url = this.screenName ? this.currentUrl() : "";
       this.tapChain = this.tapChain.then(() => this.processTap(tap, t, url, on)).catch((err) => this.reportError(err));
@@ -3644,6 +4369,8 @@ var GuidelyClient = class {
       rect = target.rect;
     }
     if (this.destroyed) return;
+    if (on.crumb && el) this.autoBreadcrumb("taps", { timestamp: t / 1e3, type: "user", category: "ui.click", message: el.selector, data: { selector: el.selector } });
+    if (!on.clicks && !on.rage && !on.heat) return;
     const platform = this.bridge.device.platform;
     const maskAll = !!this.config?.settings?.replay?.maskAllText || !!this.options.sessionReplay?.maskAllText;
     const eventUrl = this.collectUrls() && url ? url : void 0;
@@ -3742,6 +4469,277 @@ var GuidelyClient = class {
     }
   }
   // ---------------------------------------------------------------------------
+  // Error monitoring (docs/error-monitoring/sdks.md)
+  // ---------------------------------------------------------------------------
+  /**
+   * Reports a caught error as an `exception` event (`handled: true`), grouped into an issue on the
+   * Errors page. The second argument takes Sentry's capture context (`tags`, `extra`, `level`,
+   * `fingerprint`, `contexts`, `user`); any other key is attached to the occurrence as a property.
+   * Needs the project's error tracking on (plus analytics and consent); `errors.captureErrors: false`
+   * does not stop it. Returns the event id (empty when nothing is sent).
+   */
+  captureException(error, hint) {
+    if (this.destroyed) return "";
+    try {
+      const { ctx, properties } = splitHint(hint);
+      const props = exceptionFromValue(error, "manual", true);
+      return this.deliverError(this.prepareCapture(error, props, properties, ctx, "generic", ctx.level ?? "error", false));
+    } catch (err) {
+      this.reportError(err);
+      return "";
+    }
+  }
+  /** Reports a message (default level `info`) as its own issue, grouped by the message. */
+  captureMessage(message, level = "info", hint) {
+    if (this.destroyed) return "";
+    try {
+      const { ctx } = splitHint(hint);
+      const props = { type: "Message", message: String(message).slice(0, 1e3), frames: [], source: "message", handled: true };
+      return this.deliverError(this.prepareCapture(void 0, props, {}, ctx, "message", ctx.level ?? level, false));
+    } catch (err) {
+      this.reportError(err);
+      return "";
+    }
+  }
+  /** Adds a breadcrumb (sent with the next errors; the last 100 are kept). */
+  addBreadcrumb(crumb, hint) {
+    if (!this.destroyed) this.errorScope.addBreadcrumb(crumb, hint);
+  }
+  /** Tags every later error (searchable on the issue page); `null` removes the tag. */
+  setTag(key, value) {
+    if (value === null || value === void 0) delete this.errorScope.tags[key];
+    else this.errorScope.tags[key] = String(value);
+  }
+  setTags(tags) {
+    for (const [k, v] of Object.entries(tags ?? {})) this.setTag(k, v);
+  }
+  /** Arbitrary data attached to every later error. */
+  setExtra(key, value) {
+    if (value === void 0) delete this.errorScope.extra[key];
+    else this.errorScope.extra[key] = value;
+  }
+  setExtras(extras) {
+    for (const [k, v] of Object.entries(extras ?? {})) this.setExtra(k, v);
+  }
+  /** A named context (`setContext("cart", { items: 3 })`) on every later error; `null` removes it. */
+  setContext(name, context) {
+    if (context && typeof context === "object") this.errorScope.contexts[name] = context;
+    else delete this.errorScope.contexts[name];
+  }
+  /**
+   * Sentry's `setUser`: identifies the user by `id` (like `identify`) and keeps `email` / `username`
+   * on their errors. `null` forgets the user (`reset()`).
+   */
+  setUser(user) {
+    if (!user) {
+      this.errorScope.user = {};
+      return this.reset();
+    }
+    const { id, email, username, ...traits } = user;
+    this.errorScope.user = { ...email ? { email: String(email) } : {}, ...username ? { username: String(username) } : {} };
+    if (id !== void 0 && id !== null && String(id)) void this.identify(String(id), { ...traits, ...email ? { email } : {}, ...username ? { username } : {} });
+  }
+  crumbsOn(kind) {
+    const b = this.options.errors?.breadcrumbs;
+    return b !== false && !(b && b[kind] === false);
+  }
+  autoBreadcrumb(kind, crumb, hint) {
+    if (!this.destroyed && this.crumbsOn(kind)) this.errorScope.addBreadcrumb(crumb, hint);
+  }
+  /** Errors may be captured: analytics on, consent not denied and, once a config says, the project's error tracking on. */
+  errorsWanted() {
+    if (this.destroyed || !this.options.analytics || this.consent === "denied") return false;
+    const s = this.config?.settings;
+    return !this.config || (s?.analyticsEnabled ?? true) && !!s?.errorTracking?.enabled;
+  }
+  /** Errors may be queued now (a config is known and allows them). */
+  errorTrackingAllowed() {
+    return !!this.config && this.errorsWanted();
+  }
+  /** Requests to the Guidely deployment never become breadcrumbs. */
+  isGuidelyUrl(url) {
+    const base = this.options.apiUrl.replace(/\/+$/, "");
+    return !!base && (url === base || url.startsWith(`${base}/`));
+  }
+  release() {
+    return this.options.release ?? this.appInfo().appVersion;
+  }
+  /** Builds and filters one error (`null` when dropped). */
+  prepareCapture(error, props, properties, ctx, mechanism, level, fatal) {
+    if (!this.errorsWanted()) return null;
+    const info = this.appInfo();
+    const release = this.release();
+    const detail = buildDetail({
+      error,
+      props,
+      mechanism,
+      scope: this.errorScope,
+      ctx,
+      level,
+      contexts: reactNativeContexts(this.bridge.device, { ...info, inForeground: this.backgroundedAt === null }, this.bridge.globals),
+      release,
+      dist: this.options.errors?.dist ?? info.build,
+      environment: this.environment,
+      userId: this.user?.id || null,
+      sdk: { name: SDK_NAME, version: SDK_VERSION }
+    });
+    return prepareError(props, properties, detail, this.options.errors, fatal, release);
+  }
+  /** Queues a prepared error, or holds it until storage and a config are loaded. Returns its event id ("" when dropped). */
+  deliverError(p) {
+    if (!p) return "";
+    if (!this.hydrated || !this.config) {
+      if (this.earlyErrors.length >= 10) return "";
+      this.earlyErrors.push(p);
+      return p.eventId;
+    }
+    return this.sendError(p) ? p.eventId : "";
+  }
+  sendError(p) {
+    if (!this.errorTrackingAllowed()) return false;
+    if (!p.fatal && !this.exceptionThrottle.allow(p.properties)) return false;
+    const count = this.session.exceptions ?? 0;
+    if (!p.fatal && count >= MAX_SESSION_EXCEPTIONS) return false;
+    const event = this.enqueue("exception", { eventId: p.eventId, occurredAt: p.occurredAt, properties: p.properties, ...p.detail ? { detail: p.detail } : {} });
+    if (!event) return false;
+    this.session.exceptions = count + 1;
+    this.persistSession();
+    return true;
+  }
+  /** Sends what waited for storage and a config: earlier launches' crash reports, then early errors. */
+  drainErrors() {
+    if (!this.hydrated || !this.config || this.destroyed) return;
+    const stored = this.storedCrashes.splice(0);
+    if (stored.length) {
+      if (this.errorTrackingAllowed()) {
+        for (const c of stored) this.queue?.enqueue({ ...c, anonymousId: c.anonymousId || this.anonymousId, sessionId: c.sessionId || this.session.id });
+      }
+      void this.writeCrashes();
+    }
+    this.earlyErrors.splice(0).forEach((p) => this.sendError(p));
+  }
+  loadStoredCrashes() {
+    const key = this.options.projectId;
+    const valid = (c) => !!c && typeof c === "object" && typeof c.eventId === "string" && c.name === "exception";
+    const read2 = (k) => {
+      const v = readJson(this.store, k, []);
+      return Array.isArray(v) ? v.filter(valid) : [];
+    };
+    const seen = /* @__PURE__ */ new Set();
+    this.storedCrashes = [...read2(crashKey(key)), ...read2(earlyCrashKey(key))].filter((c) => !seen.has(c.eventId) && !!seen.add(c.eventId)).slice(-MAX_STORED_CRASHES);
+    this.store.remove(earlyCrashKey(key));
+    if (this.storedCrashes.length) void this.writeCrashes();
+  }
+  /**
+   * Writes the unsent crash reports to storage, directly (not behind other pending writes) so the
+   * write starts before the app ends. Resolves when the storage has it.
+   */
+  writeCrashes() {
+    const storage = this.options.storage;
+    const key = this.options.projectId;
+    const direct = (op) => {
+      try {
+        return Promise.resolve(op()).catch((err) => this.log("crash report storage error", err));
+      } catch (err) {
+        this.log("crash report storage error", err);
+        return Promise.resolve();
+      }
+    };
+    if (!this.hydrated) {
+      const json2 = JSON.stringify(this.launchCrashes.slice(-MAX_STORED_CRASHES));
+      return storage ? direct(() => storage.setItem(earlyCrashKey(key), json2)) : Promise.resolve();
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const all = [...this.storedCrashes, ...this.launchCrashes].filter((c) => !seen.has(c.eventId) && !!seen.add(c.eventId)).slice(-MAX_STORED_CRASHES);
+    if (!all.length) {
+      this.store.remove(crashKey(key));
+      return storage ? direct(() => storage.removeItem(crashKey(key))) : Promise.resolve();
+    }
+    const json = JSON.stringify(all);
+    this.store.set(crashKey(key), json);
+    return storage ? direct(() => storage.setItem(crashKey(key), json)) : Promise.resolve();
+  }
+  /**
+   * A fatal JS error: React Native ends a release app right after the global handler, so the report
+   * is written to storage at once (and sent on the next launch), and sent now as well when the
+   * network allows. The promise tells the handler when React Native's own handler may run.
+   */
+  saveCrash(p) {
+    if (!this.errorsWanted()) return void 0;
+    const info = this.appInfo();
+    const event = {
+      eventId: p.eventId,
+      name: "exception",
+      occurredAt: p.occurredAt,
+      anonymousId: this.anonymousId,
+      userId: this.user?.id || null,
+      accountId: this.user?.account?.id || null,
+      ...this.hydrated ? { sessionId: this.session.id } : {},
+      ...this.collectUrls() && this.screenName ? { url: this.currentUrl() } : {},
+      ...info.appVersion ? { appVersion: info.appVersion } : {},
+      properties: sanitizeProperties(p.properties),
+      ...p.detail ? { detail: p.detail } : {}
+    };
+    this.launchCrashes.push(event);
+    const written = this.writeCrashes();
+    if (!this.hydrated || !this.config || !this.sendError(p)) return written;
+    const sent = this.queue?.flush() ?? Promise.resolve();
+    return Promise.all([written, sent]).then(async () => {
+      if (this.queue?.peek().some((e) => e.eventId === event.eventId)) return;
+      this.launchCrashes = this.launchCrashes.filter((c) => c.eventId !== event.eventId);
+      await this.writeCrashes();
+    });
+  }
+  /** An uncaught JS error from `ErrorUtils` (fatal ones end the app in release builds). */
+  captureGlobalError(error, fatal) {
+    try {
+      const props = exceptionFromValue(error, "onerror", false);
+      if (props.message.startsWith("[Guidely]")) return void 0;
+      const p = this.prepareCapture(error, props, {}, {}, "onerror", fatal ? "fatal" : "error", fatal);
+      if (!p) return void 0;
+      if (fatal) return this.saveCrash(p);
+      this.deliverError(p);
+    } catch (err) {
+      this.log("error capture failed", err);
+    }
+    return void 0;
+  }
+  captureRejection(reason) {
+    try {
+      const props = exceptionFromValue(reason, "unhandledrejection", false, "UnhandledRejection");
+      if (props.message.startsWith("[Guidely]")) return;
+      this.deliverError(this.prepareCapture(reason, props, {}, {}, "unhandledrejection", "error", false));
+    } catch (err) {
+      this.log("error capture failed", err);
+    }
+  }
+  /**
+   * Guide breadcrumbs, and (with the bridge's JS globals) the global error handler, promise
+   * rejection tracking and console / network breadcrumbs. Undone by `destroy()`.
+   */
+  installErrorMonitoring() {
+    const guideCrumb = (message, guide, stepIndex) => this.autoBreadcrumb("guides", { type: "info", category: "guide", message, data: { guideId: guide.id, ...stepIndex !== void 0 ? { stepIndex } : {} } });
+    this.cleanups.push(
+      this.emitter.on("guide:start", (g2) => guideCrumb("Guide shown", g2)),
+      this.emitter.on("guide:step", (s) => guideCrumb("Guide step", s.guide, s.stepIndex)),
+      this.emitter.on("guide:complete", (g2) => guideCrumb("Guide completed", g2)),
+      this.emitter.on("guide:dismiss", (g2) => guideCrumb("Guide dismissed", g2)),
+      this.emitter.on("guide:skip", (g2) => guideCrumb("Guide skipped", g2))
+    );
+    const g = this.bridge.globals;
+    if (!g) return;
+    try {
+      if (this.crumbsOn("console")) this.cleanups.push(instrumentConsole(g.console, (c) => this.autoBreadcrumb("console", c)));
+      if (this.crumbsOn("http")) this.cleanups.push(instrumentHttp(g, (c) => this.autoBreadcrumb("http", c), (url) => this.isGuidelyUrl(url)));
+      if (this.options.errors?.captureErrors !== false) {
+        this.cleanups.push(installGlobalHandler(g, (error, fatal) => this.captureGlobalError(error, fatal)));
+        this.cleanups.push(installRejectionTracking(g, (reason) => this.captureRejection(reason), this.options.errors?.rejectionTracker));
+      }
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
   // Targeting + triggers
   // ---------------------------------------------------------------------------
   /** Builds the targeting context for the current moment. */
@@ -3767,7 +4765,7 @@ var GuidelyClient = class {
       completedChecklists: new Set(keysOf(Object.entries(this.state.checklists).filter(([, p]) => !!p.completedAt).map(([id]) => id))),
       audienceIds: new Set(this.state.audienceIds),
       now: /* @__PURE__ */ new Date(),
-      environment: this.options.environment,
+      environment: this.environment,
       locale: device.locale,
       platform: device.platform,
       screen: this.screenName,
@@ -4588,7 +5586,7 @@ var GuidelyClient = class {
       locale: d.locale,
       appVersion: this.options.appVersion ?? d.appVersion,
       osVersion: d.osVersion,
-      environment: this.options.environment,
+      environment: this.environment,
       ...this.screenName ? { screen: this.screenName, path: this.currentUrl() } : {},
       ...this.user?.traits ?? {},
       id: this.user?.id || this.anonymousId || void 0,
@@ -4713,6 +5711,35 @@ function detectAppVersion(src) {
     return {};
   }
 }
+function detectDeviceModel(src) {
+  try {
+    const expo = src.expoModules?.ExpoDevice ?? src.nativeModules.ExpoDevice;
+    const info = src.nativeModules.RNDeviceInfo;
+    const c = src.platform.constants ?? {};
+    const android = src.platform.OS === "android";
+    const model = text(constant(expo, "modelName")) ?? text(constant(info, "model")) ?? (android ? text(c.Model) : void 0);
+    const manufacturer = text(constant(expo, "manufacturer")) ?? (android ? text(c.Manufacturer) : "Apple");
+    const brand = text(constant(expo, "brand")) ?? text(constant(info, "brand")) ?? (android ? text(c.Brand) : void 0);
+    const isDevice = constant(expo, "isDevice");
+    return {
+      ...model ? { model } : {},
+      ...manufacturer ? { manufacturer } : {},
+      ...brand ? { brand } : {},
+      ...typeof isDevice === "boolean" ? { simulator: !isDevice } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function detectReactNativeVersion(src) {
+  try {
+    const v = src.platform.constants?.reactNativeVersion;
+    if (!v || typeof v.major !== "number") return void 0;
+    return { major: v.major, minor: Number(v.minor) || 0, patch: Number(v.patch) || 0, ...v.prerelease != null ? { prerelease: String(v.prerelease) } : {} };
+  } catch {
+    return void 0;
+  }
+}
 function detectOsVersion(src) {
   try {
     const c = src.platform.constants ?? {};
@@ -4845,7 +5872,7 @@ function measureHost(host) {
     done(null);
   });
 }
-function describe(f, masked, opts, withText) {
+function describe2(f, masked, opts, withText) {
   const props = f.memoizedProps && typeof f.memoizedProps === "object" ? f.memoizedProps : {};
   const host = firstHost(f);
   const el = { selector: idSelector(f) ?? pathSelector(f), tag: componentName(f.type) ?? "View" };
@@ -4890,8 +5917,8 @@ function resolveFiber(target, opts = {}) {
     const element = press ?? role;
     return {
       ignored: false,
-      element: element ? describe(element, masked, opts, true) : null,
-      hit: hitFiber ? describe(hitFiber, masked, opts, componentName(hitFiber.type) === "Text") : null
+      element: element ? describe2(element, masked, opts, true) : null,
+      hit: hitFiber ? describe2(hitFiber, masked, opts, componentName(hitFiber.type) === "Text") : null
     };
   } catch {
     return none;
@@ -5024,7 +6051,7 @@ function parseHtml(html) {
     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) => {
+  const size2 = (attrs, name) => {
     const n = Number(attr(attrs, name));
     return n > 0 ? n : void 0;
   };
@@ -5086,8 +6113,8 @@ function parseHtml(html) {
         }
       } else if (tag === "img" && !closing) {
         const src = attr(attrs, "src");
-        const w = size(attrs, "width");
-        const h = size(attrs, "height");
+        const w = size2(attrs, "width");
+        const h = size2(attrs, "height");
         if (isSafeMediaUrl(src)) pdf.pages.push({ src, alt: attr(attrs, "alt") ?? "", ...w && h ? { width: w, height: h } : {} });
       }
       continue;
@@ -5261,10 +6288,10 @@ function BodyPdf({ block, palette: p, onLink }) {
     ] }) })
   ] });
 }
-function RichText({ html, palette: p, onLink, size = 15 }) {
+function RichText({ html, palette: p, onLink, size: size2 = 15 }) {
   const blocks = useMemo2(() => parseHtml(html), [html]);
   if (!blocks.length) return null;
-  const base = { color: p.text, fontSize: size, lineHeight: Math.round(size * 1.42), fontFamily: p.fontFamily };
+  const base = { color: p.text, fontSize: size2, lineHeight: Math.round(size2 * 1.42), fontFamily: p.fontFamily };
   return /* @__PURE__ */ jsx3(View2, { style: styles2.wrap, children: blocks.map((b, i) => {
     if (b.kind === "image") return /* @__PURE__ */ jsx3(BodyImage, { block: b, palette: p }, i);
     if (b.kind === "video") return /* @__PURE__ */ jsx3(BodyVideo, { block: b, palette: p, onLink }, i);
@@ -5467,17 +6494,17 @@ function useReduceMotion() {
   }, []);
   return on;
 }
-function MessengerLauncher({ store, client, palette: p, style, frame, defaultSide }) {
+function MessengerLauncher({ store, client, palette: p, style, frame: frame2, defaultSide }) {
   const snap = useMessenger(store);
   const reduceMotion = useReduceMotion();
   const [placement, setPlacement] = useState3(() => client.getMessengerLauncherPlacement());
   const pan = useRef2(new Animated.ValueXY()).current;
   const offset = useRef2({ x: 0, y: 0 });
   const dragging = useRef2(false);
-  const live = useRef2({ frame, defaultSide, reduceMotion });
-  live.current = { frame, defaultSide, reduceMotion };
-  const { width, height, size, defaultBottom } = frame;
-  const { top, bottom, left, right } = frame.insets;
+  const live = useRef2({ frame: frame2, defaultSide, reduceMotion });
+  live.current = { frame: frame2, defaultSide, reduceMotion };
+  const { width, height, size: size2, defaultBottom } = frame2;
+  const { top, bottom, left, right } = frame2.insets;
   useLayoutEffect(() => {
     if (dragging.current) return;
     const f = live.current.frame;
@@ -5485,7 +6512,7 @@ function MessengerLauncher({ store, client, palette: p, style, frame, defaultSid
     const at = placement ? placementPoint(f, placement) : anchor;
     offset.current = { x: at.x - anchor.x, y: at.y - anchor.y };
     pan.setValue(offset.current);
-  }, [pan, placement, defaultSide, width, height, size, defaultBottom, top, bottom, left, right]);
+  }, [pan, placement, defaultSide, width, height, size2, defaultBottom, top, bottom, left, right]);
   const responder = useMemo3(() => {
     const moved = (g) => Math.hypot(g.dx, g.dy) > LAUNCHER_DRAG_THRESHOLD;
     const anchor = () => placementPoint(live.current.frame, { side: live.current.defaultSide, fraction: 0 });
@@ -6009,18 +7036,18 @@ import { AccessibilityInfo as AccessibilityInfo2, Animated as Animated2, Easing
 var MARGIN = 12;
 var ARROW_INSET = 18;
 var opposite = { top: "bottom", bottom: "top", left: "right", right: "left" };
-function positionCard(target, size, viewport, insets, placement, offset) {
+function positionCard(target, size2, viewport, insets, placement, offset) {
   const [rawSide, align] = placement.split("-");
   const fits = (side2) => {
     switch (side2) {
       case "bottom":
-        return target.y + target.height + offset + size.height <= viewport.height - insets.bottom - MARGIN;
+        return target.y + target.height + offset + size2.height <= viewport.height - insets.bottom - MARGIN;
       case "top":
-        return target.y - offset - size.height >= insets.top + MARGIN;
+        return target.y - offset - size2.height >= insets.top + MARGIN;
       case "right":
-        return target.x + target.width + offset + size.width <= viewport.width - insets.right - MARGIN;
+        return target.x + target.width + offset + size2.width <= viewport.width - insets.right - MARGIN;
       case "left":
-        return target.x - offset - size.width >= insets.left + MARGIN;
+        return target.x - offset - size2.width >= insets.left + MARGIN;
     }
   };
   const order = rawSide === "auto" ? ["bottom", "top"] : [rawSide, opposite[rawSide], "bottom", "top"];
@@ -6029,17 +7056,17 @@ function positionCard(target, size, viewport, insets, placement, offset) {
   const clamp3 = (v, min, max) => Math.max(min, Math.min(max, v));
   if (side === "top" || side === "bottom") {
     const cx = target.x + target.width / 2;
-    let x2 = align === "start" ? target.x : align === "end" ? target.x + target.width - size.width : cx - size.width / 2;
-    x2 = clamp3(x2, insets.left + MARGIN, Math.max(insets.left + MARGIN, viewport.width - insets.right - MARGIN - size.width));
-    let y2 = side === "bottom" ? target.y + target.height + offset : target.y - offset - size.height;
-    y2 = clamp3(y2, insets.top + MARGIN, Math.max(insets.top + MARGIN, viewport.height - insets.bottom - MARGIN - size.height));
-    return { x: x2, y: y2, side, arrow: clamp3(cx - x2, ARROW_INSET, size.width - ARROW_INSET) };
+    let x2 = align === "start" ? target.x : align === "end" ? target.x + target.width - size2.width : cx - size2.width / 2;
+    x2 = clamp3(x2, insets.left + MARGIN, Math.max(insets.left + MARGIN, viewport.width - insets.right - MARGIN - size2.width));
+    let y2 = side === "bottom" ? target.y + target.height + offset : target.y - offset - size2.height;
+    y2 = clamp3(y2, insets.top + MARGIN, Math.max(insets.top + MARGIN, viewport.height - insets.bottom - MARGIN - size2.height));
+    return { x: x2, y: y2, side, arrow: clamp3(cx - x2, ARROW_INSET, size2.width - ARROW_INSET) };
   }
   const cy = target.y + target.height / 2;
-  let y = align === "start" ? target.y : align === "end" ? target.y + target.height - size.height : cy - size.height / 2;
-  y = clamp3(y, insets.top + MARGIN, Math.max(insets.top + MARGIN, viewport.height - insets.bottom - MARGIN - size.height));
-  const x = side === "right" ? target.x + target.width + offset : target.x - offset - size.width;
-  return { x, y, side, arrow: clamp3(cy - y, ARROW_INSET, size.height - ARROW_INSET) };
+  let y = align === "start" ? target.y : align === "end" ? target.y + target.height - size2.height : cy - size2.height / 2;
+  y = clamp3(y, insets.top + MARGIN, Math.max(insets.top + MARGIN, viewport.height - insets.bottom - MARGIN - size2.height));
+  const x = side === "right" ? target.x + target.width + offset : target.x - offset - size2.width;
+  return { x, y, side, arrow: clamp3(cy - y, ARROW_INSET, size2.height - ARROW_INSET) };
 }
 
 // src/ui/StepCard.tsx
@@ -6193,9 +7220,9 @@ function StepLayer({ view, client, palette: p, geometry }) {
   }
   if (!rect) return null;
   if (step.type === "hotspot") {
-    const size = step.hotspot?.size ?? 14;
+    const size2 = step.hotspot?.size ?? 14;
     return /* @__PURE__ */ jsxs6(View7, { pointerEvents: "box-none", style: StyleSheet7.absoluteFill, children: [
-      /* @__PURE__ */ jsx8(Hotspot, { x: rect.x + rect.width - size / 2, y: rect.y - size / 2, size, pulse: step.hotspot?.pulse ?? true, color: p.primary, onPress: () => client.toggleHotspot(view.guide.id), label: step.title || "Show tip" }),
+      /* @__PURE__ */ jsx8(Hotspot, { x: rect.x + rect.width - size2 / 2, y: rect.y - size2 / 2, size: size2, pulse: step.hotspot?.pulse ?? true, color: p.primary, onPress: () => client.toggleHotspot(view.guide.id), label: step.title || "Show tip" }),
       view.expanded ? /* @__PURE__ */ jsx8(Anchored, { view, client, palette: p, geometry, rect, width: cardWidth }) : null
     ] });
   }
@@ -6242,7 +7269,7 @@ function Arrow({ side, at, color, border }) {
   const place = side === "bottom" ? { top: -half, left: at - half } : side === "top" ? { bottom: -half, left: at - half } : side === "right" ? { left: -half, top: at - half } : { right: -half, top: at - half };
   return /* @__PURE__ */ jsx8(View7, { pointerEvents: "none", style: [styles7.abs, styles7.arrow, place, { backgroundColor: color, borderColor: border }] });
 }
-function Hotspot({ x, y, size, pulse, color, onPress, label }) {
+function Hotspot({ x, y, size: size2, pulse, color, onPress, label }) {
   const scale = useRef3(new Animated2.Value(0)).current;
   const [reduceMotion, setReduceMotion] = useState5(false);
   useEffect5(() => {
@@ -6259,15 +7286,15 @@ function Hotspot({ x, y, size, pulse, color, onPress, label }) {
     loop.start();
     return () => loop.stop();
   }, [pulse, reduceMotion, scale]);
-  return /* @__PURE__ */ jsxs6(Pressable7, { accessibilityRole: "button", accessibilityLabel: label, onPress, hitSlop: 14, style: [styles7.abs, { left: x, top: y, width: size, height: size }], children: [
+  return /* @__PURE__ */ jsxs6(Pressable7, { accessibilityRole: "button", accessibilityLabel: label, onPress, hitSlop: 14, style: [styles7.abs, { left: x, top: y, width: size2, height: size2 }], children: [
     pulse && !reduceMotion ? /* @__PURE__ */ jsx8(
       Animated2.View,
       {
         pointerEvents: "none",
-        style: [styles7.abs, { width: size, height: size, borderRadius: size / 2, backgroundColor: color, opacity: scale.interpolate({ inputRange: [0, 1], outputRange: [0.55, 0] }), transform: [{ scale: scale.interpolate({ inputRange: [0, 1], outputRange: [1, 2.6] }) }] }]
+        style: [styles7.abs, { width: size2, height: size2, borderRadius: size2 / 2, backgroundColor: color, opacity: scale.interpolate({ inputRange: [0, 1], outputRange: [0.55, 0] }), transform: [{ scale: scale.interpolate({ inputRange: [0, 1], outputRange: [1, 2.6] }) }] }]
       }
     ) : null,
-    /* @__PURE__ */ jsx8(View7, { style: { width: size, height: size, borderRadius: size / 2, backgroundColor: color, borderWidth: 2, borderColor: "#ffffff" } })
+    /* @__PURE__ */ jsx8(View7, { style: { width: size2, height: size2, borderRadius: size2 / 2, backgroundColor: color, borderWidth: 2, borderColor: "#ffffff" } })
   ] });
 }
 var styles7 = StyleSheet7.create({
@@ -6888,12 +7915,16 @@ function defaultBridge(appVersion, appBuild) {
       locale: deviceLocale(),
       appVersion: appVersion ?? detected.appVersion,
       appBuild: appBuild ?? detected.appBuild,
-      osVersion: detectOsVersion(sources)
+      osVersion: detectOsVersion(sources),
+      ...detectDeviceModel(sources),
+      reactNativeVersion: detectReactNativeVersion(sources)
     },
     openExternal: (url) => void Linking.openURL(url).catch(() => {
     }),
     windowSize: () => Dimensions.get("window"),
-    capturer: nativeCapturer()
+    capturer: nativeCapturer(),
+    // ErrorUtils, HermesInternal, console, fetch, XMLHttpRequest: crash capture and breadcrumbs.
+    globals: globalThis
   };
 }
 function nativeCapturer() {
@@ -6901,6 +7932,20 @@ function nativeCapturer() {
   if (!mod || typeof mod.capture !== "function") return void 0;
   return (options) => mod.capture(options);
 }
+function latestErrorOptions(initial, latest) {
+  if (!initial) return void 0;
+  return {
+    ...initial,
+    beforeSend: (event) => {
+      const hook = latest()?.beforeSend;
+      return hook ? hook(event) : event;
+    },
+    beforeBreadcrumb: (crumb, hint) => {
+      const hook = latest()?.beforeBreadcrumb;
+      return hook ? hook(crumb, hint) : crumb;
+    }
+  };
+}
 function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPayload, flagAttributes, ...options }) {
   const [client, setClient] = useState8(null);
   const optionsRef = useRef7(options);
@@ -6931,7 +7976,8 @@ function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPay
           user: userRef.current?.id ? userRef.current : void 0,
           flags: latest.flags === false ? false : { ...latest.flags ?? {}, payload: payloadRef.current ?? void 0, attributes: appAttributesRef.current },
           onNavigate: (url) => optionsRef.current.onNavigate?.(url),
-          onError: (err) => optionsRef.current.onError?.(err)
+          onError: (err) => optionsRef.current.onError?.(err),
+          errors: latestErrorOptions(latest.errors, () => optionsRef.current.errors)
         },
         defaultBridge(latest.appVersion, latest.appBuild)
       );
@@ -6994,6 +8040,8 @@ var NOOP_RESULTS = {
   isRecordingTouches: false,
   getSessionId: "",
   getScreen: "",
+  captureException: "",
+  captureMessage: "",
   on: () => {
   },
   subscribeUi: () => () => {
@@ -7112,6 +8160,7 @@ function useActiveGuide() {
 }
 export {
   DEFAULT_API_URL,
+  FATAL_FLUSH_MS,
   Feature,
   FeatureFlag,
   FeatureValue,
@@ -7136,11 +8185,15 @@ export {
   createFlagsClient3 as createFlagsClient,
   createSseParser,
   detectAppVersion,
+  detectDeviceModel,
   detectOsVersion,
+  detectReactNativeVersion,
   guidelyScreenLayout,
   htmlToText,
   noopClient,
+  normalizeBundleFile,
   parseHtml,
+  parseReactNativeStack,
   positionCard,
   targetIdsFor,
   useActiveGuide,