@lucida-analytics/react-native 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1765 @@
+// src/client.ts
+import { Core, flagEventProps, interventionHub, offlineTransport } from "@lucida-analytics/sdk-core";
+
+// src/adapters.ts
+var PERSISTED_KEYS = [
+  "lc_identity",
+  "lc_session",
+  "lc_props",
+  "lc_groups",
+  "lc_consent",
+  "lc_flags",
+  "lc_offline",
+  "lc_app_version",
+  "lc_guide_seen",
+  "lc_person_identified"
+];
+function asyncStorageAdapter(as) {
+  const mem = /* @__PURE__ */ new Map();
+  const ready = as.multiGet(PERSISTED_KEYS).then(
+    (rows) => {
+      for (const [k, v] of rows) if (v !== null) mem.set(k, v);
+    },
+    () => void 0
+    // unreadable storage: start empty rather than fail init
+  );
+  const swallow = (p) => void p.catch(() => void 0);
+  return {
+    ready,
+    storage: {
+      get: (k) => mem.get(k) ?? null,
+      set(k, v) {
+        mem.set(k, v);
+        swallow(as.setItem(k, v));
+      },
+      remove(k) {
+        mem.delete(k);
+        swallow(as.removeItem(k));
+      }
+    }
+  };
+}
+function memoryStorage() {
+  const m = /* @__PURE__ */ new Map();
+  return { get: (k) => m.get(k) ?? null, set: (k, v) => void m.set(k, v), remove: (k) => void m.delete(k) };
+}
+function fetchTransport(fetchImpl, timeoutMs = 0) {
+  return {
+    async send(url, body) {
+      const ctl = timeoutMs > 0 && typeof AbortController !== "undefined" ? new AbortController() : void 0;
+      const timer = ctl ? setTimeout(() => ctl.abort(), timeoutMs) : void 0;
+      try {
+        const r = await fetchImpl(url, {
+          method: "POST",
+          body,
+          headers: { "Content-Type": "text/plain;charset=UTF-8" },
+          ...ctl ? { signal: ctl.signal } : {}
+        });
+        return { status: r.status };
+      } catch {
+        return { status: 0 };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function splitBatches(inner, max) {
+  return {
+    async send(url, body, opts) {
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        return inner.send(url, body, opts);
+      }
+      const batch = parsed.batch;
+      if (!Array.isArray(batch) || batch.length <= max) return inner.send(url, body, opts);
+      for (let i = 0; i < batch.length; i += max) {
+        const r = await inner.send(url, JSON.stringify({ ...parsed, batch: batch.slice(i, i + max) }), opts);
+        if (r.status < 200 || r.status >= 300) return r;
+      }
+      return { status: 200 };
+    }
+  };
+}
+function appLifecycle(app, h) {
+  let fg = app.currentState === "active";
+  const sub = app.addEventListener("change", (s) => {
+    if (s === "active" && !fg) h.onForeground();
+    else if (s !== "active" && fg) h.onBackground();
+    fg = s === "active";
+  });
+  return () => sub.remove();
+}
+function withTimeout(inner, ms) {
+  if (ms <= 0) return inner;
+  return {
+    send: (url, body, opts) => new Promise((resolve) => {
+      const timer = setTimeout(() => resolve({ status: 0 }), ms);
+      inner.send(url, body, opts).then(
+        (r) => (clearTimeout(timer), resolve(r)),
+        () => (clearTimeout(timer), resolve({ status: 0 }))
+      );
+    })
+  };
+}
+function encryptedStorage(inner, cipher, keys) {
+  const enc = new Set(keys);
+  return {
+    get: (k) => {
+      const v = inner.get(k);
+      return v !== null && enc.has(k) ? cipher.decrypt(v) : v;
+    },
+    set: (k, v) => inner.set(k, enc.has(k) ? cipher.encrypt(v) : v),
+    remove: (k) => inner.remove(k)
+  };
+}
+
+// src/autocapture.ts
+function createAutocapture(core, config, now = Date.now) {
+  const taps = [];
+  const rc = { enabled: true, minTaps: 3, windowMs: 1e3, radius: 30, ...config.rageTap };
+  function emit(type, chain) {
+    if (!config.enabled || chain.some((e) => e.noCapture)) return void 0;
+    const ignore = new Set(config.ignoreLabels ?? []);
+    const allow = new Set(config.propsAllowList ?? []);
+    const kept = chain.filter((e) => !ignore.has(e.name) && !(e.label !== void 0 && ignore.has(e.label))).slice(0, config.maxElements ?? 10);
+    if (!kept.length) return void 0;
+    const elements = kept.map((el) => {
+      const o = { tag_name: el.name };
+      if (!el.isInput && el.label) o.text = el.label.slice(0, 255);
+      for (const [k, v] of Object.entries(el.props ?? {})) if (allow.has(k)) o[`attr__${k}`] = v;
+      return o;
+    });
+    const text = elements.find((e) => e.text !== void 0)?.text ?? "";
+    core.capture("$autocapture", { $event_type: type, $elements: elements, $el_text: text });
+    return elements[0];
+  }
+  return {
+    config,
+    tap(chain, x, y) {
+      const top = emit("touch", chain);
+      if (!top || !rc.enabled) return;
+      const t = now();
+      taps.push({ t, x, y });
+      while (taps.length && t - taps[0].t > rc.windowMs) taps.shift();
+      const near = taps.filter((p) => Math.hypot(p.x - x, p.y - y) <= rc.radius).length;
+      if (near >= rc.minTaps) {
+        taps.length = 0;
+        core.capture("$rageclick", { $event_type: "touch", $tap_count: near, $elements: [top] });
+      }
+    },
+    change(chain) {
+      emit("change", chain);
+    }
+  };
+}
+function touchHandler(ac) {
+  return (e) => {
+    if (!ac.config.enabled) return;
+    const chain = chainFromFiber(e._targetInst, ac.config);
+    if (chain.length) ac.tap(chain, e.nativeEvent?.pageX ?? 0, e.nativeEvent?.pageY ?? 0);
+  };
+}
+var INPUT_NAMES = /^(TextInput|RCTSinglelineTextInputView|RCTMultilineTextInputView|AndroidTextInput)$/;
+function nameOf(f) {
+  const t = f.type;
+  if (typeof t === "string") return t;
+  return t?.displayName ?? t?.name ?? void 0;
+}
+function chainFromFiber(start, cfg) {
+  const noCapture = cfg.noCaptureProp ?? "lucidaNoCapture";
+  const labelProp = cfg.customLabelProp ?? "testID";
+  const out = [];
+  for (let f = start; f; f = f.return) {
+    const p = f.memoizedProps ?? {};
+    const name = nameOf(f);
+    if (!name) continue;
+    const input = INPUT_NAMES.test(name);
+    const label = typeof p.accessibilityLabel === "string" ? p.accessibilityLabel : typeof p[labelProp] === "string" ? p[labelProp] : void 0;
+    const flagged = p[noCapture] === true;
+    if (!input && label === void 0 && !flagged) continue;
+    const props = {};
+    for (const [k, v] of Object.entries(p)) if (typeof v === "string" && k !== "children") props[k] = v;
+    out.push({ name, label, noCapture: flagged, isInput: input, props });
+  }
+  return out;
+}
+
+// src/install.ts
+var CLICK_IDS = ["gclid", "gbraid", "wbraid", "fbclid", "ttclid", "msclkid"];
+var UTM = ["source", "medium", "campaign", "term", "content"];
+var ASA_URL = "https://api-adservices.apple.com/api/v1/";
+function installReferrerProps(raw, clickTs, beginTs) {
+  const q = /* @__PURE__ */ new Map();
+  for (const part of raw.split("&")) {
+    if (!part) continue;
+    const i = part.indexOf("=");
+    const k = i < 0 ? part : part.slice(0, i);
+    let v = i < 0 ? "" : part.slice(i + 1);
+    try {
+      v = decodeURIComponent(v.replace(/\+/g, " "));
+    } catch {
+    }
+    q.set(k, v);
+  }
+  const out = { $install_store: "google_play", $install_referrer: raw };
+  if (clickTs !== void 0) out.$install_referrer_click_ts = clickTs;
+  if (beginTs !== void 0) out.$install_begin_ts = beginTs;
+  for (const u of UTM) if (q.get(`utm_${u}`)) out[`$utm_${u}`] = q.get(`utm_${u}`);
+  for (const c of CLICK_IDS) if (q.get(c)) out[`$${c}`] = q.get(c);
+  return out;
+}
+function appStoreInstallProps(json) {
+  const out = { $install_store: "app_store" };
+  if (!json || typeof json !== "object") return out;
+  const o = json;
+  out.$install_adservices_attribution = o.attribution === true;
+  if (o.attribution !== true) return out;
+  out.$utm_source = "apple_search_ads";
+  out.$utm_medium = "cpc";
+  const map = [
+    ["campaignId", "$asa_campaign_id", "$utm_campaign"],
+    ["keywordId", "$asa_keyword_id", "$utm_term"],
+    ["adGroupId", "$asa_ad_group_id", "$utm_content"],
+    ["orgId", "$asa_org_id"],
+    ["adId", "$asa_ad_id"],
+    ["conversionType", "$asa_conversion_type"]
+  ];
+  for (const [src, asa, utm] of map) {
+    const v = o[src];
+    if (v === void 0 || v === null || v === "") continue;
+    out[asa] = String(v);
+    if (utm) out[utm] = String(v);
+  }
+  return out;
+}
+async function resolveInstallProps(native, d) {
+  let fallback = {};
+  try {
+    const info = await native();
+    if (!info) return {};
+    fallback = { $install_store: info.platform === "android" ? "google_play" : "app_store" };
+    if (info.platform === "android") {
+      return info.referrer ? installReferrerProps(info.referrer, info.clickTs, info.beginTs) : { $install_store: "google_play" };
+    }
+    if (!info.token) return appStoreInstallProps(null);
+    const attempts = d.attempts ?? 3;
+    for (let i = 0; i < attempts; i++) {
+      const ctl = typeof AbortController === "undefined" ? void 0 : new AbortController();
+      const timer = ctl ? setTimeout(() => ctl.abort(), d.timeoutMs ?? 1e4) : void 0;
+      try {
+        const r = await d.fetch(ASA_URL, { method: "POST", headers: { "Content-Type": "text/plain" }, body: info.token, signal: ctl?.signal ?? null });
+        if (r.ok) return appStoreInstallProps(await r.json());
+        if (r.status !== 404) break;
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+      if (i + 1 < attempts) await new Promise((res) => setTimeout(res, d.retryDelayMs ?? 5e3));
+    }
+    return appStoreInstallProps(null);
+  } catch {
+    return fallback;
+  }
+}
+
+// src/policy.ts
+function runHooks(hooks, event, log) {
+  let cur = event;
+  for (const h of hooks) {
+    try {
+      const next = h(cur);
+      if (next === null || next === void 0) return null;
+      cur = next;
+    } catch (e) {
+      log("beforeSend hook threw, keeping event:", e);
+    }
+  }
+  return cur;
+}
+function sampleHook(rate, random = Math.random) {
+  return (e) => {
+    if (rate >= 1) return e;
+    if (rate <= 0 || random() >= rate) return null;
+    return { ...e, properties: { ...e.properties, $sample_rate: rate } };
+  };
+}
+var KEY = "lc_person_identified";
+var ALWAYS_PROCESSED = /* @__PURE__ */ new Set(["$identify", "$create_alias", "$groupidentify"]);
+var PersonMode = class {
+  constructor(mode, storage) {
+    this.mode = mode;
+    this.storage = storage;
+    this.identified = storage.get(KEY) === "1";
+  }
+  mode;
+  storage;
+  identified;
+  get blocksPersonWrites() {
+    return this.mode === "never";
+  }
+  markIdentified() {
+    if (this.mode !== "identified_only" || this.identified) return;
+    this.identified = true;
+    this.storage.set(KEY, "1");
+  }
+  /** True when an event of this name should carry `$process_person_profile: false`. */
+  personless(event) {
+    if (this.mode === "always") return false;
+    if (this.mode === "never") return !ALWAYS_PROCESSED.has(event);
+    return !this.identified && !ALWAYS_PROCESSED.has(event);
+  }
+  reset() {
+    this.identified = false;
+    this.storage.remove(KEY);
+  }
+};
+function applyPolicy(person, o, e) {
+  const writes = !!(e.$set || e.$set_once || e.$unset);
+  if (writes || ALWAYS_PROCESSED.has(e.event)) person.markIdentified();
+  let out = e;
+  if (person.blocksPersonWrites && writes) {
+    o.log("personProfiles=never: ignoring $set/$set_once on", e.event);
+    const { $set: _s, $set_once: _o, $unset: _u, ...rest } = e;
+    out = rest;
+  }
+  const extra = {};
+  if (person.personless(e.event)) extra.$process_person_profile = false;
+  if (o.disableGeoip) extra.$geoip_disable = true;
+  if (Object.keys(extra).length) out = { ...out, properties: { ...out.properties, ...extra } };
+  return o.beforeSend?.length ? runHooks(o.beforeSend, out, o.log) : out;
+}
+function installPolicy(core, o) {
+  const person = new PersonMode(o.personProfiles ?? "always", core.storage);
+  core.setFilter((e) => applyPolicy(person, o, e));
+  return person;
+}
+
+// src/host-headers.ts
+function hostMatches(hosts, host) {
+  return hosts.some((h) => {
+    const x = h.toLowerCase();
+    return x.startsWith(".") ? host.endsWith(x) : host === x;
+  });
+}
+var hostOf = (url) => /^[a-z][a-z0-9+.-]*:\/\/([^/:?#]+)/i.exec(url)?.[1]?.toLowerCase();
+function tracingHeaders(hosts, apiHost, consent, ids) {
+  const api = hostOf(apiHost);
+  return (url, baggage) => {
+    const host = hostOf(url);
+    if (!host || !hosts.length || host === api || !hostMatches(hosts, host) || !consent()) return {};
+    const i = ids();
+    return { "X-Lucida-Distinct-Id": i.distinctId, "X-Lucida-Session-Id": i.sessionId, baggage: withBaggage(baggage, i.sessionId) };
+  };
+}
+function withBaggage(existing, sessionId) {
+  const kept = (existing ?? "").split(",").map((s) => s.trim()).filter((s) => s && !s.startsWith("lucida.session_id="));
+  return [...kept, `lucida.session_id=${sessionId}`].join(",");
+}
+function tracedFetch(fetchImpl, headersFor) {
+  return ((input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const headers = new Headers(init?.headers ?? (typeof input === "object" && "headers" in input ? input.headers : void 0));
+    const extra = headersFor(url, headers.get("baggage"));
+    if (!Object.keys(extra).length) return fetchImpl(input, init);
+    for (const [k, v] of Object.entries(extra)) headers.set(k, v);
+    return fetchImpl(input, { ...init, headers });
+  });
+}
+
+// src/flags.ts
+import { FlagFreshness, evaluateAll, flagResult, requiresServer, servable, startFlagSync } from "@lucida-analytics/sdk-core";
+var CACHE_KEY = "lc_flags";
+var norm = (v) => typeof v === "object" ? v.value ?? v.variant ?? !!v.enabled : v;
+function createFlags(d) {
+  const { core } = d;
+  let values = {};
+  let payloads = {};
+  let reasons = {};
+  const fresh = new FlagFreshness(d.options?.cacheTtlMs);
+  let requestId;
+  let loaded = false;
+  let seq = 0;
+  const called = /* @__PURE__ */ new Set();
+  const exposed = /* @__PURE__ */ new Set();
+  let calledSession = "";
+  const subs = /* @__PURE__ */ new Set();
+  let overrides = {};
+  const merged = () => ({ ...values, ...overrides });
+  const apply = (v, p) => {
+    values = v;
+    payloads = p;
+    loaded = true;
+    for (const s of subs) s(merged());
+  };
+  try {
+    const c = JSON.parse(core.storage.get(CACHE_KEY) ?? "null");
+    if (c) {
+      ({ values, payloads } = c);
+      reasons = Object.fromEntries(Object.keys(values).map((k) => [k, "cached"]));
+      fresh.restore(c);
+    }
+  } catch {
+  }
+  if (d.options?.bootstrap) {
+    values = { ...values, ...d.options.bootstrap.flags };
+    payloads = { ...payloads, ...d.options.bootstrap.payloads };
+    for (const k of Object.keys(d.options.bootstrap.flags ?? {})) reasons[k] = "bootstrap";
+  }
+  let personProps = {};
+  let groupProps = {};
+  const contexts = d.options?.evaluationContexts ?? [];
+  const appContexts = contexts.length ? { app_contexts: contexts } : {};
+  const flagPersonProps = () => ({ ...d.defaultProps, ...personProps });
+  const sendEvents = d.options?.sendFeatureFlagEvent !== false;
+  let localV = {};
+  const evalLocal = () => {
+    if (!d.localFlags?.length) return true;
+    const res = evaluateAll(d.localFlags, {
+      distinct_id: core.distinctId,
+      ...core.groups ? { groups: core.groups } : {},
+      ...Object.keys(groupProps).length ? { group_properties: groupProps } : {},
+      ...appContexts,
+      ...d.localFlagsContext,
+      person_properties: { ...flagPersonProps(), ...d.localFlagsContext?.person_properties }
+    });
+    const v = {};
+    const p = {};
+    let server = false;
+    for (const [k, r] of Object.entries(res)) {
+      if (requiresServer(r)) server = true;
+      else if (servable(r)) {
+        v[k] = r.value;
+        reasons[k] = r.reason;
+        if (r.payload !== void 0) p[k] = r.payload;
+      }
+    }
+    localV = v;
+    apply({ ...values, ...v }, { ...payloads, ...p });
+    return server;
+  };
+  const reload = (force = true) => {
+    const mine = ++seq;
+    if (!evalLocal() || d.disableRemote) return Promise.resolve();
+    if (!force && fresh.fresh(core.distinctId)) return Promise.resolve();
+    return new Promise((resolve) => {
+      d.whenConsented(() => {
+        if (mine !== seq) return resolve();
+        d.fetch(`${d.apiHost}/v1/flags`, {
+          method: "POST",
+          headers: { "Content-Type": "text/plain;charset=UTF-8" },
+          body: JSON.stringify({
+            api_key: d.apiKey,
+            ...core.distinctId ? { distinct_id: core.distinctId } : {},
+            ...core.anonDistinctId ? { anon_distinct_id: core.anonDistinctId } : {},
+            groups: core.groups ?? {},
+            person_properties: flagPersonProps(),
+            ...Object.keys(groupProps).length ? { group_properties: groupProps } : {},
+            ...d.defaultProps?.$app_version ? { app_version: d.defaultProps.$app_version } : {},
+            ...appContexts
+          })
+        }).then((r) => r.ok ? r.json() : Promise.reject(new Error(`status ${r.status}`))).then((j) => {
+          if (mine !== seq || j.quota_limited) return;
+          const v = {};
+          const p = {};
+          for (const [k, x] of Object.entries(j.flags ?? {})) {
+            v[k] = norm(x);
+            if (typeof x === "object" && x.payload !== void 0) p[k] = x.payload;
+            reasons[k] = typeof x === "object" && typeof x.reason === "string" ? x.reason : "remote";
+          }
+          requestId = j.request_id;
+          apply({ ...localV, ...v }, p);
+          core.storage.set(CACHE_KEY, JSON.stringify({ values: v, payloads: p, ...fresh.mark(core.distinctId) }));
+        }).catch(() => void 0).finally(resolve);
+      });
+    });
+  };
+  if (d.options?.preload !== false) {
+    core.onChange((c) => {
+      if (c === "reset") personProps = {};
+      if (c === "identify" || c === "reset" || c === "group") void reload();
+    });
+    void reload(false);
+  }
+  let stopSync;
+  const fs = d.flagStream;
+  if (fs && !d.disableRemote) {
+    const app = d.appState;
+    d.whenConsented(() => {
+      stopSync = startFlagSync({
+        apiHost: d.apiHost,
+        apiKey: d.apiKey,
+        fetch: d.fetch,
+        reload: () => void reload(),
+        ...typeof fs === "object" && fs.pollMs !== void 0 ? { pollMs: fs.pollMs } : {},
+        ...app ? {
+          visibility: {
+            hidden: () => app.currentState !== void 0 && app.currentState !== "active",
+            subscribe: (cb) => {
+              const sub = app.addEventListener("change", cb);
+              return () => sub.remove();
+            }
+          }
+        } : {}
+      });
+    });
+  }
+  return {
+    stop: () => stopSync?.(),
+    get(key) {
+      const v = overrides[key] ?? values[key];
+      if (v === void 0) return void 0;
+      if (key in overrides) return v;
+      const sid = core.sessionId;
+      if (sid !== calledSession) {
+        called.clear();
+        exposed.clear();
+        calledSession = sid;
+      }
+      if (!sendEvents) return v;
+      if (!exposed.has(key)) {
+        exposed.add(key);
+        core.capture("$exposure", {
+          $feature_flag: key,
+          $feature_flag_response: v,
+          ...typeof v === "string" ? { $feature_flag_variant: v } : {},
+          ...requestId ? { $feature_flag_request_id: requestId } : {}
+        });
+      }
+      const dedupe = `${key}:${String(v)}`;
+      if (!called.has(dedupe)) {
+        called.add(dedupe);
+        core.capture("$feature_flag_called", {
+          $feature_flag: key,
+          $feature_flag_response: v,
+          ...requestId ? { $feature_flag_request_id: requestId } : {}
+        });
+      }
+      return v;
+    },
+    payload: (key) => payloads[key],
+    result(key, o) {
+      const v = o?.sendExposure === false ? overrides[key] ?? values[key] : this.get(key);
+      return flagResult(key, v, payloads[key], key in overrides ? "override" : reasons[key] ?? "remote");
+    },
+    update(flags, p = {}, o = {}) {
+      for (const k of Object.keys(flags)) reasons[k] = "pushed";
+      apply(o.merge ? { ...values, ...flags } : { ...flags }, o.merge ? { ...payloads, ...p } : { ...p });
+      core.storage.set(CACHE_KEY, JSON.stringify({ values, payloads }));
+    },
+    async setPersonProperties(props, doReload = true) {
+      fresh.clear();
+      personProps = { ...personProps, ...props };
+      if (doReload) await reload();
+    },
+    async resetPersonProperties(doReload = true) {
+      personProps = {};
+      if (doReload) await reload();
+    },
+    async setGroupProperties(type, props, doReload = true) {
+      fresh.clear();
+      groupProps = { ...groupProps, [type]: { ...groupProps[type], ...props } };
+      if (doReload) await reload();
+    },
+    async resetGroupProperties(doReload = true) {
+      groupProps = {};
+      if (doReload) await reload();
+    },
+    onChange(cb) {
+      subs.add(cb);
+      if (loaded) cb(merged());
+      return () => void subs.delete(cb);
+    },
+    reload,
+    all: () => merged(),
+    override(map) {
+      overrides = map ? { ...map } : {};
+      for (const s of subs) s(merged());
+    }
+  };
+}
+
+// src/guides.ts
+var KINDS = ["modal", "banner", "announcement", "slideout", "tour", "carousel", "tooltip", "hotspot"];
+var ANCHORABLE = ["tooltip", "hotspot", "tour"];
+var HANDLED = ["url", "url_match", "flag_key", "sample_pct", "devices", "seen_guides", "not_seen_guides", "delay_seconds", "goal", "exclude_url_patterns"];
+var SEEN_KEY = "lc_guide_seen";
+function matches(screen, pattern, how) {
+  if (how === "exact") return screen === pattern;
+  if (how === "regex") {
+    try {
+      return new RegExp(pattern).test(screen);
+    } catch {
+      return false;
+    }
+  }
+  return screen.includes(pattern);
+}
+function guideButtons(g, i) {
+  const b = g.steps[i]?.buttons;
+  if (b && b.length) return b;
+  if (g.kind === "banner" || g.kind === "announcement") return [{ label: "Dismiss", action: "dismiss" }];
+  if (g.kind === "carousel") {
+    const last = i === g.steps.length - 1;
+    return [...i > 0 ? [{ label: "Back", action: "back" }] : [], { label: last ? "Done" : "Next", action: "next" }, { label: "Dismiss", action: "dismiss" }];
+  }
+  return [{ label: i === g.steps.length - 1 ? "Done" : "Next", action: "next" }, { label: "Dismiss", action: "dismiss" }];
+}
+function screenExcluded(screen, patterns) {
+  return patterns.some((p) => !!p && new RegExp("^" + p.split("*").map((x) => x.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$").test(screen));
+}
+function guideAnchor(g, i) {
+  const s = g.steps[i];
+  const id = s?.native_id;
+  if (!s || !id || !ANCHORABLE.includes(g.kind)) return void 0;
+  const wait = Math.min(Math.max(s.wait_ms ?? 3e3, 0), 15e3);
+  return { nativeId: id, ...s.placement ? { placement: s.placement } : {}, waitMs: wait, hotspot: g.kind === "hotspot" };
+}
+var unset = (v) => v == null || v === "" || Array.isArray(v) && v.length === 0;
+var strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+function createGuides(d) {
+  const { core } = d;
+  const random = d.random ?? Math.random;
+  let guides = [];
+  let seen = /* @__PURE__ */ new Set();
+  try {
+    seen = new Set(strs(JSON.parse(core.storage.get(SEEN_KEY) ?? "[]")));
+  } catch {
+  }
+  const previewed = /* @__PURE__ */ new Set();
+  const subs = /* @__PURE__ */ new Set();
+  let view = null;
+  let screen;
+  let open = () => void 0;
+  const set = (v) => {
+    view = v;
+    for (const s of subs) s(v);
+  };
+  const props = (g, extra = {}) => ({ ...extra, $guide_id: g.id, $guide_kind: g.kind });
+  const eligible = (g, name) => {
+    if (!KINDS.includes(g.kind) || !g.steps?.length) return false;
+    if ((g.kind === "tooltip" || g.kind === "hotspot") && !g.steps[0]?.native_id) return false;
+    if (g.preview) return !previewed.has(g.id);
+    const c = g.conditions ?? {};
+    if (seen.has(g.id) || !Object.keys(c).every((k) => unset(c[k]) || HANDLED.includes(k))) return false;
+    const url = c["url"];
+    if (typeof url === "string" && url && !matches(name, url, typeof c["url_match"] === "string" ? c["url_match"] : "contains")) return false;
+    const f = c["flag_key"];
+    if (typeof f === "string" && f && !d.flag(f)) return false;
+    if (screenExcluded(name, strs(c["exclude_url_patterns"]))) return false;
+    const pct = c["sample_pct"];
+    if (!g.queued && typeof pct === "number" && random() * 100 >= pct) return false;
+    if (!unset(c["devices"]) && !strs(c["devices"]).some((x) => x === "mobile" || x === "tablet")) return false;
+    if (!unset(c["seen_guides"]) && !strs(c["seen_guides"]).every((x) => seen.has(x))) return false;
+    if (!unset(c["not_seen_guides"]) && strs(c["not_seen_guides"]).some((x) => seen.has(x))) return false;
+    return true;
+  };
+  const markSeen = (id) => {
+    seen.add(id);
+    core.storage.set(SEEN_KEY, JSON.stringify([...seen].sort()));
+  };
+  const present = (g, i) => {
+    const anchor = guideAnchor(g, i);
+    set({ guide: g, step: i, buttons: guideButtons(g, i), ...anchor ? { anchor } : {} });
+  };
+  const finish = () => {
+    set(null);
+    if (screen !== void 0) svc.show(screen);
+  };
+  const svc = {
+    async reload() {
+      if (!core.hasConsent("analytics")) return;
+      try {
+        const q = new URLSearchParams({ api_key: d.apiKey, distinct_id: core.distinctId });
+        const r = await d.fetch(`${d.apiHost}/v1/guides?${q}`);
+        if (!r.ok) return;
+        const b = await r.json();
+        guides = Array.isArray(b.guides) ? b.guides : [];
+      } catch {
+        return;
+      }
+      if (screen !== void 0) svc.show(screen);
+    },
+    show(name) {
+      screen = name;
+      if (view || !subs.size) return;
+      const g = [...guides.filter((x) => x.queued), ...guides.filter((x) => !x.queued)].find((x) => eligible(x, name));
+      if (!g) return;
+      if (g.preview) previewed.add(g.id);
+      else {
+        markSeen(g.id);
+        void core.capture("$guide_shown", props(g));
+      }
+      present(g, 0);
+    },
+    current: () => view,
+    subscribe(cb) {
+      subs.add(cb);
+      if (!view && screen !== void 0) svc.show(screen);
+      return () => void subs.delete(cb);
+    },
+    setOpener(fn) {
+      open = fn;
+    },
+    targetMissing() {
+      if (!view?.anchor || view.guide.preview) return;
+      const { guide: g, step: i, anchor } = view;
+      const id = g.steps[i].id;
+      void core.capture("$guide_target_missing", props(g, { guide_id: g.id, step_id: id, $guide_step_id: id, selector: anchor.nativeId }));
+      set({ guide: g, step: i, buttons: view.buttons });
+    },
+    act(b) {
+      if (!view) return;
+      const { guide: g, step: i } = view;
+      const quiet = !!g.preview;
+      const step = g.steps[i];
+      const sp = { $guide_step_id: step.id, $guide_step_index: i };
+      const cap = (e, p) => {
+        if (!quiet) void core.capture(e, p);
+      };
+      if (!b || b.action === "dismiss") {
+        cap("$guide_dismissed", props(g, sp));
+        return finish();
+      }
+      if (b.action === "back") return present(g, Math.max(i - 1, 0));
+      if (b.action === "link" && b.url && /^https:\/\//i.test(b.url)) open(b.url);
+      else if (b.action === "event" && b.event) cap(b.event, { $guide_id: g.id });
+      cap("$guide_step", props(g, sp));
+      if (i + 1 < g.steps.length && b.action !== "link") return present(g, i + 1);
+      cap("$guide_completed", props(g));
+      finish();
+    }
+  };
+  return svc;
+}
+
+// src/replay.ts
+import { sha256Hex as sha256Hex2 } from "@lucida-analytics/sdk-core";
+
+// src/dead-swipe.ts
+var DEAD_SWIPE_MIN_DISTANCE = 48;
+var DEAD_SWIPE_SETTLE_MS = 700;
+var DEAD_SWIPE_COOLDOWN_MS = 2e3;
+var swipeDirection = (dx, dy) => Math.abs(dx) >= Math.abs(dy) ? dx < 0 ? "left" : "right" : dy < 0 ? "up" : "down";
+function deadSwipeDecision(i) {
+  const distance = Math.hypot(i.dx, i.dy);
+  if (distance < DEAD_SWIPE_MIN_DISTANCE || i.screen !== i.startScreen || i.startFingerprint !== i.endFingerprint) return null;
+  if (i.lastAt !== void 0 && i.nowMs - i.lastAt < DEAD_SWIPE_COOLDOWN_MS) return null;
+  return { $screen_name: i.screen, $swipe_direction: swipeDirection(i.dx, i.dy), $swipe_distance: Math.round(distance) };
+}
+
+// src/replay-hit.ts
+var px = (style, prop) => {
+  const m = new RegExp(`(?:^|;)\\s*${prop}:\\s*(-?[\\d.]+)px`).exec(style);
+  return m ? Number(m[1]) : void 0;
+};
+function hitTest(root, x, y, fallback) {
+  const visit = (n, ox, oy, isRoot) => {
+    if (n.type !== void 0 && n.type !== 0 && n.type !== 2) return void 0;
+    const style = typeof n.attributes?.style === "string" ? n.attributes.style : "";
+    const left = ox + (px(style, "left") ?? 0);
+    const top = oy + (px(style, "top") ?? 0);
+    const w = px(style, "width");
+    const h = px(style, "height");
+    if (!isRoot && w !== void 0 && h !== void 0 && (x < left || y < top || x >= left + w || y >= top + h)) return void 0;
+    const kids = n.childNodes ?? [];
+    for (let i = kids.length - 1; i >= 0; i--) {
+      const hit = visit(kids[i], left, top, false);
+      if (hit !== void 0) return hit;
+    }
+    return n.type === 0 || n.tagName === "html" || n.id === void 0 ? void 0 : n.id;
+  };
+  if (typeof root !== "object" || root === null) return fallback;
+  return visit(root, 0, 0, true) ?? fallback;
+}
+
+// src/replay-masking.ts
+var escape = (s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+function screenMasked(screen, patterns) {
+  return patterns.some((p) => new RegExp(`^${p.split("*").map(escape).join(".*")}$`, "is").test(screen));
+}
+function compilePatterns(patterns) {
+  const out = [];
+  for (const p of new Set(patterns)) {
+    if (!p) continue;
+    try {
+      out.push(new RegExp(p, "g"));
+    } catch {
+    }
+  }
+  return out;
+}
+function maskPatterns(text, patterns) {
+  if (patterns.length === 0 || text === "") return text;
+  const hit = new Array(text.length).fill(false);
+  let any = false;
+  for (const p of patterns) {
+    const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      for (let i = m.index; i < m.index + m[0].length; i++) {
+        hit[i] = true;
+        any = true;
+      }
+      if (m[0].length === 0) re.lastIndex++;
+    }
+  }
+  if (!any) return text;
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    out += hit[i] && !/\s/.test(c) ? "*" : c;
+  }
+  return out;
+}
+function maskSnapshotText(node, patterns) {
+  if (patterns.length === 0 || typeof node !== "object" || node === null) return node;
+  const n = node;
+  const out = { ...n };
+  if (typeof n.textContent === "string") out.textContent = maskPatterns(n.textContent, patterns);
+  if (n.attributes && typeof n.attributes.value === "string") out.attributes = { ...n.attributes, value: maskPatterns(n.attributes.value, patterns) };
+  if (Array.isArray(n.childNodes)) out.childNodes = n.childNodes.map((c) => maskSnapshotText(c, patterns));
+  return out;
+}
+
+// src/sensitive.ts
+import { sha256Hex } from "@lucida-analytics/sdk-core";
+var SENSITIVE_MAX_PLAIN_BYTES = 190;
+var utf8Len = (cp) => cp < 128 ? 1 : cp < 2048 ? 2 : cp < 65536 ? 3 : 4;
+function truncateUtf8(value, max = SENSITIVE_MAX_PLAIN_BYTES) {
+  let bytes = 0;
+  let text = "";
+  for (const ch of value) {
+    const n = utf8Len(ch.codePointAt(0));
+    if (bytes + n > max) return { text, truncated: true };
+    bytes += n;
+    text += ch;
+  }
+  return { text, truncated: false };
+}
+function encryptSensitive(module, key, plain) {
+  const fn = module?.encryptSensitive;
+  if (typeof fn !== "function") return null;
+  try {
+    const out = fn.call(module, key.pkcs1, key.n, key.e, plain);
+    return typeof out === "string" && out !== "" ? out : null;
+  } catch {
+    return null;
+  }
+}
+function createSensitiveCapture(module) {
+  const seen = /* @__PURE__ */ new Set();
+  let session;
+  return {
+    properties(field, value, screen, key, sessionId) {
+      if (session !== sessionId) {
+        seen.clear();
+        session = sessionId;
+      }
+      const digest = sha256Hex(`${field}\0${value}`);
+      if (seen.has(digest)) return null;
+      const t = truncateUtf8(value);
+      const ct = encryptSensitive(module, key, t.text);
+      if (ct === null) return null;
+      seen.add(digest);
+      return {
+        $exposure_field: field,
+        $exposure_kid: key.kid,
+        $exposure_ciphertext: ct,
+        $screen_name: screen,
+        ...t.truncated ? { $exposure_truncated: true } : {}
+      };
+    }
+  };
+}
+
+// src/replay.ts
+var strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+function exposureKeyOf(v) {
+  const k = v;
+  if (!k || typeof k !== "object") return null;
+  const { kid, n, e, pkcs1 } = k;
+  return typeof kid === "string" && typeof n === "string" && typeof e === "string" && typeof pkcs1 === "string" ? { kid, n, e, pkcs1 } : null;
+}
+var fingerprint = (events) => sha256Hex2(JSON.stringify(events.find((e) => e.type === 2)?.data ?? null));
+var screenAllowed = (screen, allow = [], deny = []) => !deny.includes(screen) && (allow.length === 0 || allow.includes(screen));
+var effectiveSampleRate = (local, remote) => remote === null ? local : remote.session_recording === false ? 0 : Math.min(local, remote.replay_sample_rate ?? 1);
+var effectiveMinDurationMs = (local, remote) => Math.max(local, remote?.replay_min_duration_ms ?? 0);
+function bodyId(events) {
+  const find = (n) => {
+    const o = n;
+    if (!o) return void 0;
+    if (o.tagName === "body") return o.id;
+    for (const c of o.childNodes ?? []) {
+      const r = find(c);
+      if (r !== void 0) return r;
+    }
+    return void 0;
+  };
+  return find(events.find((e) => e.type === 2)?.data.node) ?? 0;
+}
+function createReplay(d) {
+  const { core, config } = d;
+  const now = d.now ?? Date.now;
+  let screen = "Unknown";
+  let timer;
+  let lastFp = null;
+  let lastScreen = null;
+  let lastSession = null;
+  let seq = 0;
+  let paused = false;
+  let lastCaptureAt = Number.NEGATIVE_INFINITY;
+  let remote = null;
+  let remoteLoaded = false;
+  let sessionStart = 0;
+  let held = [];
+  const maxHeld = 20;
+  let touches = [];
+  let tapTarget = 0;
+  let tapTree;
+  let hasSnapshot = false;
+  let patternSources = config.maskTextPatterns ?? [];
+  let patterns = compilePatterns(patternSources);
+  const sensitive = createSensitiveCapture(config.module);
+  let swipeStart = null;
+  let lastDeadSwipeAt;
+  const sampled = /* @__PURE__ */ new Map();
+  const isSampled = (sid) => {
+    const rate = effectiveSampleRate(config.sampleRate ?? 1, remote);
+    if (rate >= 1) return true;
+    if (rate <= 0) return false;
+    let v = sampled.get(sid);
+    if (v === void 0) {
+      v = (config.random ?? Math.random)() < rate;
+      sampled.clear();
+      sampled.set(sid, v);
+    }
+    return v;
+  };
+  const gateOpen = () => {
+    if (config.linkedFlag && !(d.isFlagOn?.(config.linkedFlag) ?? false)) return false;
+    return screenAllowed(screen, config.screenAllowList, config.screenDenyList);
+  };
+  const consented = () => core.hasConsent("analytics") && core.hasConsent("replay");
+  async function loadRemote() {
+    if (config.useRemoteConfig === false || remoteLoaded) return;
+    remoteLoaded = true;
+    try {
+      const r = await d.fetch(`${d.apiHost}/v1/config?api_key=${encodeURIComponent(d.apiKey)}`);
+      if (r.ok) remote = await r.json();
+    } catch {
+    }
+    sampled.clear();
+    const fromRemote = strings(remote?.replay_mask_text_patterns).filter((p) => p.length <= 200).slice(0, 20);
+    patternSources = [...config.maskTextPatterns ?? [], ...fromRemote];
+    patterns = compilePatterns(patternSources);
+  }
+  const isScreenMasked = () => screenMasked(screen, [...config.maskScreens ?? [], ...strings(remote?.replay_mask_screens)]);
+  const touchesRecording = () => hasSnapshot && !paused && consented() && gateOpen();
+  async function structure() {
+    try {
+      const raw = await config.module.captureWireframe({ screen, maskText: true, maskAllTextInputs: true, maskAllImages: true, maskSandboxedViews: true });
+      const events = raw ? JSON.parse(raw).events ?? [] : [];
+      return events.some((e) => e.type === 2) ? fingerprint(events) : null;
+    } catch {
+      return null;
+    }
+  }
+  async function swipeEnded(dx, dy) {
+    const pending = swipeStart;
+    swipeStart = null;
+    if (!pending || Math.hypot(dx, dy) < DEAD_SWIPE_MIN_DISTANCE) return false;
+    const start = await pending;
+    if (!start) return false;
+    await new Promise((r) => setTimeout(r, config.deadSwipeSettleMs ?? DEAD_SWIPE_SETTLE_MS));
+    if (!touchesRecording()) return false;
+    const fp = await structure();
+    if (fp === null) return false;
+    const t = now();
+    const p = deadSwipeDecision({ screen, startScreen: start.screen, startFingerprint: start.fp, endFingerprint: fp, dx, dy, nowMs: t, lastAt: lastDeadSwipeAt });
+    if (!p) return false;
+    lastDeadSwipeAt = t;
+    core.capture("$dead_swipe", p);
+    return true;
+  }
+  function captureSensitive(field, value) {
+    const key = exposureKeyOf(remote?.replay_exposure_key);
+    if (!value || !key || !strings(remote?.replay_exposure_fields).includes(field) || !consented()) return false;
+    const p = sensitive.properties(field, value, screen, key, core.session.touch().sessionId);
+    if (!p) return false;
+    core.capture("$sensitive_capture", p);
+    return true;
+  }
+  async function send(events, sessionId, windowId) {
+    const body = JSON.stringify({ api_key: d.apiKey, session_id: sessionId, window_id: windowId, seq, events });
+    if (body.length > (config.maxEventBytes ?? 5e6)) return;
+    try {
+      const r = await d.fetch(`${d.apiHost}/v1/replay`, { method: "POST", headers: { "Content-Type": "application/json" }, body });
+      if (r.ok) seq += 1;
+      else lastFp = null;
+    } catch {
+      lastFp = null;
+    }
+  }
+  async function tick() {
+    if (!consented()) {
+      lastFp = null;
+      hasSnapshot = false;
+      touches = [];
+      held = [];
+      return;
+    }
+    await loadRemote();
+    if (paused || !gateOpen()) {
+      lastFp = null;
+      hasSnapshot = false;
+      touches = [];
+      return;
+    }
+    if (!isSampled(core.session.touch().sessionId)) return;
+    const shots = config.mode === "screenshot";
+    if (now() - lastCaptureAt < (shots ? Math.max(config.throttleMs ?? 0, 1e3) : config.throttleMs ?? 0)) return;
+    lastCaptureAt = now();
+    let cap;
+    try {
+      const masked = isScreenMasked();
+      const raw = await config.module.captureWireframe({
+        screen,
+        maskText: masked || (config.maskText ?? true),
+        maskAllTextInputs: masked || (config.maskAllTextInputs ?? true),
+        maskAllImages: masked || (config.maskAllImages ?? true),
+        maskSandboxedViews: config.maskSandboxedViews ?? true,
+        ...masked ? { maskScreen: true } : {},
+        ...patternSources.length > 0 ? { maskTextPatterns: patternSources } : {},
+        ...shots ? { mode: "screenshot", screenshotQuality: Math.min(1, Math.max(0, config.screenshotQuality ?? 0.4)) } : {}
+      });
+      if (!raw) return;
+      cap = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const events = (cap.events ?? []).map(
+      (e) => e.type === 2 && !shots && patterns.length > 0 ? { ...e, data: { ...e.data, node: maskSnapshotText(e.data.node, patterns) } } : e
+    );
+    if (!events.some((e) => e.type === 2)) return;
+    const { sessionId, windowId } = core.session.touch();
+    const rotated = sessionId !== lastSession;
+    if (rotated) {
+      seq = 0;
+      lastSession = sessionId;
+      sessionStart = now();
+      held = [];
+    }
+    const fp = fingerprint(events);
+    const ts = now();
+    let out = touches.splice(0);
+    if (rotated || fp !== lastFp) {
+      lastFp = fp;
+      const snap = events.map((e) => ({ ...e, timestamp: ts }));
+      if (screen !== lastScreen) {
+        lastScreen = screen;
+        snap.splice(1, 0, { type: 5, timestamp: ts, data: { tag: "navigation", payload: { url: `app://${screen}` } } });
+      }
+      out = [...out, ...snap];
+      tapTarget = bodyId(events);
+      tapTree = events.find((e) => e.type === 2)?.data.node;
+      hasSnapshot = true;
+    }
+    if (out.length === 0) return;
+    const minMs = effectiveMinDurationMs(config.minDurationMs ?? 0, remote);
+    if (minMs > 0 && now() - sessionStart < minMs) {
+      held.push(out);
+      if (held.length > maxHeld) held.shift();
+      return;
+    }
+    const backlog = held;
+    held = [];
+    for (const chunk of [...backlog, out]) await send(chunk, sessionId, windowId);
+  }
+  return {
+    start() {
+      if (timer !== void 0) return;
+      timer = (config.setInterval ?? ((fn, ms) => setInterval(fn, ms)))(() => void tick(), config.snapshotIntervalMs ?? 5e3);
+    },
+    stop() {
+      if (timer === void 0) return;
+      (config.clearInterval ?? ((h) => clearInterval(h)))(timer);
+      timer = void 0;
+      held = [];
+    },
+    pause() {
+      paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    isRecording: () => timer !== void 0 && !paused && consented() && isSampled(core.session.touch().sessionId) && gateOpen(),
+    setScreen(name) {
+      screen = name;
+    },
+    tap(x, y) {
+      if (config.captureTouches === false || !hasSnapshot || paused || !consented() || !gateOpen() || touches.length >= 500) return;
+      touches.push({
+        type: 3,
+        timestamp: now(),
+        data: { source: 2, type: 2, id: hitTest(tapTree, x, y, tapTarget), x, y }
+      });
+    },
+    tick,
+    swipeBegan() {
+      if (config.captureDeadSwipes === false || !touchesRecording()) return;
+      const s = screen;
+      swipeStart = structure().then((fp) => fp === null ? null : { screen: s, fp });
+    },
+    swipeEnded,
+    captureSensitive
+  };
+}
+
+// src/client.ts
+var LIB = "lucida-react-native";
+var LIB_VERSION = "0.0.0";
+var DEFAULT_HOST = "https://app.lucida.dev";
+var VERSION_KEY = "lc_app_version";
+var noop = { send: async () => ({ status: 200 }) };
+async function createClient(apiKey, config = {}) {
+  const apiHost = (config.apiHost ?? DEFAULT_HOST).replace(/\/+$/, "");
+  const boot = config.flagOptions?.bootstrap;
+  const fetchImpl = config.fetch ?? ((...a) => fetch(...a));
+  let debugOn = !!config.debug;
+  const log = (...a) => {
+    if (debugOn) console.debug("[lucida]", ...a);
+  };
+  let storage = memoryStorage();
+  if (config.asyncStorage && !config.disabled) {
+    const a = asyncStorageAdapter(config.asyncStorage);
+    await a.ready;
+    storage = a.storage;
+  }
+  if (config.queueCipher) storage = encryptedStorage(storage, config.queueCipher, ["lc_offline"]);
+  let transport = config.transport ?? fetchTransport(fetchImpl, config.requestTimeoutMs);
+  if (config.maxBatchSize) transport = splitBatches(transport, config.maxBatchSize);
+  if (config.transport && config.requestTimeoutMs) transport = withTimeout(transport, config.requestTimeoutMs);
+  let offline;
+  if (!config.transport && config.asyncStorage) transport = offline = offlineTransport(transport, storage);
+  let flagsRef;
+  const core = new Core({
+    apiKey,
+    apiHost,
+    transport: config.disabled ? noop : transport,
+    storage,
+    library: { name: LIB, version: LIB_VERSION },
+    ...config.consent ? { consent: config.consent } : {},
+    ...boot?.distinctId ? { bootstrapDistinctId: boot.distinctId } : {},
+    session: {
+      ...config.sessionIdleMs ? { idleMs: config.sessionIdleMs } : {},
+      ...config.sessionMaxMs ? { maxMs: config.sessionMaxMs } : {}
+    },
+    queue: {
+      ...config.flushAt ? { flushAt: config.flushAt } : {},
+      ...config.flushIntervalMs ? { flushIntervalMs: config.flushIntervalMs } : {},
+      ...config.maxQueueSize ? { maxQueueSize: config.maxQueueSize } : {},
+      ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {},
+      ...config.retryDelayMs ? { backoff: { baseMs: config.retryDelayMs } } : {}
+    },
+    enrich: (event) => ({
+      properties: {
+        $os: config.platform,
+        $os_version: config.osVersion,
+        $app_version: config.appVersion,
+        $app_build: config.appBuild,
+        ...config.sendFeatureFlags !== false && event !== "$snapshot" && flagsRef ? flagEventProps(flagsRef.all()) : {}
+      }
+    }),
+    log
+  });
+  if (boot?.isIdentified && boot.distinctId === core.distinctId) core.identity.identify(boot.distinctId);
+  const person = installPolicy(core, {
+    beforeSend: config.beforeSend,
+    personProfiles: config.personProfiles,
+    disableGeoip: config.disableGeoip,
+    log
+  });
+  if (config.dataMode === "wifi" && config.network) {
+    const q = core.queue;
+    const send = q.flush.bind(q);
+    q.flush = (o) => {
+      if (config.network.isWifi()) return send(o);
+      setTimeout(() => void q.flush(), config.flushIntervalMs ?? 5e3);
+      return Promise.resolve();
+    };
+  }
+  const whenConsented = (fn) => {
+    if (config.disabled) return;
+    if (core.hasConsent("analytics")) return fn();
+    let done = false;
+    core.onChange((c) => {
+      if (!done && c === "consent" && core.hasConsent("analytics")) {
+        done = true;
+        fn();
+      }
+    });
+  };
+  const deps = { core, fetch: fetchImpl, apiHost, apiKey, whenConsented };
+  const flags = createFlags({
+    ...deps,
+    localFlags: config.localFlags,
+    localFlagsContext: config.localFlagsContext,
+    flagStream: config.flagStream,
+    appState: config.appState,
+    options: config.flagOptions,
+    disableRemote: config.disableRemoteFeatureFlags,
+    ...config.sendDefaultFlagProps === false ? {} : { defaultProps: { $lib: LIB, ...config.appVersion ? { $app_version: config.appVersion } : {}, ...config.platform ? { $os: config.platform } : {} } }
+  });
+  flagsRef = flags;
+  const autocapture = createAutocapture(core, config.autocapture ?? {});
+  const headersFor = tracingHeaders(config.tracingHeaders ?? [], apiHost, () => core.hasConsent("analytics"), () => ({
+    distinctId: core.distinctId,
+    sessionId: core.sessionId
+  }));
+  const anonId = () => {
+    try {
+      return JSON.parse(core.storage.get("lc_identity") ?? "{}").anon_id ?? core.distinctId;
+    } catch {
+      return core.distinctId;
+    }
+  };
+  const personBlocked = (what) => {
+    if (person.blocksPersonWrites) log(`personProfiles=never: ${what} ignored`);
+    return person.blocksPersonWrites;
+  };
+  const guides = createGuides({ core, fetch: fetchImpl, apiHost, apiKey, flag: (k) => ![void 0, false].includes(flags.get(k)) });
+  if (config.guides?.enabled && !config.disabled) {
+    const load = () => void flags.reload().finally(() => void guides.reload());
+    whenConsented(load);
+    core.onChange((c) => {
+      if (c === "identify" || c === "reset" || c === "group") load();
+    });
+  }
+  const replay = config.replay?.enabled && !config.disabled ? createReplay({ core, fetch: fetchImpl, apiHost, apiKey, config: config.replay, isFlagOn: (k) => {
+    const v = flags.all()[k];
+    return v !== void 0 && v !== false;
+  } }) : void 0;
+  const interventions = interventionHub(core, { apiHost, apiKey, fetch: fetchImpl, whenConsented, log, disabled: !!config.disabled });
+  const client = {
+    get distinctId() {
+      return core.distinctId;
+    },
+    getAnonymousId: anonId,
+    isOptedOut: () => !core.hasConsent("analytics"),
+    debug(on) {
+      debugOn = on;
+    },
+    capture: (e, p, o) => void core.capture(e, p, { ...o?.set ? { $set: o.set } : {}, ...o?.setOnce ? { $set_once: o.setOnce } : {} }),
+    setPersonProperties(set, setOnce) {
+      if (personBlocked("setPersonProperties")) return;
+      core.capture("$set", {}, { ...set ? { $set: set } : {}, ...setOnce ? { $set_once: setOnce } : {} });
+    },
+    openURL(url, referrer) {
+      const query = {};
+      for (const kv of (url.split("#")[0].split("?")[1] ?? "").split("&")) {
+        if (!kv) continue;
+        const [k = "", v = ""] = kv.split("=");
+        query[decodeURIComponent(k)] = decodeURIComponent(v);
+      }
+      core.capture("$deep_link_opened", { url, query, ...referrer ? { referrer } : {} });
+    },
+    fetch: tracedFetch(fetchImpl, headersFor),
+    autocapture,
+    screen(name, props) {
+      core.capture("$screen", { ...props, $screen_name: name });
+      replay?.setScreen(name);
+      if (config.guides?.enabled) guides.show(name);
+    },
+    identify(id, s, o) {
+      if (!personBlocked("identify")) core.identify(id, s, o);
+    },
+    alias(a, o) {
+      if (!personBlocked("alias")) core.alias(a, o);
+    },
+    reset() {
+      person.reset();
+      core.reset({ reuseAnonymousId: !!config.reuseAnonymousId });
+    },
+    register: (p) => core.register(p),
+    registerOnce: (p) => core.registerOnce(p),
+    unregister: (k) => core.unregister(k),
+    group: (t, k, p) => core.group(t, k, p),
+    optIn: () => core.optIn(),
+    optOut: () => core.optOut(),
+    getFlag: (k) => flags.get(k),
+    getFlagPayload: (k) => flags.payload(k),
+    getFlagResult: (k, o) => flags.result(k, o),
+    isFeatureEnabled: (k) => {
+      const v = flags.get(k);
+      return v !== void 0 && v !== false;
+    },
+    onFlags: (cb) => flags.onChange(cb),
+    onIntervention: (cb) => interventions.on(cb),
+    reloadFlags: () => flags.reload(),
+    updateFlags: (f, p, o) => flags.update(f, p, o),
+    getAllFlags: () => flags.all(),
+    overrideFlags: (m) => flags.override(m),
+    setPersonPropertiesForFlags: (p, r) => flags.setPersonProperties(p, r),
+    resetPersonPropertiesForFlags: (r) => flags.resetPersonProperties(r),
+    setGroupPropertiesForFlags: (t, p, r) => flags.setGroupProperties(t, p, r),
+    resetGroupPropertiesForFlags: (r) => flags.resetGroupProperties(r),
+    replay: {
+      start: () => replay?.start(),
+      stop: () => replay?.stop(),
+      pause: () => replay?.pause(),
+      resume: () => replay?.resume(),
+      tag: (name) => void core.capture("$replay_tag", { name, session_id: core.sessionId }),
+      isRecording: () => replay?.isRecording() ?? false,
+      tap: (x, y) => replay?.tap(x, y),
+      swipeBegan: () => replay?.swipeBegan(),
+      swipeEnded: (dx, dy) => void replay?.swipeEnded(dx, dy)
+    },
+    captureSensitive: (field, value) => replay?.captureSensitive(field, value) ?? false,
+    guides,
+    flush: () => core.flush(),
+    shutdown: async () => {
+      stopLifecycle();
+      flags.stop();
+      interventions.stop();
+      replay?.stop();
+      await core.shutdown();
+    }
+  };
+  const opened = () => void core.capture("$app_opened");
+  const prev = core.storage.get(VERSION_KEY);
+  if (config.appVersion && prev !== config.appVersion) {
+    const base = { $app_version: config.appVersion };
+    if (prev !== null) core.capture("$app_updated", { ...base, $previous_app_version: prev });
+    else if (config.installInfo && config.installAttribution !== false) {
+      void resolveInstallProps(config.installInfo, { fetch: fetchImpl }).then((extra) => core.capture("$app_installed", { ...base, ...extra }));
+    } else core.capture("$app_installed", base);
+    core.storage.set(VERSION_KEY, config.appVersion);
+  }
+  opened();
+  const stopLifecycle = config.appState ? appLifecycle(config.appState, {
+    onForeground() {
+      opened();
+      void offline?.drain();
+    },
+    onBackground() {
+      core.capture("$app_backgrounded");
+      void core.flush();
+    }
+  }) : () => void 0;
+  replay?.start();
+  if (offline) whenConsented(() => void offline.drain());
+  log("initialised", { apiHost });
+  return client;
+}
+
+// src/native-cipher.ts
+function nativeQueueCipher(module) {
+  if (!module || typeof module.encryptQueue !== "function" || typeof module.decryptQueue !== "function") {
+    throw new Error("nativeQueueCipher: the native LucidaReplay module has no encryptQueue/decryptQueue (rebuild the app, and note blocking sync methods do not work under the remote JS debugger)");
+  }
+  return {
+    encrypt(plain) {
+      try {
+        const out = module.encryptQueue(plain);
+        return typeof out === "string" ? out : "";
+      } catch {
+        return "";
+      }
+    },
+    decrypt(cipher) {
+      if (cipher === "") return null;
+      try {
+        const out = module.decryptQueue(cipher);
+        return typeof out === "string" && out !== "" ? out : null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/navigation.ts
+function screenTracker(client, ref, opts = {}) {
+  let last;
+  const track = () => {
+    const r = ref.current?.getCurrentRoute();
+    if (!r || r.name === last) return;
+    last = r.name;
+    client.screen(r.name, opts.includeParams && r.params ? { $screen_params: r.params } : {});
+  };
+  return { onReady: track, onStateChange: track };
+}
+
+// src/guides-view.tsx
+import { useContext as useContext2, useEffect as useEffect3, useState as useState2 } from "react";
+import { Dimensions, Linking, Modal, Pressable, Text, View as View2, useColorScheme } from "react-native";
+
+// src/guide-anchor.tsx
+import { useEffect, useRef } from "react";
+import { View } from "react-native";
+import { jsx } from "react/jsx-runtime";
+var anchors = /* @__PURE__ */ new Map();
+function registerAnchor(id, m) {
+  anchors.set(id, m);
+  return () => {
+    if (anchors.get(id) === m) anchors.delete(id);
+  };
+}
+function measureAnchor(id) {
+  const m = anchors.get(id);
+  if (!m) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    try {
+      m.measureInWindow((x, y, width, height) => resolve(width > 0 || height > 0 ? { x, y, width, height } : null));
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function GuideAnchor({ testID, children, style }) {
+  const ref = useRef(null);
+  useEffect(() => ref.current ? registerAnchor(testID, ref.current) : void 0, [testID]);
+  return /* @__PURE__ */ jsx(View, { ref, testID, collapsable: false, style, children });
+}
+
+// src/guide-theme.ts
+var HEX = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+var obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+function wantsDark(a, systemDark) {
+  if (!obj(obj(a?.["dark"])?.["tokens"])) return false;
+  const m = a?.["theme_mode"];
+  const mode = typeof m === "string" ? m : "auto";
+  return mode === "dark" || mode === "auto" && systemDark;
+}
+function guideTokens(a, systemDark) {
+  const t = {};
+  const ff = a?.["font_family"];
+  if (typeof ff === "string") t.font = ff;
+  const layers = [obj(a?.["tokens"]), wantsDark(a, systemDark) ? obj(obj(a?.["dark"])?.["tokens"]) : void 0];
+  for (const l of layers) {
+    if (!l) continue;
+    for (const k of ["background", "text", "accent"]) {
+      const v = l[k];
+      if (typeof v === "string" && HEX.test(v)) t[k] = v;
+    }
+    const r = l["radius"];
+    if (typeof r === "number" && r >= 0 && r <= 32) t.radius = r;
+    const f = l["font"];
+    if (typeof f === "string" && f.trim()) t.font = f;
+  }
+  return t;
+}
+function bubbleOrigin(w, h, r, bounds, placement, margin = 12, gap = 8) {
+  const below = r.y + r.height + gap;
+  const above = r.y - gap - h;
+  const fitsBelow = below + h <= bounds.y + bounds.height - margin;
+  const fitsAbove = above >= bounds.y + margin;
+  const y = placement === "top" ? fitsAbove || !fitsBelow ? above : below : fitsBelow || !fitsAbove ? below : above;
+  const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), Math.max(lo, hi));
+  return {
+    x: clamp(r.x + r.width / 2 - w / 2, bounds.x + margin, bounds.x + bounds.width - margin - w),
+    y: clamp(y, bounds.y + margin, bounds.y + bounds.height - margin - h)
+  };
+}
+
+// src/provider.tsx
+import { createContext, useContext, useEffect as useEffect2, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var LucidaContext = createContext(null);
+function LucidaProvider({ client: given, apiKey, options, children }) {
+  const [client, setClient] = useState(given ?? null);
+  const [flags, setFlags] = useState({});
+  useEffect2(() => {
+    if (given) return setClient(given);
+    if (!apiKey) return;
+    let alive = true;
+    let owned;
+    void createClient(apiKey, options).then((c) => {
+      owned = c;
+      if (alive) setClient(c);
+      else void c.shutdown();
+    });
+    return () => {
+      alive = false;
+      void owned?.shutdown();
+    };
+  }, [given, apiKey]);
+  useEffect2(() => client?.onFlags((f) => setFlags(f)), [client]);
+  return /* @__PURE__ */ jsx2(LucidaContext.Provider, { value: { client, flags }, children });
+}
+function useLucidaContext() {
+  const v = useContext(LucidaContext);
+  if (!v) throw new Error("Lucida hooks must be used inside <LucidaProvider>");
+  return v;
+}
+
+// src/guides-view.tsx
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+function LucidaGuides() {
+  const client = useContext2(LucidaContext)?.client;
+  const [v, setV] = useState2(null);
+  const dark = useColorScheme() === "dark";
+  useEffect3(() => {
+    if (!client) return;
+    client.guides.setOpener((u) => void Linking.openURL(u).catch(() => void 0));
+    return client.guides.subscribe(setV);
+  }, [client]);
+  if (!client || !v) return null;
+  const t = guideTokens(v.guide.appearance, dark);
+  const act = (b) => client.guides.act(b);
+  if (v.anchor) return /* @__PURE__ */ jsx3(AnchoredStep, { v, t, act, missing: () => client.guides.targetMissing() }, `${v.guide.id}:${v.step}`);
+  const step = v.guide.steps[v.step];
+  const banner = v.guide.kind === "banner" || v.guide.kind === "announcement";
+  return /* @__PURE__ */ jsx3(Modal, { visible: true, transparent: true, animationType: "fade", onRequestClose: () => act(null), children: /* @__PURE__ */ jsx3(View2, { style: { flex: 1, justifyContent: banner ? "flex-start" : "center", backgroundColor: "rgba(0,0,0,0.4)", padding: 16 }, children: /* @__PURE__ */ jsxs(View2, { accessibilityViewIsModal: true, style: { backgroundColor: t.background ?? "#fff", borderRadius: t.radius ?? 12, padding: 16 }, children: [
+    /* @__PURE__ */ jsx3(Body, { v, t, title: step?.title ?? null }),
+    v.guide.kind === "carousel" ? /* @__PURE__ */ jsx3(Dots, { i: v.step, n: v.guide.steps.length, t }) : null,
+    /* @__PURE__ */ jsx3(Buttons, { v, t, act })
+  ] }) }) });
+}
+function Body({ v, t, title }) {
+  const step = v.guide.steps[v.step];
+  const font = t.font?.split(",")[0]?.trim().replace(/["']/g, "");
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    title ? /* @__PURE__ */ jsx3(Text, { accessibilityRole: "header", style: { fontSize: 18, fontWeight: "600", color: t.text, fontFamily: font }, children: title }) : null,
+    step?.body ? /* @__PURE__ */ jsx3(Text, { style: { marginTop: 8, color: t.text, fontFamily: font }, children: step.body }) : null
+  ] });
+}
+function Buttons({ v, t, act }) {
+  return /* @__PURE__ */ jsx3(View2, { style: { flexDirection: "row", justifyContent: "flex-end", marginTop: 16 }, children: v.buttons.map((b, i) => /* @__PURE__ */ jsx3(Pressable, { accessibilityRole: "button", accessibilityLabel: b.label, onPress: () => act(b), style: { padding: 8, marginLeft: 8 }, children: /* @__PURE__ */ jsx3(Text, { style: { color: t.accent }, children: b.label }) }, i)) });
+}
+function Dots({ i, n, t }) {
+  return /* @__PURE__ */ jsx3(View2, { accessibilityLabel: `Slide ${i + 1} of ${n}`, style: { flexDirection: "row", justifyContent: "center", marginTop: 12 }, children: Array.from({ length: n }, (_, k) => /* @__PURE__ */ jsx3(View2, { style: { width: 8, height: 8, borderRadius: 4, marginHorizontal: 3, backgroundColor: k === i ? t.accent ?? "#111" : "#ccc" } }, k)) });
+}
+function AnchoredStep({ v, t, act, missing }) {
+  const a = v.anchor;
+  const [rect, setRect] = useState2(null);
+  const [open, setOpen] = useState2(!a.hotspot);
+  const [height, setHeight] = useState2(120);
+  useEffect3(() => {
+    let alive = true;
+    let found = false;
+    let goneSince = 0;
+    const deadline = Date.now() + a.waitMs;
+    const poll = async () => {
+      if (!alive) return;
+      const r = await measureAnchor(a.nativeId);
+      if (!alive) return;
+      if (r) {
+        found = true;
+        goneSince = 0;
+        setRect((p) => p && p.x === r.x && p.y === r.y && p.width === r.width && p.height === r.height ? p : r);
+      } else if (!found && Date.now() >= deadline) return missing();
+      else if (found) {
+        goneSince ||= Date.now();
+        if (Date.now() - goneSince > 2e3) return act(null);
+      }
+      setTimeout(() => void poll(), found ? 100 : 150);
+    };
+    void poll();
+    return () => void (alive = false);
+  }, [a.nativeId, a.waitMs]);
+  if (!rect) return null;
+  const win = Dimensions.get("window");
+  const width = Math.min(300, win.width - 24);
+  const at = bubbleOrigin(width, height, rect, { x: 0, y: 0, width: win.width, height: win.height }, a.placement);
+  const step = v.guide.steps[v.step];
+  return /* @__PURE__ */ jsxs(View2, { pointerEvents: "box-none", style: { position: "absolute", left: 0, top: 0, right: 0, bottom: 0 }, children: [
+    a.hotspot ? /* @__PURE__ */ jsx3(
+      Pressable,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: step?.title ?? v.guide.name,
+        onPress: () => setOpen(true),
+        style: { position: "absolute", left: rect.x + rect.width - 8, top: rect.y - 8, width: 16, height: 16, borderRadius: 8, borderWidth: 2, borderColor: "#fff", backgroundColor: t.accent ?? "#e5484d" }
+      }
+    ) : null,
+    open ? /* @__PURE__ */ jsxs(
+      View2,
+      {
+        onLayout: (e) => setHeight(e.nativeEvent.layout.height),
+        style: { position: "absolute", left: at.x, top: at.y, width, backgroundColor: t.background ?? "#fff", borderRadius: t.radius ?? 10, padding: 14, elevation: 6, shadowOpacity: 0.25, shadowRadius: 8 },
+        children: [
+          /* @__PURE__ */ jsx3(Body, { v, t, title: step?.title ?? (v.step === 0 ? v.guide.name : null) }),
+          /* @__PURE__ */ jsx3(Buttons, { v, t, act })
+        ]
+      }
+    ) : null
+  ] });
+}
+
+// src/mask.tsx
+import { useContext as useContext3, useRef as useRef2 } from "react";
+import { Platform, View as View3 } from "react-native";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var REPLAY_MARKERS = {
+  ios: { mask: "lucida-sensitive", unmask: "lucida-unmask" },
+  android: { mask: "lc-mask", unmask: "lc-unmask" }
+};
+var replayMarker = (kind, os = Platform.OS) => REPLAY_MARKERS[os === "android" ? "android" : "ios"][kind];
+function LucidaMask({ children, style }) {
+  return /* @__PURE__ */ jsx4(View3, { testID: replayMarker("mask"), collapsable: false, style, children });
+}
+function LucidaUnmask({ children, style }) {
+  return /* @__PURE__ */ jsx4(View3, { testID: replayMarker("unmask"), collapsable: false, style, children });
+}
+var point = (e) => {
+  const n = e.nativeEvent;
+  return n && typeof n.pageX === "number" && typeof n.pageY === "number" ? { x: n.pageX, y: n.pageY } : null;
+};
+var TOUCH_SLOP = 10;
+function LucidaTouchCapture({ children, style }) {
+  const client = useContext3(LucidaContext)?.client;
+  const swipe = useRef2(null);
+  return /* @__PURE__ */ jsx4(
+    View3,
+    {
+      collapsable: false,
+      style: style ?? { flex: 1 },
+      onTouchStart: (e) => {
+        const p = point(e);
+        swipe.current = p ? { ...p, began: false } : null;
+      },
+      onTouchMove: (e) => {
+        const s = swipe.current;
+        const p = point(e);
+        if (!client || !s || !p || s.began || Math.hypot(p.x - s.x, p.y - s.y) <= TOUCH_SLOP) return;
+        s.began = true;
+        client.replay.swipeBegan();
+      },
+      onTouchEnd: (e) => {
+        const p = point(e);
+        const s = swipe.current;
+        swipe.current = null;
+        if (!client || !p) return;
+        client.replay.tap(p.x, p.y);
+        if (s?.began) client.replay.swipeEnded(p.x - s.x, p.y - s.y);
+      },
+      children
+    }
+  );
+}
+
+// src/hooks.tsx
+import { useCallback, useEffect as useEffect4, useMemo } from "react";
+import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+function useLucida() {
+  return useLucidaContext().client;
+}
+function useCapture() {
+  const { client } = useLucidaContext();
+  return useCallback((event, props) => client?.capture(event, props), [client]);
+}
+var NO_REPLAY = { start() {
+}, stop() {
+}, pause() {
+}, resume() {
+}, tag() {
+}, tap() {
+}, swipeBegan() {
+}, swipeEnded() {
+}, isRecording: () => false };
+function useReplay() {
+  return useLucidaContext().client?.replay ?? NO_REPLAY;
+}
+function useScreen(name, props) {
+  const { client } = useLucidaContext();
+  useEffect4(() => {
+    client?.screen(name, props);
+  }, [client, name]);
+}
+function useFeatureFlag(key) {
+  const { client, flags } = useLucidaContext();
+  const value = flags[key];
+  useEffect4(() => {
+    if (value !== void 0) client?.getFlag(key);
+  }, [client, key, value]);
+  return value;
+}
+function useFeatureFlagVariant(key) {
+  const v = useFeatureFlag(key);
+  return typeof v === "string" ? v : void 0;
+}
+function useFeatureFlagPayload(key) {
+  const { client, flags } = useLucidaContext();
+  return useMemo(() => client?.getFlagPayload(key), [client, key, flags]);
+}
+function useActiveFeatureFlags() {
+  const { flags } = useLucidaContext();
+  return useMemo(() => Object.keys(flags).filter((k) => flags[k] !== false), [flags]);
+}
+function FeatureGate({ flag, variant, fallback = null, children }) {
+  const v = useFeatureFlag(flag);
+  const on = variant !== void 0 ? v === variant : v !== void 0 && v !== false;
+  return /* @__PURE__ */ jsx5(Fragment2, { children: on ? children : fallback });
+}
+export {
+  DEAD_SWIPE_MIN_DISTANCE,
+  FeatureGate,
+  GuideAnchor,
+  LIB,
+  LIB_VERSION,
+  LucidaGuides,
+  LucidaMask,
+  LucidaProvider,
+  LucidaTouchCapture,
+  LucidaUnmask,
+  PERSISTED_KEYS,
+  PersonMode,
+  REPLAY_MARKERS,
+  SENSITIVE_MAX_PLAIN_BYTES,
+  appLifecycle,
+  appStoreInstallProps,
+  asyncStorageAdapter,
+  bubbleOrigin,
+  chainFromFiber,
+  compilePatterns,
+  createAutocapture,
+  createClient,
+  createGuides,
+  createReplay,
+  createSensitiveCapture,
+  deadSwipeDecision,
+  effectiveMinDurationMs,
+  effectiveSampleRate,
+  encryptSensitive,
+  encryptedStorage,
+  exposureKeyOf,
+  fetchTransport,
+  guideAnchor,
+  guideButtons,
+  guideTokens,
+  installReferrerProps,
+  maskPatterns,
+  maskSnapshotText,
+  matches as matchGuideScreen,
+  measureAnchor,
+  memoryStorage,
+  nativeQueueCipher,
+  registerAnchor,
+  replayMarker,
+  resolveInstallProps,
+  runHooks,
+  sampleHook,
+  screenAllowed,
+  screenExcluded,
+  screenMasked,
+  screenTracker,
+  splitBatches,
+  swipeDirection,
+  touchHandler,
+  tracedFetch,
+  tracingHeaders,
+  truncateUtf8,
+  useActiveFeatureFlags,
+  useCapture,
+  useFeatureFlag,
+  useFeatureFlagPayload,
+  useFeatureFlagVariant,
+  useLucida,
+  useReplay,
+  useScreen,
+  withBaggage,
+  withTimeout
+};