@guidelytech/react-native 0.9.0 → 0.11.0

package/dist/index.js

@@ -3,9 +3,9 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.tsx
-import { useContext as useContext3, useEffect as useEffect9, useMemo as useMemo5, useRef as useRef6, useState as useState8 } from "react";
-import { AppState as AppState2, Dimensions, Linking, Platform as Platform6 } from "react-native";
-import { createStaticFlags as createStaticFlags2, stableStringify as stableStringify2 } from "@guidelytech/flags";
+import { useContext as useContext3, useEffect as useEffect9, useMemo as useMemo6, useRef as useRef7, useState as useState8 } from "react";
+import { AppState as AppState2, Dimensions, Linking, Platform as Platform6, StyleSheet as StyleSheet10, View as View12 } from "react-native";
+import { createStaticFlags as createStaticFlags2, stableStringify as stableStringify3 } from "@guidelytech/flags";
 
 // src/flags.tsx
 import { createFlagsClient, createStaticFlags, jsonEquals, stableStringify } from "@guidelytech/flags";
@@ -96,7 +96,7 @@ function FlagsProvider({ children, client: external, payload, ...options }) {
   return /* @__PURE__ */ jsx(FlagsContext.Provider, { value, children });
 }
 
-// ../shared/dist/chunk-UW6NRYRY.js
+// ../shared/dist/chunk-TGIUEYXM.js
 function fnv1a(input) {
   let h = 2166136261;
   for (let i = 0; i < input.length; i++) {
@@ -276,6 +276,8 @@ function resolveField(rule, ctx) {
       return ctx.now.getHours();
     case "rollout.percentage":
       return rolloutBucket(ctx.userId || ctx.anonymousId, ctx.rolloutSalt || "guidely");
+    case "experiment.bucket":
+      return rule.key ? rolloutBucket(ctx.userId || ctx.anonymousId, rule.key) : void 0;
     case "environment":
       return ctx.environment;
     case "locale":
@@ -286,6 +288,9 @@ function resolveField(rule, ctx) {
       return ctx.screen;
     case "app.version":
       return ctx.appVersion;
+    case "page.views":
+    case "feature.clicks":
+      return rule.key ? ctx.tagUsage?.[rule.key] ?? 0 : 0;
     default:
       return void 0;
   }
@@ -394,8 +399,8 @@ function sanitizeProperties(props) {
   for (const [k, v] of Object.entries(props)) {
     if (SENSITIVE_PROPERTY_PATTERN.test(k)) continue;
     if (typeof v === "function" || typeof v === "symbol") continue;
-    const str = typeof v === "string" ? v : JSON.stringify(v ?? null);
-    size += k.length + (str?.length ?? 0);
+    const str2 = typeof v === "string" ? v : JSON.stringify(v ?? null);
+    size += k.length + (str2?.length ?? 0);
     if (size > MAX_PROPERTY_BYTES) break;
     out[k.slice(0, 100)] = typeof v === "string" ? v.slice(0, 1e3) : v;
   }
@@ -552,53 +557,252 @@ function isArticleListed(collections, article, member) {
   }
   return true;
 }
+var RC_MODULE_IDS = ["announcements", "search", "checklists", "guides", "articles", "links", "faqs"];
+function orderedModules(modules) {
+  const known = (modules ?? []).filter((m, i, all) => RC_MODULE_IDS.includes(m.id) && all.findIndex((x) => x.id === m.id) === i);
+  const missing2 = RC_MODULE_IDS.filter((id) => !known.some((m) => m.id === id)).map((id) => ({ id, enabled: true }));
+  return [...known, ...missing2];
+}
+function visibleAnnouncements(items, member, now = Date.now()) {
+  return (items ?? []).filter((a) => {
+    const t = Date.parse(a.publishedAt);
+    return !Number.isNaN(t) && t <= now && matchesAudiences(a.audienceIds, member);
+  }).sort((a, b) => Date.parse(b.publishedAt) - Date.parse(a.publishedAt));
+}
+function unreadAnnouncements(items, lastSeenAt) {
+  const seen = lastSeenAt ? Date.parse(lastSeenAt) : NaN;
+  if (Number.isNaN(seen)) return items.length;
+  return items.filter((a) => Date.parse(a.publishedAt) > seen).length;
+}
 var CAPTURE_SCREENSHOT_MAX_BYTES = 8 * 1024 * 1024;
-
-// ../sdk-core/dist/chunk-CYAG6ZYX.js
-function readJson(store, key, fallback) {
-  const raw = store.get(key);
-  if (raw == null) return fallback;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return fallback;
-  }
+var DEFAULT_LOCALE = "en";
+function normalizeLocale(input) {
+  if (typeof input !== "string") return "";
+  const parts = input.trim().replace(/_/g, "-").split("-").filter(Boolean);
+  if (!parts.length || !/^[a-zA-Z]{2,3}$/.test(parts[0])) return "";
+  return parts.slice(0, 3).map((p, i) => i === 0 ? p.toLowerCase() : p.length === 4 ? p[0].toUpperCase() + p.slice(1).toLowerCase() : p.length === 2 ? p.toUpperCase() : p).join("-");
+}
+function baseLanguage(locale) {
+  return normalizeLocale(locale).split("-")[0] ?? "";
+}
+function resolveLocale(requested, available, defaultLocale = DEFAULT_LOCALE) {
+  const def = normalizeLocale(defaultLocale) || DEFAULT_LOCALE;
+  const avail = available.map(normalizeLocale).filter(Boolean);
+  const all = [def, ...avail.filter((a) => a.toLowerCase() !== def.toLowerCase())];
+  for (const raw of requested) {
+    const want = normalizeLocale(raw);
+    if (!want) continue;
+    const exact = all.find((a) => a.toLowerCase() === want.toLowerCase());
+    if (exact) return exact;
+    const base = baseLanguage(want);
+    const sameBase = all.find((a) => a.toLowerCase() === base) ?? all.find((a) => baseLanguage(a) === base);
+    if (sameBase) return sameBase;
+  }
+  return def;
+}
+function visitorLocales(explicit, traits, platform = []) {
+  const out = [];
+  const push = (v) => {
+    const n = normalizeLocale(v);
+    if (n && !out.includes(n)) out.push(n);
+  };
+  push(explicit);
+  push(traits?.language);
+  push(traits?.locale);
+  for (const p of platform) push(p);
+  return out;
 }
-function writeJson(store, key, value) {
-  try {
-    store.set(key, JSON.stringify(value));
-  } catch {
-  }
+function guideLocales(config) {
+  const t = config.localization?.translations ?? {};
+  return Object.keys(t).filter((l) => Object.values(t[l] ?? {}).some((v) => typeof v === "string" && v.trim() !== ""));
+}
+function pick(map, key, fallback) {
+  const v = map?.[key];
+  return typeof v === "string" && v.trim() !== "" ? v : fallback;
+}
+function applyGuideTranslations(config, map) {
+  if (!map || !Object.keys(map).length) return config;
+  return {
+    ...config,
+    steps: config.steps.map((s) => ({
+      ...s,
+      title: pick(map, `steps.${s.id}.title`, s.title),
+      body: pick(map, `steps.${s.id}.body`, s.body),
+      customHtml: pick(map, `steps.${s.id}.customHtml`, s.customHtml),
+      imageAlt: pick(map, `steps.${s.id}.imageAlt`, s.imageAlt),
+      buttons: s.buttons.map((b) => ({ ...b, label: pick(map, `steps.${s.id}.buttons.${b.id}.label`, b.label) }))
+    })),
+    checklist: config.checklist ? {
+      ...config.checklist,
+      launcherLabel: pick(map, "checklist.launcherLabel", config.checklist.launcherLabel),
+      completionTitle: pick(map, "checklist.completionTitle", config.checklist.completionTitle),
+      completionBody: pick(map, "checklist.completionBody", config.checklist.completionBody),
+      tasks: config.checklist.tasks.map((t) => ({ ...t, title: pick(map, `checklist.tasks.${t.id}.title`, t.title), description: pick(map, `checklist.tasks.${t.id}.description`, t.description) }))
+    } : config.checklist,
+    survey: config.survey ? {
+      ...config.survey,
+      thankYouTitle: pick(map, "survey.thankYouTitle", config.survey.thankYouTitle),
+      thankYouBody: pick(map, "survey.thankYouBody", config.survey.thankYouBody),
+      questions: config.survey.questions.map((q) => ({
+        ...q,
+        title: pick(map, `survey.questions.${q.id}.title`, q.title),
+        description: pick(map, `survey.questions.${q.id}.description`, q.description),
+        placeholder: pick(map, `survey.questions.${q.id}.placeholder`, q.placeholder),
+        lowLabel: pick(map, `survey.questions.${q.id}.lowLabel`, q.lowLabel),
+        highLabel: pick(map, `survey.questions.${q.id}.highLabel`, q.highLabel),
+        options: q.options.map((o) => ({ ...o, label: pick(map, `survey.questions.${q.id}.options.${o.id}.label`, o.label) }))
+      }))
+    } : config.survey
+  };
+}
+function localizeGuide(guide, requested, defaultLocale = DEFAULT_LOCALE) {
+  const translations = guide.config.localization?.translations ?? {};
+  const locale = resolveLocale(requested, guideLocales(guide.config), defaultLocale);
+  const key = Object.keys(translations).find((l) => normalizeLocale(l).toLowerCase() === locale.toLowerCase());
+  if (!key) return { ...guide, locale };
+  return { ...guide, locale, config: applyGuideTranslations(guide.config, translations[key]) };
+}
+function resourceCenterLocales(rc) {
+  const set = new Set(Object.keys(rc.translations ?? {}));
+  for (const a of rc.articles) for (const l of Object.keys(a.translations ?? {})) set.add(l);
+  for (const a of rc.announcements ?? []) for (const l of Object.keys(a.translations ?? {})) set.add(l);
+  return [...set];
+}
+function translationFor(map, locale) {
+  if (!map) return void 0;
+  const key = Object.keys(map).find((l) => normalizeLocale(l).toLowerCase() === locale.toLowerCase());
+  return key ? map[key] : void 0;
+}
+function localizeArticle(a, locale) {
+  const t = translationFor(a.translations, locale);
+  if (!t) return a;
+  const body = t.body?.trim() ? t.body : a.body;
+  return { ...a, title: t.title?.trim() ? t.title : a.title, summary: t.summary?.trim() ? t.summary : a.summary, body, ...t.bodyOmitted ? { bodyOmitted: true } : {} };
+}
+function localizeAnnouncement(a, locale) {
+  const t = translationFor(a.translations, locale);
+  if (!t) return a;
+  return { ...a, title: t.title?.trim() ? t.title : a.title, body: t.body?.trim() ? t.body : a.body };
+}
+function localizeResourceCenter(rc, requested, defaultLocale = DEFAULT_LOCALE) {
+  const locale = resolveLocale(requested, resourceCenterLocales(rc), defaultLocale);
+  if (locale.toLowerCase() === normalizeLocale(defaultLocale).toLowerCase()) return { ...rc, locale };
+  const map = translationFor(rc.translations, locale);
+  return {
+    ...rc,
+    locale,
+    title: pick(map, "title", rc.title),
+    launcher: { ...rc.launcher, label: pick(map, "launcher.label", rc.launcher.label) },
+    collections: rc.collections.map((c) => ({ ...c, name: pick(map, `collections.${c.id}.name`, c.name), description: pick(map, `collections.${c.id}.description`, c.description) })),
+    links: rc.links.map((l) => ({ ...l, label: pick(map, `links.${l.id}.label`, l.label) })),
+    faqs: rc.faqs.map((f) => ({ ...f, question: pick(map, `faqs.${f.id}.question`, f.question), answer: pick(map, `faqs.${f.id}.answer`, f.answer) })),
+    articles: rc.articles.map((a) => localizeArticle(a, locale)),
+    announcements: rc.announcements?.map((a) => localizeAnnouncement(a, locale))
+  };
 }
-var KEYS = {
-  anon: "guidely:anon",
-  seen: "guidely:seen",
-  config: (key) => `guidely:config:${key}`,
-  etag: (key) => `guidely:etag:${key}`,
-  state: (key) => `guidely:state:${key}`,
-  user: (key) => `guidely:user:${key}`,
-  queue: (key) => `guidely:queue:${key}`,
-  session: "guidely:session",
-  active: "guidely:active",
-  authoring: "guidely:authoring",
-  /** How-to capture session marker ({ token, … }) and its not-yet-uploaded steps. */
-  capture: "guidely:capture",
-  capturePending: "guidely:capture:pending",
-  /** Messenger conversations this browser can read: [{ id, token }]. */
-  conversations: (key) => `guidely:conversations:${key}`,
-  /** Announcement ids opened in the messenger's News tab. */
-  newsSeen: (key) => `guidely:news:${key}`
-};
 
-// ../sdk-core/dist/chunk-AKNE7D5M.js
+// ../sdk-core/dist/chunk-JUSM7J5N.js
 var __defProp2 = Object.defineProperty;
 var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var MAX_RETRY_AFTER_MS = 60 * 60 * 1e3;
+var OFFLINE_WAIT_MS = 3e4;
+var ServerHealth = class {
+  constructor(opts = {}) {
+    __publicField2(this, "failures", 0);
+    __publicField2(this, "openUntil", 0);
+    __publicField2(this, "lastOkAt", 0);
+    __publicField2(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField2(this, "threshold");
+    __publicField2(this, "baseMs");
+    __publicField2(this, "maxMs");
+    __publicField2(this, "now");
+    __publicField2(this, "random");
+    this.threshold = opts.threshold ?? 3;
+    this.baseMs = opts.baseMs ?? 5e3;
+    this.maxMs = opts.maxMs ?? 5 * 60 * 1e3;
+    this.now = opts.now ?? Date.now;
+    this.random = opts.random ?? Math.random;
+  }
+  /** The server answered (2xx, 3xx, or a 4xx other than 429): it is up. */
+  success() {
+    const wasDown = this.failures > 0 || this.openUntil > 0;
+    this.failures = 0;
+    this.openUntil = 0;
+    this.lastOkAt = this.now();
+    if (wasDown) this.notify();
+  }
+  /** The request failed or the server is overloaded. `retryAfterMs` comes from a `Retry-After` header. */
+  failure(retryAfterMs) {
+    this.failures += 1;
+    const now = this.now();
+    if (retryAfterMs != null && retryAfterMs > 0) {
+      this.openUntil = Math.max(this.openUntil, now + Math.min(retryAfterMs, MAX_RETRY_AFTER_MS));
+      return;
+    }
+    if (this.failures < this.threshold) return;
+    const cooldown = Math.min(this.maxMs, this.baseMs * 2 ** (this.failures - this.threshold));
+    this.openUntil = Math.max(this.openUntil, now + cooldown * (0.8 + this.random() * 0.4));
+  }
+  /** Milliseconds background traffic should wait before trying again (0: send now). */
+  waitMs() {
+    if (typeof navigator !== "undefined" && navigator.onLine === false) return OFFLINE_WAIT_MS;
+    return Math.max(0, this.openUntil - this.now());
+  }
+  canSend() {
+    return this.waitMs() === 0;
+  }
+  /**
+   * The last request got an answer. Unload beacons can't report back, so what they carry is only
+   * forgotten while this holds; otherwise it stays queued and is sent again (the server drops duplicates).
+   */
+  get reachable() {
+    return this.failures === 0 && this.lastOkAt > 0;
+  }
+  /** The browser came back online: end the cooldown and let queued traffic try straight away. */
+  online() {
+    this.openUntil = 0;
+    this.notify();
+  }
+  /** Called when the server answers again after failures, or the browser comes back online. */
+  onRecover(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  notify() {
+    for (const cb of Array.from(this.listeners)) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+};
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+function isServerFailure(status) {
+  return status === 429 || status >= 500;
+}
+var STREAM_RESPONSE_TIMEOUT_MS = 3e4;
+var STREAM_IDLE_TIMEOUT_MS = 6e4;
 var Api = class {
-  constructor(baseUrl, key, fetchImpl) {
+  constructor(baseUrl, key, fetchImpl, health) {
     __publicField2(this, "baseUrl", baseUrl);
     __publicField2(this, "key", key);
     __publicField2(this, "fetchImpl", fetchImpl);
+    __publicField2(this, "health");
+    this.health = health ?? new ServerHealth();
+  }
+  /** Feeds an answer (or a failed request, `null`) into {@link health}. */
+  observe(res) {
+    if (!res) this.health.failure();
+    else if (isServerFailure(res.status)) this.health.failure(parseRetryAfter(res.headers?.get?.("retry-after")));
+    else this.health.success();
   }
   url(path, params = {}) {
     const query = Object.entries({ key: this.key, ...params }).filter((e) => e[1] != null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
@@ -618,15 +822,22 @@ var Api = class {
     const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
     const timer = ac ? setTimeout(() => ac.abort(), options.timeoutMs ?? 1e4) : null;
     try {
-      const res = await f(this.url(path, options.params), {
-        method,
-        headers,
-        body: options.body === void 0 ? void 0 : form ? options.body : JSON.stringify(options.body),
-        keepalive: options.keepalive,
-        signal: ac?.signal,
-        credentials: "omit",
-        mode: "cors"
-      });
+      let res;
+      try {
+        res = await f(this.url(path, options.params), {
+          method,
+          headers,
+          body: options.body === void 0 ? void 0 : form ? options.body : JSON.stringify(options.body),
+          keepalive: options.keepalive,
+          signal: ac?.signal,
+          credentials: "omit",
+          mode: "cors"
+        });
+      } catch (err) {
+        this.observe(null);
+        throw err;
+      }
+      this.observe(res);
       let data = null;
       if (res.status !== 304 && res.status !== 204) {
         try {
@@ -652,30 +863,53 @@ var Api = class {
   }
   /**
    * POST that may answer with server-sent events. Each event is passed to `onEvent`; a JSON answer is
-   * returned instead. No timeout: Scout replies can take a while and the server keeps the stream alive.
+   * returned instead. Scout replies can take a while, so there is no overall timeout: the response
+   * must start within 30 s and then never go quiet for more than 60 s (the server sends keepalives),
+   * otherwise the request is aborted and rejects.
    */
   async stream(path, body, onEvent, headers = {}) {
     const f = this.fetcher;
     if (!f) throw new Error("fetch is not available");
-    const res = await f(this.url(path), {
-      method: "POST",
-      headers: { ...headers, "X-Guidely-Key": this.key, Accept: "text/event-stream, application/json", "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-      credentials: "omit",
-      mode: "cors"
-    });
-    const type = res.headers?.get?.("content-type") ?? "";
-    if (!type.includes("text/event-stream") || !res.body) {
-      let data = null;
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    let timer = null;
+    const arm = (ms) => {
+      if (!ac) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => ac.abort(), ms);
+    };
+    arm(STREAM_RESPONSE_TIMEOUT_MS);
+    try {
+      let res;
       try {
-        data = await res.json();
-      } catch {
-        data = null;
+        res = await f(this.url(path), {
+          method: "POST",
+          headers: { ...headers, "X-Guidely-Key": this.key, Accept: "text/event-stream, application/json", "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: ac?.signal,
+          credentials: "omit",
+          mode: "cors"
+        });
+      } catch (err) {
+        this.observe(null);
+        throw err;
+      }
+      this.observe(res);
+      const type = res.headers?.get?.("content-type") ?? "";
+      if (!type.includes("text/event-stream") || !res.body) {
+        let data = null;
+        try {
+          data = await res.json();
+        } catch {
+          data = null;
+        }
+        return { status: res.status, ok: res.ok, data, etag: null };
       }
-      return { status: res.status, ok: res.ok, data, etag: null };
+      arm(STREAM_IDLE_TIMEOUT_MS);
+      await readEventStream(res.body, onEvent, () => arm(STREAM_IDLE_TIMEOUT_MS));
+      return { status: res.status, ok: res.ok, data: null, etag: null };
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    await readEventStream(res.body, onEvent);
-    return { status: res.status, ok: res.ok, data: null, etag: null };
   }
   /** `navigator.sendBeacon` when available (page unload); returns false when it could not be queued. */
   beacon(path, body) {
@@ -706,7 +940,7 @@ async function withRetry(send, attempts = 3, baseMs = 500) {
 function postWithRetry(api, path, body, attempts = 3, baseMs = 500) {
   return withRetry(() => api.post(path, body), attempts, baseMs);
 }
-async function readEventStream(body, onEvent) {
+async function readEventStream(body, onEvent, onChunk) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -729,6 +963,7 @@ async function readEventStream(body, onEvent) {
   };
   for (; ; ) {
     const { done, value } = await reader.read();
+    if (value) onChunk?.();
     if (value) buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
     let sep;
     while ((sep = buffer.indexOf("\n\n")) >= 0) {
@@ -739,8 +974,46 @@ async function readEventStream(body, onEvent) {
   }
   if (buffer.trim()) dispatch(buffer);
 }
+function readJson(store, key, fallback) {
+  const raw = store.get(key);
+  if (raw == null) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(store, key, value) {
+  try {
+    store.set(key, JSON.stringify(value));
+  } catch {
+  }
+}
+var KEYS = {
+  anon: "guidely:anon",
+  seen: "guidely:seen",
+  config: (key) => `guidely:config:${key}`,
+  etag: (key) => `guidely:etag:${key}`,
+  state: (key) => `guidely:state:${key}`,
+  user: (key) => `guidely:user:${key}`,
+  queue: (key) => `guidely:queue:${key}`,
+  /** Survey answers and guide/checklist progress not yet accepted by the server. */
+  outbox: (key) => `guidely:outbox:${key}`,
+  /** Agent Analytics turns not yet accepted by the server. */
+  agentOutbox: (key) => `guidely:agents:${key}`,
+  session: "guidely:session",
+  active: "guidely:active",
+  authoring: "guidely:authoring",
+  /** How-to capture session marker ({ token, … }) and its not-yet-uploaded steps. */
+  capture: "guidely:capture",
+  capturePending: "guidely:capture:pending",
+  /** Messenger conversations this browser can read: [{ id, token }]. */
+  conversations: (key) => `guidely:conversations:${key}`,
+  /** Announcement ids opened in the messenger's News tab. */
+  newsSeen: (key) => `guidely:news:${key}`
+};
 
-// ../sdk-core/dist/chunk-544KSOC3.js
+// ../sdk-core/dist/chunk-ZAF2KRJA.js
 var EventQueue = class {
   constructor(opts) {
     __publicField2(this, "opts", opts);
@@ -751,17 +1024,34 @@ var EventQueue = class {
     __publicField2(this, "inflightIds", /* @__PURE__ */ new Set());
     __publicField2(this, "attempt", 0);
     __publicField2(this, "destroyed", false);
+    __publicField2(this, "offRecover", null);
     __publicField2(this, "flushIntervalMs");
     __publicField2(this, "maxQueue");
     __publicField2(this, "batchSize");
     __publicField2(this, "maxAttempts");
     this.flushIntervalMs = opts.flushIntervalMs ?? 2e3;
-    this.maxQueue = opts.maxQueue ?? 200;
+    this.maxQueue = opts.maxQueue ?? 500;
     this.batchSize = opts.batchSize ?? 50;
     this.maxAttempts = opts.maxAttempts ?? 5;
     const persisted = readJson(opts.store, opts.storageKey, []);
     if (Array.isArray(persisted)) this.events = persisted.filter((e) => e && typeof e.eventId === "string").slice(-this.maxQueue);
     if (this.events.length) this.schedule();
+    this.offRecover = opts.health?.onRecover(() => this.retryNow()) ?? null;
+  }
+  /** The API is back: drop any pending backoff and send what is queued. */
+  retryNow() {
+    if (this.destroyed) return;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    this.attempt = 0;
+    void this.flush();
+  }
+  retryIn(ms) {
+    if (this.retryTimer || this.destroyed) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.flush();
+    }, ms);
   }
   get size() {
     return this.events.length;
@@ -795,6 +1085,8 @@ var EventQueue = class {
       clearTimeout(this.timer);
       this.timer = null;
     }
+    const wait = this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.retryIn(wait);
     this.inflight = true;
     const batch = this.events.slice(0, this.batchSize);
     this.inflightIds = new Set(batch.map((e) => e.eventId));
@@ -818,26 +1110,20 @@ var EventQueue = class {
       if (this.events.length) this.schedule();
       return;
     }
-    this.attempt += 1;
-    if (this.attempt >= this.maxAttempts) {
-      this.attempt = 0;
-      return;
-    }
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      void this.flush();
-    }, backoffMs(this.attempt - 1));
+    this.attempt = Math.min(this.attempt + 1, this.maxAttempts);
+    const delay = this.attempt >= this.maxAttempts ? 6e4 : backoffMs(this.attempt - 1);
+    this.retryIn(Math.max(delay, this.opts.health?.waitMs() ?? 0));
   }
   /** Best-effort synchronous flush on unload using `sendBeacon`. */
   flushSync() {
     if (this.destroyed || !this.opts.enabled() || !this.opts.beacon) return;
     const batch = this.events.filter((e) => !this.inflightIds.has(e.eventId)).slice(0, this.batchSize);
     if (!batch.length) return;
-    if (this.opts.beacon(batch)) {
+    if (this.opts.beacon(batch) && (this.opts.health?.reachable ?? true)) {
       const ids = new Set(batch.map((e) => e.eventId));
       this.events = this.events.filter((e) => !ids.has(e.eventId));
-      this.persist();
     }
+    this.persist();
   }
   clear() {
     this.events = [];
@@ -845,6 +1131,7 @@ var EventQueue = class {
   }
   destroy() {
     this.destroyed = true;
+    this.offRecover?.();
     if (this.timer) clearTimeout(this.timer);
     if (this.retryTimer) clearTimeout(this.retryTimer);
     this.timer = null;
@@ -852,6 +1139,88 @@ var EventQueue = class {
     this.persist();
   }
 };
+var Outbox = class {
+  constructor(opts) {
+    __publicField2(this, "opts", opts);
+    __publicField2(this, "items");
+    __publicField2(this, "sending", false);
+    __publicField2(this, "attempt", 0);
+    __publicField2(this, "timer", null);
+    __publicField2(this, "destroyed", false);
+    __publicField2(this, "offRecover");
+    __publicField2(this, "maxItems");
+    __publicField2(this, "maxAgeMs");
+    this.maxItems = opts.maxItems ?? 50;
+    this.maxAgeMs = opts.maxAgeMs ?? 7 * 24 * 60 * 60 * 1e3;
+    const stored = readJson(opts.store, opts.storageKey, []);
+    const cutoff = Date.now() - this.maxAgeMs;
+    this.items = Array.isArray(stored) ? stored.filter((i) => i && typeof i.path === "string" && typeof i.key === "string" && i.createdAt > cutoff).slice(-this.maxItems) : [];
+    this.offRecover = opts.health?.onRecover(() => {
+      this.attempt = 0;
+      this.retryIn(0);
+    }) ?? null;
+    if (this.items.length) this.retryIn(0);
+  }
+  get size() {
+    return this.items.length;
+  }
+  /** Queues `POST path` and sends it now (or as soon as the API is reachable). */
+  add(key, path, body) {
+    if (this.destroyed) return;
+    this.items = this.items.filter((i) => i.key !== key);
+    this.items.push({ key, path, body, createdAt: Date.now() });
+    if (this.items.length > this.maxItems) this.items.splice(0, this.items.length - this.maxItems);
+    this.persist();
+    void this.flush();
+  }
+  persist() {
+    writeJson(this.opts.store, this.opts.storageKey, this.items);
+  }
+  retryIn(ms) {
+    if (this.destroyed) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, ms);
+  }
+  /** Sends queued requests in order, one at a time. */
+  async flush() {
+    if (this.destroyed || this.sending || !this.items.length) return;
+    const wait = this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.retryIn(wait);
+    this.sending = true;
+    try {
+      while (this.items.length && !this.destroyed) {
+        const item = this.items[0];
+        let retry = false;
+        try {
+          const res = await this.opts.api.post(item.path, item.body);
+          retry = !res.ok && (res.status === 429 || res.status >= 500);
+        } catch (err) {
+          retry = true;
+          this.opts.onError?.(err);
+        }
+        if (retry) {
+          this.attempt += 1;
+          this.retryIn(Math.max(backoffMs(this.attempt - 1, 1e3, 6e4), this.opts.health?.waitMs() ?? 0));
+          return;
+        }
+        this.attempt = 0;
+        this.items = this.items.filter((i) => i !== item);
+        this.persist();
+      }
+    } finally {
+      this.sending = false;
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    this.offRecover?.();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+};
 var Emitter = class {
   constructor(onError) {
     __publicField2(this, "onError", onError);
@@ -920,12 +1289,32 @@ function areMutuallyExclusive(a, b) {
   return la.includes(b.id) || la.includes(b.key) || lb.includes(a.id) || lb.includes(a.key);
 }
 function isWithinSchedule(guide, now = Date.now()) {
-  const s = guide.config.survey;
-  if (!s) return true;
-  if (s.startAt && now < Date.parse(s.startAt)) return false;
-  if (s.endAt && now > Date.parse(s.endAt)) return false;
+  for (const w of [guide.config.schedule, guide.config.survey]) {
+    if (!w) continue;
+    if (w.startAt && now < Date.parse(w.startAt)) return false;
+    if (w.endAt && now > Date.parse(w.endAt)) return false;
+  }
   return true;
 }
+var MINUTE = 60 * 1e3;
+function countsTowardThrottle(guide) {
+  return isExclusiveGuide(guide) && !guide.config.frequency.ignoreThrottling;
+}
+function isThrottleEligible(settings, launches, now = Date.now()) {
+  if (!settings || !settings.enabled) return true;
+  const times = launches.map((l) => Date.parse(l)).filter((t) => !Number.isNaN(t));
+  const windowMs = Math.max(1, settings.windowHours) * HOUR;
+  if (times.filter((t) => now - t < windowMs).length >= Math.max(1, settings.maxGuides)) return false;
+  if (settings.minGapMinutes > 0 && times.some((t) => now - t < settings.minGapMinutes * MINUTE)) return false;
+  return true;
+}
+function pruneLaunches(launches, settings, now = Date.now()) {
+  const keepMs = Math.max(settings?.windowHours ?? 24, 1) * HOUR + (settings?.minGapMinutes ?? 0) * MINUTE;
+  return launches.filter((l) => {
+    const t = Date.parse(l);
+    return !Number.isNaN(t) && now - t < keepMs;
+  }).slice(-100);
+}
 function dismissedAfterMerge(local, server) {
   if (server.dismissResetAt && server.dismissResetAt !== local?.dismissResetAt) return server.dismissedAt ?? null;
   return local?.dismissedAt ?? server.dismissedAt ?? null;
@@ -934,6 +1323,115 @@ function dismissedAfterMerge(local, server) {
 // src/core/client.ts
 import { createFlagsClient as createFlagsClient2 } from "@guidelytech/flags";
 
+// src/core/autocapture.ts
+var TAP_SLOP = 10;
+var TAP_MAX_MS = 1e3;
+var HEATMAP_MAX_POINTS = 40;
+function quoteValue(value) {
+  return `"${value.replace(/["\\]/g, "\\$&")}"`;
+}
+function attrSelector(name, value) {
+  return `[${name}=${quoteValue(value)}]`.slice(0, 300);
+}
+function cleanText(text) {
+  const t = (text ?? "").replace(/\s+/g, " ").trim();
+  return t ? t.slice(0, 100) : void 0;
+}
+function tapProperties(el, x, y, platform, maskAll) {
+  const props = { selector: el.selector.slice(0, 300), tag: el.tag || "View", x: Math.round(x) || 0, y: Math.round(y) || 0, platform };
+  const text = maskAll ? void 0 : cleanText(el.text);
+  if (text) props.text = text;
+  return props;
+}
+var r2 = (n) => Math.round(Math.min(1, Math.max(0, n)) * 100) / 100;
+function heatmapPoint(x, y, el, rect, rage) {
+  const p = { k: rage ? "r" : "c", x: Math.round(x) || 0, y: Math.round(y) || 0 };
+  const s = el?.selector.slice(0, 120);
+  if (s) p.s = s;
+  if (s && rect && rect.width > 0 && rect.height > 0) {
+    p.rx = r2((x - rect.x) / rect.width);
+    p.ry = r2((y - rect.y) / rect.height);
+  }
+  return p;
+}
+var RageClickDetector = class {
+  constructor(threshold = 3, windowMs = 1e3, radius = 30) {
+    __publicField(this, "threshold", threshold);
+    __publicField(this, "windowMs", windowMs);
+    __publicField(this, "radius", radius);
+    __publicField(this, "clicks", []);
+    __publicField(this, "fired", false);
+  }
+  /** Taps in the current burst once it has fired (rage), otherwise 0. */
+  get burst() {
+    return this.fired ? this.clicks.length : 0;
+  }
+  /** Records a tap; returns the tap count when it completes a burst, otherwise 0. */
+  add(x, y, t) {
+    const first = this.clicks[0];
+    const last = this.clicks[this.clicks.length - 1];
+    if (!first || !last || t - last.t > this.windowMs || Math.hypot(x - first.x, y - first.y) > this.radius) {
+      this.clicks = [];
+      this.fired = false;
+    }
+    this.clicks = this.clicks.filter((c) => t - c.t <= this.windowMs);
+    this.clicks.push({ x, y, t });
+    if (this.fired || this.clicks.length < this.threshold) return 0;
+    this.fired = true;
+    return this.clicks.length;
+  }
+};
+var HeatmapBuffer = class {
+  constructor() {
+    /** Screen path the buffered points belong to. */
+    __publicField(this, "url", "");
+    __publicField(this, "points", []);
+  }
+  /** Adds a tap (`burst` > 0 marks it and the burst's previous taps as rage); true when the batch is full. */
+  add(url, point, burst) {
+    this.url = url;
+    for (let i = Math.max(0, this.points.length - burst + 1); i < this.points.length; i++) this.points[i].k = "r";
+    this.points.push(point);
+    return this.points.length >= HEATMAP_MAX_POINTS;
+  }
+  /** Empties the buffer, returning what was in it. */
+  take() {
+    const points = this.points;
+    this.points = [];
+    return points.length ? { url: this.url, points } : null;
+  }
+};
+var TapTracker = class {
+  constructor() {
+    __publicField(this, "start", null);
+    __publicField(this, "moved", 0);
+  }
+  /** A finger went down. A second finger while one is tracked cancels the gesture (not a tap). */
+  begin(x, y, t, touches, id) {
+    if (this.start || touches > 1) {
+      this.start = null;
+      return;
+    }
+    this.start = { x, y, t, id };
+    this.moved = 0;
+  }
+  move(x, y, id) {
+    const s = this.start;
+    if (s && (id === void 0 || s.id === void 0 || id === s.id)) this.moved = Math.max(this.moved, Math.hypot(x - s.x, y - s.y));
+  }
+  /** The finger lifted: the tap position when it moved ≤ 10pt and lasted < 1s, else null. */
+  end(x, y, t, id) {
+    const s = this.start;
+    if (!s || id !== void 0 && s.id !== void 0 && id !== s.id) return null;
+    this.start = null;
+    const moved = Math.max(this.moved, Math.hypot(x - s.x, y - s.y));
+    return moved <= TAP_SLOP && t - s.t < TAP_MAX_MS ? { x, y } : null;
+  }
+  cancel() {
+    this.start = null;
+  }
+};
+
 // src/core/targets.ts
 var TargetTimeoutError = class extends Error {
   constructor(ids) {
@@ -1036,6 +1534,35 @@ var TargetRegistry = class {
       return null;
     }
   }
+  /**
+   * The registered target on the current screen whose visible frame contains the point (window
+   * coordinates); the smallest one when targets are nested. Frames that do not answer within
+   * `timeoutMs` are skipped.
+   */
+  async hitTest(x, y, timeoutMs = 500) {
+    const candidates = [];
+    this.targets.forEach((list, id) => {
+      for (const handle of list) if (!(handle.screen && this.screen && handle.screen !== this.screen)) candidates.push({ id, handle });
+    });
+    if (!candidates.length) return null;
+    const rects = await Promise.all(
+      candidates.map(
+        ({ handle }) => new Promise((resolve) => {
+          const timer = setTimeout(() => resolve(null), timeoutMs);
+          void this.measureHandle(handle).then((r) => {
+            clearTimeout(timer);
+            resolve(r);
+          });
+        })
+      )
+    );
+    let best = null;
+    rects.forEach((r, i) => {
+      if (!r || x < r.x || y < r.y || x > r.x + r.width || y > r.y + r.height) return;
+      if (!best || r.width * r.height < best.rect.width * best.rect.height) best = { id: candidates[i].id, rect: r };
+    });
+    return best;
+  }
   /** First of `ids` that is mounted and visible. */
   async resolve(ids) {
     for (const id of ids) {
@@ -1407,12 +1934,29 @@ function createSseParser(onEvent) {
     }
   };
 }
+var STREAM_RESPONSE_TIMEOUT_MS2 = 3e4;
+var STREAM_IDLE_TIMEOUT_MS2 = 6e4;
 function xhrStreamPost() {
   if (typeof XMLHttpRequest === "undefined") return null;
   return (url, headers, body, onChunk) => new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest();
     let seen = 0;
     let streamed = false;
+    let timer = null;
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      fn();
+    };
+    const arm = (ms, what) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        settle(() => reject(new Error(`Scout ${what} timed out`)));
+        xhr.abort();
+      }, ms);
+    };
     const pump = () => {
       const type = xhr.getResponseHeader("content-type") || "";
       if (!type.includes("text/event-stream")) return;
@@ -1425,8 +1969,15 @@ function xhrStreamPost() {
     };
     xhr.open("POST", url);
     for (const [k, v] of Object.entries(headers)) xhr.setRequestHeader(k, v);
-    xhr.onprogress = pump;
-    xhr.onload = () => {
+    xhr.onreadystatechange = () => {
+      if (!settled && xhr.readyState >= 2 && xhr.readyState < 4) arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+    };
+    xhr.onprogress = () => {
+      if (settled) return;
+      arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+      pump();
+    };
+    xhr.onload = () => settle(() => {
       pump();
       let json = null;
       if (!streamed) {
@@ -1437,27 +1988,74 @@ function xhrStreamPost() {
         }
       }
       resolve({ status: xhr.status, json, streamed });
-    };
-    xhr.onerror = () => reject(new Error("Network request failed"));
+    });
+    xhr.onerror = () => settle(() => reject(new Error("Network request failed")));
+    arm(STREAM_RESPONSE_TIMEOUT_MS2, "request");
     xhr.send(JSON.stringify(body));
   });
 }
+function bodyReader(res) {
+  const body = res.body;
+  const Decoder = globalThis.TextDecoder;
+  return body && typeof body.getReader === "function" && Decoder ? { reader: body.getReader(), decoder: new Decoder() } : null;
+}
 function fetchStreamPost(fetchImpl) {
   return async (url, headers, body, onChunk) => {
-    const res = await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body) });
-    const type = res.headers.get("content-type") || "";
-    const text = await res.text();
-    if (type.includes("text/event-stream")) {
-      onChunk(text);
-      return { status: res.status, json: null, streamed: true };
-    }
-    let json = null;
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    let timer = null;
+    let timedOut = "";
+    let fail = () => {
+    };
+    const expired = new Promise((_, reject) => fail = reject);
+    expired.catch(() => {
+    });
+    const arm = (ms, what) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timedOut = what;
+        ac?.abort();
+        fail(new Error(`Scout ${what} timed out`));
+      }, ms);
+    };
+    const race = (p) => Promise.race([p, expired]);
+    arm(STREAM_RESPONSE_TIMEOUT_MS2, "request");
     try {
-      json = JSON.parse(text || "null");
-    } catch {
-      json = null;
+      const res = await race(fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body), signal: ac?.signal }));
+      arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+      const type = res.headers.get("content-type") || "";
+      const sse = type.includes("text/event-stream");
+      const streaming = sse ? bodyReader(res) : null;
+      if (streaming) {
+        const { reader, decoder } = streaming;
+        for (; ; ) {
+          const { done, value } = await race(reader.read());
+          if (value) {
+            arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+            onChunk(decoder.decode(value, { stream: true }));
+          }
+          if (done) break;
+        }
+        const rest = decoder.decode();
+        if (rest) onChunk(rest);
+        return { status: res.status, json: null, streamed: true };
+      }
+      const text = await race(res.text());
+      if (sse) {
+        onChunk(text);
+        return { status: res.status, json: null, streamed: true };
+      }
+      let json = null;
+      try {
+        json = JSON.parse(text || "null");
+      } catch {
+        json = null;
+      }
+      return { status: res.status, json, streamed: false };
+    } catch (err) {
+      throw timedOut ? new Error(`Scout ${timedOut} timed out`) : err;
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    return { status: res.status, json, streamed: false };
   };
 }
 var byNewest = (a, b) => Date.parse(b.lastMessageAt) - Date.parse(a.lastMessageAt);
@@ -1642,7 +2240,15 @@ var Messenger = class {
       }
     });
     try {
-      const res = await this.deps.streamPost(this.url(path), headers, payload, (chunk) => parser.feed(chunk));
+      let res;
+      try {
+        res = await this.deps.streamPost(this.url(path), headers, payload, (chunk) => parser.feed(chunk));
+      } catch (err) {
+        this.deps.health?.failure();
+        throw err;
+      }
+      if (isServerFailure(res.status)) this.deps.health?.failure();
+      else this.deps.health?.success();
       parser.end();
       if (res.status < 200 || res.status >= 300) throw new Error(`Request failed (${res.status})`);
       if (!res.streamed && res.json) {
@@ -1714,7 +2320,8 @@ var Messenger = class {
     this.stopThreadPolling();
     this.set({ open: true, view: { kind: "article", articleId: id, from }, article: null });
     try {
-      const res = await this.request("GET", `/articles/${encodeURIComponent(id)}`);
+      const locale = this.deps.locale?.();
+      const res = await this.request("GET", `/articles/${encodeURIComponent(id)}`, locale ? { params: { locale } } : {});
       this.set({ article: res.article });
     } catch (err) {
       this.deps.onError(err);
@@ -1829,9 +2436,22 @@ var PersistentStore = class {
 
 // src/core/client.ts
 var SDK_NAME = "@guidelytech/react-native";
-var SDK_VERSION = "0.9.0";
+var SDK_VERSION = "0.11.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;
+function settlesWithin(promise, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), ms);
+    const done = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    promise.then(done, done);
+  });
+}
+var appVersionKey = (key) => `guidely:app:${key}`;
+var UNKNOWN_VIEW = { selector: "View", tag: "View" };
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 var emptyState = () => ({ guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] });
 var newSession = () => ({ id: `s_${randomId(16)}`, startedAt: nowIso(), lastActiveAt: nowIso(), shownGuides: [], events: [] });
@@ -1844,6 +2464,8 @@ var GuidelyClient = class {
     __publicField(this, "store");
     __publicField(this, "emitter");
     __publicField(this, "queue", null);
+    /** Survey answers, guide completions/dismissals and checklist progress, kept until the server has them. */
+    __publicField(this, "outbox", null);
     __publicField(this, "config", null);
     __publicField(this, "configFetchedAt", 0);
     __publicField(this, "etag", null);
@@ -1861,6 +2483,7 @@ var GuidelyClient = class {
     __publicField(this, "activeSurvey", null);
     __publicField(this, "queued", []);
     __publicField(this, "flows", /* @__PURE__ */ new Map());
+    /** Checklists on screen, with the guide as rendered (in the visitor's language). */
     __publicField(this, "checklists", /* @__PURE__ */ new Map());
     __publicField(this, "expanded", /* @__PURE__ */ new Set());
     __publicField(this, "surveyView", null);
@@ -1880,6 +2503,27 @@ var GuidelyClient = class {
     __publicField(this, "flags");
     /** Experiments already reported this session (`experiment_viewed` is sent once per session). */
     __publicField(this, "exposures", /* @__PURE__ */ new Set());
+    // Product analytics (autocapture).
+    __publicField(this, "rage", new RageClickDetector());
+    __publicField(this, "heatmap", new HeatmapBuffer());
+    /** Taps are processed in order (target frames are measured asynchronously). */
+    __publicField(this, "tapChain", Promise.resolve());
+    /** When the current screen's foreground measurement started; `screenLeft` once it has been reported. */
+    __publicField(this, "screenStartedAt", 0);
+    __publicField(this, "screenLeft", true);
+    /** Last `app_open` (cold start or return to the foreground), for `app_background.foregroundMs`. */
+    __publicField(this, "openedAt", Date.now());
+    __publicField(this, "launchChecked", false);
+    /** An identity was stored before this launch (an existing install adopting lifecycle events). */
+    __publicField(this, "hadIdentity", false);
+    /** Language set with `setLocale()` (or the `locale` option). */
+    __publicField(this, "locale", null);
+    /** Language each shown guide was rendered in; added to its events as `locale`. */
+    __publicField(this, "guideLocales", /* @__PURE__ */ new Map());
+    /** The resource center in the visitor's language, recomputed when the config or language changes. */
+    __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);
     __publicField(this, "customListeners", /* @__PURE__ */ new Map());
     __publicField(this, "eventBus", {
       on: (name, cb) => {
@@ -1906,9 +2550,10 @@ var GuidelyClient = class {
     this.emitter = new Emitter((err) => this.reportError(err));
     this.api = new Api(this.options.apiUrl, this.options.projectId, options.fetch);
     this.store = new PersistentStore(options.storage ?? null, (err) => this.log("storage error", err));
-    if (!options.storage) this.log("no `storage` passed: identity and guide history last only for this app session. Pass AsyncStorage to persist them.");
+    if (!options.storage) this.log("no `storage` passed: identity, guide history, queued events and survey answers last only for this app session, so whatever could not be sent during a Guidely outage is lost when the app restarts. Pass AsyncStorage to persist them.");
     this.cleanups.push(this.targets.onTap((id) => this.handleTap(id)));
     if (options.user) this.user = { ...options.user };
+    this.locale = options.locale ? normalizeLocale(options.locale) || null : null;
     this.flags = this.createFlags(options.flags);
   }
   createFlags(opts) {
@@ -1957,9 +2602,10 @@ 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.conversations(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)]);
       if (this.destroyed) return;
       this.anonymousId = this.store.get(KEYS.anon) || "";
+      this.hadIdentity = !!this.anonymousId;
       if (!this.anonymousId) {
         this.anonymousId = `anon_${randomId(20)}`;
         this.store.set(KEYS.anon, this.anonymousId);
@@ -1977,22 +2623,28 @@ var GuidelyClient = class {
         store: this.store,
         storageKey: KEYS.queue(key),
         enabled: () => this.analyticsEnabled(),
+        health: this.api.health,
         send: async (events) => {
           const res = await this.api.post("/events", { events, sentAt: nowIso(), sdk: { name: SDK_NAME, version: SDK_VERSION } });
           return { ok: res.ok, retry: !(res.status >= 400 && res.status < 500 && res.status !== 429) };
         },
         onError: (err) => this.reportError(err)
       });
+      this.outbox = new Outbox({ api: this.api, store: this.store, storageKey: KEYS.outbox(key), health: this.api.health });
       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);
       this.syncMessenger();
       this.pending.splice(0).forEach((fn) => fn());
-      await this.fetchConfig();
+      const before = this.config?.configVersion;
+      const fresh = this.fetchConfig();
+      if (!this.config) await fresh;
+      else if (!await settlesWithin(fresh, CACHED_START_MS)) void fresh.then(() => this.applyConfigChange(before));
       if (this.destroyed) return;
+      this.checkLaunch();
       this.wireTimers();
-      if (this.user?.id) await this.identify(this.user.id, this.user.traits, this.user.account);
+      if (this.user?.id) await settlesWithin(this.identify(this.user.id, this.user.traits, this.user.account), CACHED_START_MS);
       if (this.destroyed) return;
       this.isReady = true;
       if (this.config) this.emitter.emit("ready", this.config);
@@ -2020,6 +2672,7 @@ var GuidelyClient = class {
         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.log("config loaded", this.config.configVersion, `${this.config.guides.length} guides`);
         return true;
@@ -2032,13 +2685,15 @@ var GuidelyClient = class {
     }
   }
   wireTimers() {
-    const refresh = setInterval(() => void this.refresh(), this.options.configRefreshMs);
+    const refresh = setInterval(() => {
+      if (this.api.health.canSend()) void this.refresh();
+    }, this.options.configRefreshMs);
     this.cleanups.push(() => clearInterval(refresh));
     const poll = setInterval(() => {
       if (!this.isReady || !this.config || this.backgroundedAt !== null) return;
       const url = this.currentUrl();
       const ctx = this.getContext();
-      for (const guide of this.config.guides) if (guide.config.trigger.type === "element_visible" && guide.config.trigger.value) this.armVisibility(guide, ctx, url);
+      for (const guide of this.candidates()) if (guide.config.trigger.type === "element_visible" && guide.config.trigger.value) this.armVisibility(guide, ctx, url);
       this.drainQueue(url, ctx);
     }, 1e3);
     this.cleanups.push(() => clearInterval(poll));
@@ -2048,6 +2703,11 @@ var GuidelyClient = class {
     if (this.destroyed) return;
     const before = this.config?.configVersion;
     await this.fetchConfig();
+    this.applyConfigChange(before);
+  }
+  /** Re-renders after a config change (refresh, or a config that arrived after start). */
+  applyConfigChange(before) {
+    if (this.destroyed || !this.isReady) return;
     if (this.config && this.config.configVersion !== before) {
       this.notify();
       this.evaluate("ready");
@@ -2057,10 +2717,13 @@ var GuidelyClient = class {
   setAppState(state) {
     if (this.destroyed || !this.hydrated) return;
     if (state === "background") {
+      const wasForeground = this.backgroundedAt === null;
       this.backgroundedAt = Date.now();
+      if (wasForeground) this.wentToBackground();
       this.session.lastActiveAt = nowIso();
       this.persistSession();
       void this.queue?.flush();
+      void this.outbox?.flush();
       void this.store.flush();
       void this.flags.flush();
       this.messenger?.setForeground(false);
@@ -2073,8 +2736,9 @@ var GuidelyClient = class {
         this.persistSession();
         this.firedDelays.clear();
       }
+      this.cameToForeground();
       void this.flags.refresh();
-      if (Date.now() - this.configFetchedAt > this.options.configRefreshMs) void this.refresh();
+      if (Date.now() - this.configFetchedAt > this.options.configRefreshMs && this.api.health.canSend()) void this.refresh();
       else if (this.isReady) this.evaluate("ready");
     }
   }
@@ -2085,6 +2749,7 @@ var GuidelyClient = class {
   /** Tears everything down. Create a new client to start again. */
   destroy() {
     if (this.destroyed) return;
+    this.flushHeatmap();
     this.destroyed = true;
     this.active?.controller.destroy();
     this.active = null;
@@ -2100,6 +2765,7 @@ var GuidelyClient = class {
     this.cleanups.splice(0).forEach((fn) => fn());
     void this.queue?.flush();
     this.queue?.destroy();
+    this.outbox?.destroy();
     this.flags.destroy();
     this.emitter.clear();
     this.uiListeners.clear();
@@ -2135,6 +2801,7 @@ var GuidelyClient = class {
     for (const [id, s] of Object.entries(data.guideState || {})) {
       const local = guides[id];
       guides[id] = {
+        ...local,
         impressions: Math.max(local?.impressions ?? 0, s.impressions ?? 0),
         completedAt: local?.completedAt ?? s.completedAt ?? null,
         dismissedAt: local?.dismissedAt ?? s.dismissedAt ?? null,
@@ -2156,7 +2823,10 @@ var GuidelyClient = class {
       checklists,
       surveysSubmitted: Array.from(/* @__PURE__ */ new Set([...this.state.surveysSubmitted, ...data.surveysSubmitted || []])),
       audienceIds: data.audienceIds || [],
-      firstSeenAt: this.state.firstSeenAt ?? data.firstSeenAt
+      firstSeenAt: this.state.firstSeenAt ?? data.firstSeenAt,
+      // Device-local only (the server doesn't hold them).
+      ...this.state.throttle ? { throttle: this.state.throttle } : {},
+      ...this.state.announcementsSeenAt ? { announcementsSeenAt: this.state.announcementsSeenAt } : {}
     };
     if (data.firstSeenAt && Date.now() - Date.parse(data.firstSeenAt) > 6e4) this.firstVisit = false;
     this.persistState();
@@ -2248,6 +2918,8 @@ var GuidelyClient = class {
       ...extra
     };
     if (extra.properties) event.properties = sanitizeProperties(extra.properties);
+    const locale = extra.guideId ? this.guideLocales.get(extra.guideId) : void 0;
+    if (locale) event.properties = { ...event.properties ?? {}, locale };
     this.queue.enqueue(event);
     this.emitter.emit("track", event);
     return event;
@@ -2280,11 +2952,19 @@ var GuidelyClient = class {
     if (!name) return;
     this.whenHydrated(() => {
       const changed = name !== this.screenName;
+      if (changed) {
+        this.leaveScreen();
+        this.flushHeatmap();
+      }
       this.screenName = name;
       this.targets.setScreen(name);
       if (changed) this.syncFlagAttributes();
       const url = this.currentUrl();
-      if (changed) this.enqueue("page_view", { properties: { ...properties, path: url, screen: name } });
+      if (changed) {
+        this.screenStartedAt = Date.now();
+        this.screenLeft = this.backgroundedAt !== null;
+        if (this.pageviewsOn()) this.enqueue("page_view", { properties: { ...properties, path: url, screen: name, platform: this.bridge.device.platform } });
+      }
       this.completeChecklistTasksBy("url_visited", url);
       this.active?.controller.resume();
       this.flows.forEach((f) => f.controller.resume());
@@ -2312,6 +2992,149 @@ var GuidelyClient = class {
     if (this.isReady) this.evaluate("click", { targetId });
   }
   // ---------------------------------------------------------------------------
+  // Product analytics (autocapture)
+  // ---------------------------------------------------------------------------
+  captureAllowed() {
+    return !this.destroyed && this.analyticsEnabled();
+  }
+  /** A capability runs when the project enables it (absent on old servers → off), no option turns it off and analytics are allowed. */
+  autocaptureOn(key) {
+    const o = this.options.autocapture;
+    return !!this.config?.settings?.autocapture?.[key] && o !== false && !(typeof o === "object" && o?.[key] === false) && this.captureAllowed();
+  }
+  /** `page_view` from `screen()` predates autocapture: only an explicit opt-out stops it. */
+  pageviewsOn() {
+    const o = this.options.autocapture;
+    return this.config?.settings?.autocapture?.pageviews !== false && o !== false && !(typeof o === "object" && o?.pageviews === false);
+  }
+  /** 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"));
+  }
+  /**
+   * Records a tap observed by the provider: `click` for an interactive element, `rage_click` for
+   * bursts and a heatmap point. A registered `<GuidelyTarget>` whose frame contains the point
+   * (smallest wins) takes precedence over the resolved element and is reported as `#<id>`.
+   */
+  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 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));
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  async processTap(tap, t, url, on) {
+    let el = tap.element ?? null;
+    let rect = null;
+    const target = this.targets.ids().length ? await this.targets.hitTest(tap.x, tap.y) : null;
+    if (target) {
+      el = { selector: `#${target.id}`, tag: el?.tag ?? tap.hit?.tag ?? "View", text: el?.text };
+      rect = target.rect;
+    }
+    if (this.destroyed) return;
+    const platform = this.bridge.device.platform;
+    const maskAll = !!this.config?.settings?.replay?.maskAllText;
+    const eventUrl = this.collectUrls() && url ? url : void 0;
+    if (on.clicks && el) this.enqueue("click", { url: eventUrl, properties: { ...tapProperties(el, tap.x, tap.y, platform, maskAll) } });
+    const count = this.rage.add(tap.x, tap.y, t);
+    if (on.rage && count) this.enqueue("rage_click", { url: eventUrl, properties: { ...tapProperties(el ?? tap.hit ?? UNKNOWN_VIEW, tap.x, tap.y, platform, maskAll), count } });
+    if (!on.heat) return;
+    const burst = this.rage.burst;
+    if (el && !rect && el.measure) rect = await el.measure().catch(() => null);
+    if (this.destroyed) return;
+    if (this.heatmap.url !== url) this.flushHeatmap();
+    if (this.heatmap.add(url, heatmapPoint(tap.x, tap.y, el, rect, burst > 0), burst)) this.flushHeatmap();
+  }
+  /** Sends the buffered heatmap taps as one `heatmap` event attributed to the screen they happened on. */
+  flushHeatmap() {
+    const batch = this.heatmap.take();
+    if (!batch || !this.captureAllowed()) return;
+    const collect = this.collectUrls() && !!batch.url;
+    const { width, height } = this.windowSize();
+    this.enqueue("heatmap", {
+      url: collect ? batch.url : void 0,
+      properties: { ...collect ? { path: batch.url } : {}, viewportWidth: width, viewportHeight: height, pageHeight: height, platform: this.bridge.device.platform, points: batch.points }
+    });
+  }
+  windowSize() {
+    try {
+      const s = this.bridge.windowSize?.();
+      if (s && Number.isFinite(s.width) && Number.isFinite(s.height)) return { width: Math.round(s.width), height: Math.round(s.height) };
+    } catch {
+    }
+    return { width: 0, height: 0 };
+  }
+  /** Ends the foreground measurement of the current screen with a `page_leave` (once per measurement). */
+  leaveScreen() {
+    if (!this.screenName || this.screenLeft) return;
+    this.screenLeft = true;
+    if (!this.autocaptureOn("pageLeave")) return;
+    const url = this.currentUrl();
+    const collect = this.collectUrls();
+    this.enqueue("page_leave", {
+      url: collect ? url : void 0,
+      properties: { ...collect ? { path: url } : {}, screen: this.screenName, durationMs: Math.max(0, Date.now() - this.screenStartedAt), scrollDepth: 100, platform: this.bridge.device.platform }
+    });
+  }
+  /** `{ appVersion, build }` of this launch, without unknown keys. */
+  appInfo() {
+    const appVersion = this.options.appVersion ?? this.bridge.device.appVersion;
+    const build = this.options.appBuild;
+    return { ...appVersion ? { appVersion: String(appVersion) } : {}, ...build ? { build: String(build) } : {} };
+  }
+  /**
+   * Once per launch, as soon as a config is known: `app_install` / `app_update` from the stored
+   * version (when the app passes `appVersion` and `storage`), then `app_open` with `coldStart: true`.
+   */
+  checkLaunch() {
+    if (this.launchChecked || !this.config || this.destroyed || !this.hydrated) return;
+    this.launchChecked = true;
+    try {
+      const on = this.autocaptureOn("appLifecycle");
+      const info = this.appInfo();
+      if (info.appVersion && this.options.storage) {
+        const key = appVersionKey(this.options.projectId);
+        const stored = readJson(this.store, key, null);
+        if (!stored?.appVersion) {
+          if (!this.hadIdentity && on) this.enqueue("app_install", { properties: { ...info } });
+        } else if (stored.appVersion !== info.appVersion || !!stored.build && !!info.build && stored.build !== info.build) {
+          if (on) this.enqueue("app_update", { properties: { ...info, previousVersion: stored.appVersion, ...stored.build ? { previousBuild: stored.build } : {} } });
+        }
+        writeJson(this.store, key, info);
+      }
+      if (on) this.enqueue("app_open", { properties: { ...info, coldStart: true } });
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  wentToBackground() {
+    try {
+      this.leaveScreen();
+      this.flushHeatmap();
+      if (this.launchChecked && this.autocaptureOn("appLifecycle")) this.enqueue("app_background", { properties: { foregroundMs: Math.max(0, Date.now() - this.openedAt) } });
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  cameToForeground() {
+    try {
+      this.openedAt = Date.now();
+      if (this.launchChecked && this.autocaptureOn("appLifecycle")) this.enqueue("app_open", { properties: { ...this.appInfo(), coldStart: false } });
+      if (this.screenName && this.screenLeft) {
+        this.screenStartedAt = Date.now();
+        this.screenLeft = false;
+        if (this.pageviewsOn() && this.autocaptureOn("pageLeave")) this.enqueue("page_view", { properties: { path: this.currentUrl(), screen: this.screenName, platform: this.bridge.device.platform, resumed: true } });
+      }
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
   // Targeting + triggers
   // ---------------------------------------------------------------------------
   /** Builds the targeting context for the current moment. */
@@ -2358,6 +3181,50 @@ var GuidelyClient = class {
     if (guide.kind === "checklist") return !this.state.checklists[guide.id]?.dismissedAt;
     return isFrequencyEligible(guide.config.frequency, this.state.guides[guide.id], this.session.shownGuides.includes(guide.id));
   }
+  /** Guide throttling: may this guide launch automatically now? */
+  throttleAllows(guide) {
+    if (!countsTowardThrottle(guide)) return true;
+    return isThrottleEligible(this.config?.settings.throttling, this.state.throttle ?? []);
+  }
+  recordLaunch(guide, manual) {
+    if (manual || !countsTowardThrottle(guide) || !this.config?.settings.throttling?.enabled) return;
+    this.state.throttle = pruneLaunches([...this.state.throttle ?? [], nowIso()], this.config.settings.throttling);
+  }
+  /** Guides and A/B test control groups, which are evaluated the same way but never render. */
+  candidates() {
+    const guides = this.config?.guides ?? [];
+    const holdouts = this.config?.guideHoldouts ?? [];
+    return holdouts.length ? [...guides, ...holdouts.map((h) => h.guide)] : guides;
+  }
+  holdoutFor(guide) {
+    return this.config?.guideHoldouts?.find((h) => h.guide.id === guide.id) ?? null;
+  }
+  // ---------------------------------------------------------------------------
+  // Localization
+  // ---------------------------------------------------------------------------
+  /** The visitor's language candidates, most preferred first: `setLocale()` / `locale` option, traits, device. */
+  locales() {
+    return visitorLocales(this.locale, this.user?.traits, [this.bridge.device.locale]);
+  }
+  defaultLocale() {
+    return this.config?.settings?.localization?.defaultLocale || "en";
+  }
+  /** The guide in the visitor's language (remembered so its events carry `locale`). */
+  localize(guide) {
+    const localized = localizeGuide(guide, this.locales(), this.defaultLocale());
+    this.guideLocales.set(guide.id, localized.locale);
+    return localized;
+  }
+  /**
+   * Sets the language for guides and the resource center (`null` = back to the user's traits and
+   * the device language). Guides already on screen keep their language; the resource center re-renders.
+   */
+  setLocale(locale) {
+    const next = locale ? normalizeLocale(locale) || null : null;
+    if (next === this.locale) return;
+    this.locale = next;
+    this.notify();
+  }
   triggerFires(guide, reason, detail) {
     const t = guide.config.trigger;
     switch (t.type) {
@@ -2393,7 +3260,7 @@ var GuidelyClient = class {
       this.lastAudiences = current;
     }
     const candidates = [];
-    for (const guide of this.config.guides) {
+    for (const guide of this.candidates()) {
       const t = guide.config.trigger;
       if (detail.endedGuide && detail.endedGuide.id === guide.id) continue;
       if (reason === "ready" || reason === "navigation") {
@@ -2409,6 +3276,10 @@ var GuidelyClient = class {
       if (t.type === "page_load" && t.delayMs > 0 && reason === "timer" && detail.guideId !== guide.id) continue;
       if (!this.triggerFires(guide, reason, detail)) continue;
       if (!this.isEligible(guide, ctx, url)) continue;
+      if (!this.throttleAllows(guide)) {
+        this.log("throttled", guide.key);
+        continue;
+      }
       candidates.push(guide);
     }
     if (reason === "after_guide" || reason === "navigation") this.drainQueue(url, ctx);
@@ -2454,6 +3325,12 @@ var GuidelyClient = class {
   }
   tryShow(guide, url, manual) {
     if (this.destroyed) return false;
+    if (!manual && !this.throttleAllows(guide)) return false;
+    if (this.holdoutFor(guide)) {
+      if (this.hasExclusive() && !manual) return false;
+      this.recordImpression(guide, manual);
+      return true;
+    }
     if (!isExclusiveGuide(guide)) {
       if (this.flows.has(guide.id) || this.checklists.has(guide.id)) return false;
       this.show(guide, manual);
@@ -2495,14 +3372,18 @@ var GuidelyClient = class {
   guideState(id) {
     return this.state.guides[id] ?? (this.state.guides[id] = { impressions: 0 });
   }
-  recordImpression(guide) {
+  recordImpression(guide, manual = false) {
     const s = this.guideState(guide.id);
     s.impressions += 1;
     s.lastShownAt = nowIso();
     if (!this.session.shownGuides.includes(guide.id)) this.session.shownGuides.push(guide.id);
+    this.recordLaunch(guide, manual);
     this.persistState();
     this.persistSession();
-    this.syncGuideState(guide.id, { impression: true });
+    const holdout = this.holdoutFor(guide);
+    const experiment = holdout ? { id: holdout.experimentId, variantId: holdout.variantId } : guide.experiment;
+    if (experiment) this.enqueue("experiment_viewed", { properties: { guideExperimentId: experiment.id, variantId: experiment.variantId, ...holdout ? {} : { guideId: guide.id } } });
+    if (!holdout) this.syncGuideState(guide.id, { impression: true });
   }
   recordEnd(guide, reason) {
     const s = this.guideState(guide.id);
@@ -2513,7 +3394,13 @@ var GuidelyClient = class {
     if (reason === "completed") this.completeChecklistTasksBy("guide_completed", guide);
   }
   syncGuideState(guideId, update) {
-    void postWithRetry(this.api, "/guide-state", { anonymousId: this.anonymousId, userId: this.user?.id || null, updates: [{ guideId, ...update }] });
+    const body = { anonymousId: this.anonymousId, userId: this.user?.id || null, updates: [{ guideId, ...update }] };
+    if (update.impression) void postWithRetry(this.api, "/guide-state", body);
+    else this.sendDurably(`guide:${guideId}:${update.completed ? "completed" : "dismissed"}:${this.anonymousId}`, "/guide-state", body);
+  }
+  /** Queues a write in the persisted outbox (sent now, or once the API is reachable again). */
+  sendDurably(key, path, body) {
+    this.whenHydrated(() => this.outbox?.add(key, path, body));
   }
   show(guide, manual, stepId) {
     try {
@@ -2524,7 +3411,8 @@ var GuidelyClient = class {
       this.reportError(err);
     }
   }
-  showFlow(guide, manual, stepId) {
+  showFlow(raw, manual, stepId) {
+    const guide = this.localize(raw);
     const exclusive = isExclusiveGuide(guide);
     const flow = { guide, manual, view: null, controller: null };
     let renders = 0;
@@ -2539,7 +3427,7 @@ var GuidelyClient = class {
         const step = e.stepId ? guide.config.steps.find((s) => s.id === e.stepId) : void 0;
         this.enqueue(e.name, { guideId: guide.id, guideVersion: guide.version, stepId: e.stepId, stepIndex: e.stepIndex, properties: e.properties });
         if (e.name === "guide_started") {
-          this.recordImpression(guide);
+          this.recordImpression(guide, manual);
           this.emitter.emit("guide:start", guide);
         } else if (e.name === "step_viewed" && step) {
           this.emitter.emit("guide:step", { guide, stepId: step.id, stepIndex: e.stepIndex ?? 0 });
@@ -2586,21 +3474,24 @@ var GuidelyClient = class {
       if (this.flows.get(guide.id) === flow) this.flows.delete(guide.id);
     }
   }
-  showChecklist(guide, open) {
+  showChecklist(raw, open) {
+    if (!raw.config.checklist || this.checklists.has(raw.id)) return;
+    const guide = this.localize(raw);
     const config = guide.config.checklist;
-    if (!config || this.checklists.has(guide.id)) return;
+    if (!config) return;
     const progress = this.getChecklistProgress(guide.id);
     const first = !this.state.guides[guide.id]?.impressions;
-    this.checklists.set(guide.id, { open: open ?? (config.autoOpen && first && !progress.completedAt) });
+    this.checklists.set(guide.id, { guide, open: open ?? (config.autoOpen && first && !progress.completedAt) });
     if (first) this.recordImpression(guide);
     if (this.checklists.get(guide.id)?.open) this.enqueue("guide_viewed", { guideId: guide.id, guideVersion: guide.version });
     this.notify();
   }
-  showSurvey(guide, manual) {
-    if (!guide.config.survey) return;
+  showSurvey(raw, manual) {
+    if (!raw.config.survey) return;
+    const guide = this.localize(raw);
     this.activeSurvey = { guide, manual };
     this.surveyView = { key: `${guide.id}:${randomId(6)}`, guide, submitted: false };
-    this.recordImpression(guide);
+    this.recordImpression(guide, manual);
     this.enqueue("survey_displayed", { guideId: guide.id, guideVersion: guide.version });
     this.emitter.emit("guide:start", guide);
     this.notify();
@@ -2660,10 +3551,7 @@ var GuidelyClient = class {
     const steps = [];
     for (const f of [...this.flows.values(), ...this.active ? [this.active] : []]) if (f.view) steps.push({ ...f.view, expanded: this.expanded.has(f.guide.id) });
     const checklists = [];
-    this.checklists.forEach((w, id) => {
-      const guide = this.findGuide(id);
-      if (guide) checklists.push({ guide, progress: this.getChecklistProgress(id), open: w.open });
-    });
+    this.checklists.forEach((w, id) => checklists.push({ guide: w.guide, progress: this.getChecklistProgress(id), open: w.open }));
     this.ui = { steps, checklists, survey: this.surveyView, resourceCenterOpen: this.resourceCenterOpen, theme: this.themeFor(), messenger: !!this.messenger };
     for (const cb of Array.from(this.uiListeners)) {
       try {
@@ -2721,7 +3609,7 @@ var GuidelyClient = class {
     progress.dismissedAt = nowIso();
     this.persistState();
     this.enqueue("checklist_dismissed", { guideId: guide.id, guideVersion: guide.version });
-    void postWithRetry(this.api, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, dismissed: true });
+    this.sendDurably(`checklist:${guide.id}:dismissed:${this.anonymousId}`, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, dismissed: true });
     this.checklists.delete(guide.id);
     this.notify();
   }
@@ -2734,7 +3622,7 @@ var GuidelyClient = class {
     this.persistState();
     this.recordEnd(guide, "completed");
     this.enqueue("survey_submitted", { guideId: guide.id, guideVersion: guide.version, properties: { responseId } });
-    void postWithRetry(this.api, `/surveys/${encodeURIComponent(guide.id)}/responses`, { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, guideVersion: guide.version, answers, responseId });
+    this.sendDurably(`survey:${responseId}`, `/surveys/${encodeURIComponent(guide.id)}/responses`, { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, guideVersion: guide.version, answers, responseId });
     this.emitter.emit("survey:submit", { guide, answers, responseId });
     this.emitter.emit("guide:complete", guide);
     this.surveyView = { ...this.surveyView, submitted: true };
@@ -2748,10 +3636,58 @@ var GuidelyClient = class {
   getAudienceIds() {
     return this.state.audienceIds;
   }
+  /** The published resource center in the visitor's language, or null when it is off. */
   getResourceCenter() {
-    const rc = this.config?.resourceCenter;
+    const rc = this.localizedResourceCenter();
     return rc && rc.enabled ? rc : null;
   }
+  /** The resource center in the visitor's language (cached until the config or language changes). */
+  localizedResourceCenter() {
+    const rc = this.config?.resourceCenter;
+    if (!rc) return null;
+    const locales = this.locales();
+    const key = `${locales.join(",")}|${this.defaultLocale()}`;
+    if (this.localizedRc?.source !== rc || this.localizedRc.locales !== key) this.localizedRc = { source: rc, locales: key, value: localizeResourceCenter(rc, locales, this.defaultLocale()) };
+    return this.localizedRc.value;
+  }
+  /** Evaluates targeting rules (e.g. a resource-center section's) for the current visitor and screen. */
+  matchesTargeting(rules) {
+    if (!rules) return true;
+    try {
+      return evaluateRules(rules, this.getContext());
+    } catch (err) {
+      this.reportError(err);
+      return false;
+    }
+  }
+  /** Resource-center sections this visitor sees, in order (disabled and non-matching ones left out). */
+  getResourceCenterModules() {
+    const rc = this.getResourceCenter();
+    if (!rc) return [];
+    return orderedModules(rc.modules).filter((m) => m.enabled && (!("targeting" in m) || this.matchesTargeting(m.targeting))).map((m) => m.id);
+  }
+  /**
+   * Sections of the messenger's Help tab, in order: the resource center's modules without "What's
+   * new" (the messenger has its own News tab); every section when no resource center is published.
+   */
+  getHelpModules() {
+    const modules = this.getResourceCenter() ? this.getResourceCenterModules() : [...RC_MODULE_IDS];
+    return modules.filter((id) => id !== "announcements");
+  }
+  /** "What's new" entries this visitor sees (newest first); empty when the section is off. */
+  getAnnouncements() {
+    const rc = this.getResourceCenter();
+    if (!rc || !this.getResourceCenterModules().includes("announcements")) return [];
+    return visibleAnnouncements(rc.announcements, this.state.audienceIds);
+  }
+  /** "What's new" entries published since the visitor last opened the resource center. */
+  getUnreadAnnouncements() {
+    return unreadAnnouncements(this.getAnnouncements(), this.state.announcementsSeenAt);
+  }
+  /** Whether an entry is new to the visitor in the resource center that is open now. */
+  isAnnouncementNew(a) {
+    return unreadAnnouncements([a], this.announcementsSeenAtOpen) > 0;
+  }
   async searchResourceCenter(q) {
     try {
       const res = await this.api.get("/resource-center/search", { params: { q } });
@@ -2760,6 +3696,11 @@ var GuidelyClient = class {
       return [];
     }
   }
+  /** The language of the resource center as shown, when it isn't the default (sent with article fetches). */
+  articleLocale() {
+    const locale = this.localizedResourceCenter()?.locale;
+    return locale && locale.toLowerCase() !== this.defaultLocale().toLowerCase() ? locale : void 0;
+  }
   articleViewed(article) {
     this.enqueue("article_viewed", { properties: { articleId: article.id, slug: article.slug } });
   }
@@ -2791,7 +3732,7 @@ var GuidelyClient = class {
       this.enqueue("checklist_completed", { guideId: guide.id, guideVersion: guide.version });
     }
     this.persistState();
-    void postWithRetry(this.api, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, completed: !!progress.completedAt });
+    this.sendDurably(`checklist:${guide.id}:progress:${this.anonymousId}`, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, completed: !!progress.completedAt });
     this.emitter.emit("checklist:task", { guide, task, progress: this.getChecklistProgress(guide.id) });
     if (complete) {
       this.emitter.emit("checklist:complete", guide);
@@ -2894,6 +3835,11 @@ var GuidelyClient = class {
     }
     if (this.resourceCenterOpen) return;
     this.resourceCenterOpen = true;
+    this.announcementsSeenAtOpen = this.state.announcementsSeenAt ?? null;
+    if (this.getAnnouncements().length) {
+      this.state.announcementsSeenAt = nowIso();
+      this.persistState();
+    }
     this.enqueue("resource_center_opened");
     this.emitter.emit("resource-center:open");
     this.notify();
@@ -2928,7 +3874,9 @@ var GuidelyClient = class {
           },
           onMessage: (message, conversation) => this.emitter.emit("conversation:message", { message, conversation }),
           onStartGuide: (key) => this.setTimer(() => this.startGuide(key), 0),
-          onError: (err) => this.log("messenger", err instanceof Error ? err.message : err)
+          onError: (err) => this.log("messenger", err instanceof Error ? err.message : err),
+          health: this.api.health,
+          locale: () => this.articleLocale()
         });
         this.resourceCenterOpen = false;
       }
@@ -3033,6 +3981,7 @@ var GuidelyClient = class {
       audienceIds: this.state.audienceIds,
       session: this.session,
       pendingEvents: this.queue?.size ?? 0,
+      pendingWrites: this.outbox?.size ?? 0,
       targets: this.targets.ids(),
       flagsReady: this.flags.isReady()
     };
@@ -3061,7 +4010,191 @@ var GuidelyClient = class {
   }
 };
 function forPlatform(config, platform) {
-  return config.guides.every((g) => supportsPlatform(g.config, platform)) ? config : { ...config, guides: config.guides.filter((g) => supportsPlatform(g.config, platform)) };
+  const keep = (g) => supportsPlatform(g.config, platform);
+  const holdouts = config.guideHoldouts?.filter((h) => keep(h.guide)).map((h) => ({ ...h, guide: withoutCode(h.guide) }));
+  return { ...config, guides: config.guides.filter(keep).map(withoutCode), ...holdouts ? { guideHoldouts: holdouts } : {} };
+}
+function withoutCode(guide) {
+  if (!guide.config.steps.some((s) => s.code)) return guide;
+  return { ...guide, config: { ...guide.config, steps: guide.config.steps.map(({ code: _code, ...step }) => step) } };
+}
+
+// src/ui/Autocapture.tsx
+import { useMemo as useMemo5, useRef as useRef5 } from "react";
+import { View as View10 } from "react-native";
+
+// src/core/viewTree.ts
+var HOST_TEXT = 6;
+var MAX_ANCESTORS = 500;
+var MAX_TEXT_NODES = 300;
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set(["button", "link", "tab", "menuitem", "checkbox", "switch", "radio", "togglebutton", "imagebutton", "option", "combobox", "adjustable"]);
+var TEXT_INPUT_HOST = /TextInput/i;
+var NOISE = /^(Anonymous|Unknown|ForwardRef|Memo|Context|Provider|Consumer|Fragment|StrictMode|Suspense|Profiler)$|Context$|Provider$|Consumer$/;
+var isFiber = (v) => !!v && typeof v === "object" && "return" in v && "memoizedProps" in v;
+function fiberFromEvent(event) {
+  try {
+    const e = event;
+    if (isFiber(e?._targetInst)) return e._targetInst;
+    const target = e?.target;
+    if (!target || typeof target !== "object") return null;
+    for (const key of ["__internalInstanceHandle", "_internalInstanceHandle", "_internalFiberInstanceHandleDEV"]) if (isFiber(target[key])) return target[key];
+    for (const sym of Object.getOwnPropertySymbols(target)) if (sym.description === "internalInstanceHandle" && isFiber(target[sym])) return target[sym];
+  } catch {
+  }
+  return null;
+}
+function componentName(type, depth = 0) {
+  if (!type || depth > 3) return null;
+  if (typeof type === "function") {
+    const f = type;
+    const n = typeof f.displayName === "string" && f.displayName ? f.displayName : typeof f.name === "string" ? f.name : "";
+    return n || null;
+  }
+  if (typeof type === "object") {
+    const o = type;
+    if (typeof o.displayName === "string" && o.displayName) return o.displayName;
+    return componentName(o.render, depth + 1) ?? componentName(o.type, depth + 1);
+  }
+  return null;
+}
+var isHost = (f) => typeof f.type === "string";
+var isTextInput = (f) => typeof f.type === "string" ? TEXT_INPUT_HOST.test(f.type) : componentName(f.type) === "TextInput";
+function isInteractive(props) {
+  if (!props || typeof props !== "object") return null;
+  if (typeof props.onPress === "function" || typeof props.onLongPress === "function") return "press";
+  const role = props.accessibilityRole ?? props.role;
+  return typeof role === "string" && INTERACTIVE_ROLES.has(role) ? "role" : null;
+}
+function firstHost(f) {
+  let cur = f;
+  for (let i = 0; cur && i < 30; i++, cur = cur.child) if (isHost(cur)) return cur;
+  return null;
+}
+function idSelector(f) {
+  const host = firstHost(f);
+  const sources = [f.memoizedProps, host?.memoizedProps];
+  for (const key of ["nativeID", "testID"]) {
+    for (const p of sources) {
+      const v = p && typeof p === "object" ? p[key] : void 0;
+      if (typeof v === "string" && v) return attrSelector(key, v);
+    }
+  }
+  return null;
+}
+function pathSelector(f) {
+  const parts = [];
+  let cur = f;
+  for (let i = 0; cur && parts.length < 4 && i < MAX_ANCESTORS; i++, cur = cur.return) {
+    if (isHost(cur)) continue;
+    const name = componentName(cur.type);
+    if (!name || NOISE.test(name)) continue;
+    let same = 0;
+    let index = 0;
+    for (let s = cur.return?.child, n = 0; s && n < 500; s = s.sibling, n++) {
+      if (s.type !== cur.type) continue;
+      same += 1;
+      if (s === cur) index = same;
+    }
+    parts.unshift(same > 1 && index ? `${name}:nth-of-type(${index})` : name);
+  }
+  return parts.join(" > ").slice(0, 300) || "View";
+}
+function subtreeText(f, opts) {
+  const out = [];
+  let visited = 0;
+  let masked = false;
+  const walk = (node) => {
+    for (let n = node; n && visited < MAX_TEXT_NODES && !masked; n = n.sibling) {
+      visited += 1;
+      if (opts.isMask?.(n.type)) {
+        masked = true;
+        return;
+      }
+      if (isTextInput(n)) continue;
+      if (n.tag === HOST_TEXT && (typeof n.memoizedProps === "string" || typeof n.memoizedProps === "number")) out.push(String(n.memoizedProps));
+      else walk(n.child);
+    }
+  };
+  if (opts.isMask?.(f.type)) return { text: "", masked: true };
+  walk(f.child);
+  return { text: out.join(" "), masked };
+}
+function measureHost(host) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    const timer = setTimeout(() => done(null), 500);
+    const cb = (x, y, width, height) => done(Number.isFinite(x) && Number.isFinite(y) && width > 0 && height > 0 ? { x, y, width, height } : null);
+    try {
+      const sn = host.stateNode;
+      const pub = sn?.canonical?.publicInstance ?? sn;
+      if (pub && typeof pub.measureInWindow === "function") return pub.measureInWindow(cb);
+      const ui = globalThis.nativeFabricUIManager;
+      if (sn?.node && typeof ui?.measureInWindow === "function") return ui.measureInWindow(sn.node, cb);
+    } catch {
+    }
+    done(null);
+  });
+}
+function describe(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" };
+  if (withText && !masked) {
+    const sub = subtreeText(f, opts);
+    if (!sub.masked) {
+      const hostProps = host?.memoizedProps && typeof host.memoizedProps === "object" ? host.memoizedProps : {};
+      const label = props.accessibilityLabel ?? props["aria-label"] ?? hostProps.accessibilityLabel ?? hostProps["aria-label"];
+      const text = cleanText(sub.text) ?? (typeof label === "string" ? cleanText(label) : void 0);
+      if (text) el.text = text;
+    }
+  }
+  if (host) el.measure = () => measureHost(host);
+  return el;
+}
+function resolveFiber(target, opts = {}) {
+  const none = { ignored: false, element: null, hit: null };
+  if (!target) return none;
+  try {
+    let press = null;
+    let role = null;
+    let hitFiber = null;
+    let stopped = false;
+    let masked = false;
+    for (let f = target, i = 0; f && i < MAX_ANCESTORS; f = f.return, i++) {
+      if (opts.isIgnored?.(f.type)) return { ignored: true, element: null, hit: null };
+      if (opts.isMask?.(f.type)) masked = true;
+      if (stopped) continue;
+      if (isTextInput(f)) {
+        stopped = true;
+        continue;
+      }
+      if (isHost(f)) continue;
+      const name = componentName(f.type);
+      if (!hitFiber && name && !NOISE.test(name)) hitFiber = f;
+      const kind = isInteractive(f.memoizedProps);
+      if (kind === "press") {
+        press = f;
+        stopped = true;
+      } else if (kind === "role" && !role) role = f;
+    }
+    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
+    };
+  } catch {
+    return none;
+  }
+}
+function resolveTapTarget(event, opts = {}) {
+  return resolveFiber(fiberFromEvent(event), opts);
 }
 
 // src/ui/Overlay.tsx
@@ -3585,9 +4718,9 @@ var styles3 = StyleSheet3.create({
 });
 
 // src/ui/Messenger.tsx
-import { useCallback, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState3, useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { Fragment as Fragment2, useCallback, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState3, useSyncExternalStore as useSyncExternalStore2 } from "react";
 import { ActivityIndicator, Keyboard, Modal as Modal2, Platform as Platform2, Pressable as Pressable4, ScrollView as ScrollView3, StyleSheet as StyleSheet4, Text as Text4, TextInput, View as View4 } from "react-native";
-import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 function useMessenger(store) {
   return useSyncExternalStore2(
     useCallback((cb) => store.subscribe(cb), [store]),
@@ -3821,25 +4954,41 @@ function Help({ store, client, palette: p }) {
   ] }, title);
   const audiences = client.getAudienceIds();
   const sections = resourceCenterSections(articles?.collections ?? [], articles?.articles ?? [], audiences);
-  const listed = results?.filter((a) => isArticleListed(articles?.collections ?? [], a, audiences));
+  const modules = client.getHelpModules();
+  const searchOn = modules.includes("search");
+  const listed = searchOn ? results?.filter((a) => isArticleListed(articles?.collections ?? [], a, audiences)) : void 0;
+  const checklists = (rc?.checklistGuideIds ?? []).map((id) => guides.find((g) => g.id === id || g.key === id)).filter((g) => !!g && g.kind === "checklist");
+  const renderModule = (id) => {
+    switch (id) {
+      case "guides":
+        return recommended.length ? section("Recommended", recommended.map((g) => row(g.id, g.name, void 0, () => store.startGuide(g.key), "\u25B6"))) : null;
+      case "checklists":
+        return checklists.length ? section("Checklists", checklists.map((g) => row(g.id, g.name, void 0, () => store.startGuide(g.key), "\u2611"))) : null;
+      case "articles":
+        return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+          !articles ? /* @__PURE__ */ jsx5(ActivityIndicator, { color: p.muted }) : null,
+          sections.map((s) => section(s.collection ? s.path.join(" \u203A ") : "Articles", s.articles.map((a) => row(a.id, a.title, a.summary, () => open(a)))))
+        ] });
+      case "faqs":
+        return rc?.faqs.length ? section(
+          "FAQ",
+          rc.faqs.map((f) => /* @__PURE__ */ jsxs3(View4, { style: [styles4.row, styles4.faq, { borderColor: p.border }], children: [
+            /* @__PURE__ */ jsxs3(Pressable4, { accessibilityRole: "button", accessibilityState: { expanded: faq === f.id }, onPress: () => setFaq(faq === f.id ? null : f.id), style: styles4.faqHead, children: [
+              /* @__PURE__ */ jsx5(Text4, { style: [styles4.rowTitle, styles4.flex, { color: p.text }], children: f.question }),
+              /* @__PURE__ */ jsx5(Text4, { style: [styles4.chev, { color: p.muted }], children: faq === f.id ? "\u2212" : "+" })
+            ] }),
+            faq === f.id ? /* @__PURE__ */ jsx5(RichText, { html: f.answer, palette: p, onLink: (u) => client.navigate(u), size: 14 }) : null
+          ] }, f.id))
+        ) : null;
+      case "links":
+        return rc?.links.length ? section("Links", rc.links.map((l) => row(l.id, l.label, void 0, () => client.navigate(l.url), "\u2197"))) : null;
+      default:
+        return null;
+    }
+  };
   return /* @__PURE__ */ jsxs3(ScrollView3, { contentContainerStyle: styles4.content, keyboardShouldPersistTaps: "handled", children: [
-    /* @__PURE__ */ jsx5(TextInput, { value: q, onChangeText: setQ, placeholder: "Search articles", placeholderTextColor: p.muted, accessibilityLabel: "Search help articles", returnKeyType: "search", style: [styles4.search, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(10, p.radius) }] }),
-    listed ? section(`Results for \u201C${q.trim()}\u201D`, listed.length ? listed.map((a) => row(a.id, a.title, a.summary, () => open(a))) : /* @__PURE__ */ jsx5(Text4, { style: [styles4.rowSub, { color: p.muted }], children: "No articles found." })) : /* @__PURE__ */ jsxs3(Fragment2, { children: [
-      recommended.length ? section("Recommended", recommended.map((g) => row(g.id, g.name, void 0, () => store.startGuide(g.key), "\u25B6"))) : null,
-      !articles ? /* @__PURE__ */ jsx5(ActivityIndicator, { color: p.muted }) : null,
-      sections.map((s) => section(s.collection ? s.path.join(" \u203A ") : "Articles", s.articles.map((a) => row(a.id, a.title, a.summary, () => open(a))))),
-      rc?.faqs.length ? section(
-        "FAQ",
-        rc.faqs.map((f) => /* @__PURE__ */ jsxs3(View4, { style: [styles4.row, styles4.faq, { borderColor: p.border }], children: [
-          /* @__PURE__ */ jsxs3(Pressable4, { accessibilityRole: "button", accessibilityState: { expanded: faq === f.id }, onPress: () => setFaq(faq === f.id ? null : f.id), style: styles4.faqHead, children: [
-            /* @__PURE__ */ jsx5(Text4, { style: [styles4.rowTitle, styles4.flex, { color: p.text }], children: f.question }),
-            /* @__PURE__ */ jsx5(Text4, { style: [styles4.chev, { color: p.muted }], children: faq === f.id ? "\u2212" : "+" })
-          ] }),
-          faq === f.id ? /* @__PURE__ */ jsx5(RichText, { html: f.answer, palette: p, onLink: (u) => client.navigate(u), size: 14 }) : null
-        ] }, f.id))
-      ) : null,
-      rc?.links.length ? section("Links", rc.links.map((l) => row(l.id, l.label, void 0, () => client.navigate(l.url), "\u2197"))) : null
-    ] })
+    searchOn ? /* @__PURE__ */ jsx5(TextInput, { value: q, onChangeText: setQ, placeholder: "Search articles", placeholderTextColor: p.muted, accessibilityLabel: "Search help articles", returnKeyType: "search", style: [styles4.search, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(10, p.radius) }] }) : null,
+    listed ? section(`Results for \u201C${q.trim()}\u201D`, listed.length ? listed.map((a) => row(a.id, a.title, a.summary, () => open(a))) : /* @__PURE__ */ jsx5(Text4, { style: [styles4.rowSub, { color: p.muted }], children: "No articles found." })) : /* @__PURE__ */ jsx5(Fragment3, { children: modules.filter((id) => id !== "search").map((id) => /* @__PURE__ */ jsx5(Fragment2, { children: renderModule(id) }, id)) })
   ] });
 }
 function Article({ article, palette: p, client }) {
@@ -3906,9 +5055,9 @@ var styles4 = StyleSheet4.create({
 });
 
 // src/ui/ResourceCenter.tsx
-import { useEffect as useEffect4, useMemo as useMemo4, useState as useState4 } from "react";
+import { Fragment as Fragment4, useEffect as useEffect4, useMemo as useMemo4, useState as useState4 } from "react";
 import { Modal as Modal3, Platform as Platform3, Pressable as Pressable5, ScrollView as ScrollView4, StyleSheet as StyleSheet5, Text as Text5, TextInput as TextInput2, View as View5 } from "react-native";
-import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 function ResourceCenter({ client, palette: p, open, topInset, bottomInset }) {
   const rc = client.getResourceCenter();
   const [query, setQuery] = useState4("");
@@ -3942,6 +5091,8 @@ function ResourceCenter({ client, palette: p, open, topInset, bottomInset }) {
   const checklists = useMemo4(() => (rc?.checklistGuideIds ?? []).map((id) => guides.find((g) => g.id === id || g.key === id)).filter((g) => !!g && g.kind === "checklist"), [rc, guides]);
   if (!rc) return null;
   const close = () => client.closeResourceCenter();
+  const modules = client.getResourceCenterModules();
+  const announcements = client.getAnnouncements();
   const openArticle = (a) => {
     if (a.externalUrl) return client.navigate(a.externalUrl);
     client.articleViewed(a);
@@ -3960,7 +5111,51 @@ function ResourceCenter({ client, palette: p, open, topInset, bottomInset }) {
   ] }, title);
   const audiences = client.getAudienceIds();
   const sections = resourceCenterSections(rc.collections, rc.articles, audiences);
-  const listed = results?.filter((a) => isArticleListed(rc.collections, a, audiences));
+  const listed = modules.includes("search") ? results?.filter((a) => isArticleListed(rc.collections, a, audiences)) : void 0;
+  const link = (label, onPress) => /* @__PURE__ */ jsx6(Pressable5, { accessibilityRole: "button", accessibilityLabel: label, onPress, hitSlop: 8, children: /* @__PURE__ */ jsx6(Text5, { style: [styles5.link, { color: p.primary }], children: label }) }, label);
+  const announcement2 = (a) => {
+    const linked = a.articleId ? rc.articles.find((x) => x.id === a.articleId) : void 0;
+    const isNew = client.isAnnouncementNew(a);
+    return /* @__PURE__ */ jsxs4(View5, { style: [styles5.row, styles5.faq, { borderColor: p.border }], children: [
+      /* @__PURE__ */ jsxs4(View5, { style: styles5.faqHead, children: [
+        /* @__PURE__ */ jsx6(Text5, { accessibilityRole: "header", style: [styles5.rowTitle, styles5.flex, { color: p.text, fontFamily: p.fontFamily }], children: a.title }),
+        isNew ? /* @__PURE__ */ jsx6(Text5, { style: [styles5.badge, { color: p.onPrimary, backgroundColor: p.primary }], children: "NEW" }) : null
+      ] }),
+      a.body ? /* @__PURE__ */ jsx6(RichText, { html: a.body, palette: p, onLink: (u) => client.navigate(u), size: 14 }) : null,
+      a.guideId || linked || a.url ? /* @__PURE__ */ jsxs4(View5, { style: styles5.links, children: [
+        a.guideId ? link("Show me", () => (close(), client.startGuide(a.guideId))) : null,
+        linked ? link("Read more", () => openArticle(linked)) : null,
+        a.url ? link(a.linkLabel || "Learn more", () => client.navigate(a.url)) : null
+      ] }) : null
+    ] }, a.id);
+  };
+  const renderModule = (id) => {
+    switch (id) {
+      case "announcements":
+        return announcements.length ? section("What's new", announcements.map(announcement2)) : null;
+      case "guides":
+        return recommended.length ? section("Recommended", recommended.map((g) => row(g.id, g.name, void 0, () => (close(), client.startGuide(g.id)), "\u25B6"))) : null;
+      case "checklists":
+        return checklists.length ? section("Checklists", checklists.map((g) => row(g.id, g.name, void 0, () => (close(), client.openChecklist(g.id)), "\u2611"))) : null;
+      case "articles":
+        return sections.map((s) => section(s.collection ? s.path.join(" \u203A ") : "Articles", s.articles.map((a) => row(a.id, a.title, a.summary, () => openArticle(a)))));
+      case "faqs":
+        return rc.faqs.length ? section(
+          "FAQ",
+          rc.faqs.map((f) => /* @__PURE__ */ jsxs4(View5, { style: [styles5.row, styles5.faq, { borderColor: p.border }], children: [
+            /* @__PURE__ */ jsxs4(Pressable5, { accessibilityRole: "button", accessibilityState: { expanded: faq === f.id }, onPress: () => setFaq(faq === f.id ? null : f.id), style: styles5.faqHead, children: [
+              /* @__PURE__ */ jsx6(Text5, { style: [styles5.rowTitle, styles5.flex, { color: p.text }], children: f.question }),
+              /* @__PURE__ */ jsx6(Text5, { style: [styles5.chev, { color: p.muted }], children: faq === f.id ? "\u2212" : "+" })
+            ] }),
+            faq === f.id ? /* @__PURE__ */ jsx6(RichText, { html: f.answer, palette: p, onLink: (u) => client.navigate(u), size: 14 }) : null
+          ] }, f.id))
+        ) : null;
+      case "links":
+        return rc.links.length ? section("Links", rc.links.map((l) => row(l.id, l.label, void 0, () => client.navigate(l.url), "\u2197"))) : null;
+      default:
+        return null;
+    }
+  };
   return /* @__PURE__ */ jsx6(Modal3, { visible: open, animationType: "slide", presentationStyle: Platform3.OS === "ios" ? "pageSheet" : "fullScreen", onRequestClose: () => article ? setArticle(null) : close(), children: /* @__PURE__ */ jsxs4(View5, { style: [styles5.sheet, { backgroundColor: p.background, paddingTop: Platform3.OS === "ios" ? 8 : topInset }], children: [
     /* @__PURE__ */ jsxs4(View5, { style: [styles5.header, { borderColor: p.border }], children: [
       article ? /* @__PURE__ */ jsx6(Pressable5, { accessibilityRole: "button", accessibilityLabel: "Back", onPress: () => setArticle(null), hitSlop: 10, children: /* @__PURE__ */ jsx6(Text5, { style: [styles5.back, { color: p.primary }], children: "\u2039 Back" }) }) : null,
@@ -3971,7 +5166,7 @@ function ResourceCenter({ client, palette: p, open, topInset, bottomInset }) {
       /* @__PURE__ */ jsx6(Text5, { accessibilityRole: "header", style: [styles5.articleTitle, { color: p.text, fontFamily: p.fontFamily }], children: article.title }),
       /* @__PURE__ */ jsx6(RichText, { html: article.body, palette: p, onLink: (u) => client.navigate(u) })
     ] }) : /* @__PURE__ */ jsxs4(ScrollView4, { contentContainerStyle: [styles5.content, { paddingBottom: bottomInset + 24 }], keyboardShouldPersistTaps: "handled", children: [
-      /* @__PURE__ */ jsx6(
+      modules.includes("search") ? /* @__PURE__ */ jsx6(
         TextInput2,
         {
           value: query,
@@ -3983,26 +5178,11 @@ function ResourceCenter({ client, palette: p, open, topInset, bottomInset }) {
           returnKeyType: "search",
           style: [styles5.search, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(10, p.radius) }]
         }
-      ),
+      ) : null,
       listed ? section(
         `Results for \u201C${query.trim()}\u201D`,
         listed.length ? listed.map((a) => row(a.id, a.title, a.summary, () => openArticle(a))) : /* @__PURE__ */ jsx6(Text5, { style: [styles5.rowSub, { color: p.muted }], children: "No articles found." })
-      ) : /* @__PURE__ */ jsxs4(Fragment3, { children: [
-        recommended.length ? section("Recommended", recommended.map((g) => row(g.id, g.name, void 0, () => (close(), client.startGuide(g.id)), "\u25B6"))) : null,
-        checklists.length ? section("Checklists", checklists.map((g) => row(g.id, g.name, void 0, () => (close(), client.openChecklist(g.id)), "\u2611"))) : null,
-        sections.map((s) => section(s.collection ? s.path.join(" \u203A ") : "Articles", s.articles.map((a) => row(a.id, a.title, a.summary, () => openArticle(a))))),
-        rc.faqs.length ? section(
-          "FAQ",
-          rc.faqs.map((f) => /* @__PURE__ */ jsxs4(View5, { style: [styles5.row, styles5.faq, { borderColor: p.border }], children: [
-            /* @__PURE__ */ jsxs4(Pressable5, { accessibilityRole: "button", accessibilityState: { expanded: faq === f.id }, onPress: () => setFaq(faq === f.id ? null : f.id), style: styles5.faqHead, children: [
-              /* @__PURE__ */ jsx6(Text5, { style: [styles5.rowTitle, styles5.flex, { color: p.text }], children: f.question }),
-              /* @__PURE__ */ jsx6(Text5, { style: [styles5.chev, { color: p.muted }], children: faq === f.id ? "\u2212" : "+" })
-            ] }),
-            faq === f.id ? /* @__PURE__ */ jsx6(RichText, { html: f.answer, palette: p, onLink: (u) => client.navigate(u), size: 14 }) : null
-          ] }, f.id))
-        ) : null,
-        rc.links.length ? section("Links", rc.links.map((l) => row(l.id, l.label, void 0, () => client.navigate(l.url), "\u2197"))) : null
-      ] })
+      ) : /* @__PURE__ */ jsx6(Fragment5, { children: modules.filter((id) => id !== "search").map((id) => /* @__PURE__ */ jsx6(Fragment4, { children: renderModule(id) }, id)) })
     ] })
   ] }) });
 }
@@ -4022,7 +5202,10 @@ var styles5 = StyleSheet5.create({
   chev: { fontSize: 18 },
   faq: { flexDirection: "column", alignItems: "stretch" },
   faqHead: { flexDirection: "row", alignItems: "center", gap: 10 },
-  articleTitle: { fontSize: 22, fontWeight: "700" }
+  articleTitle: { fontSize: 22, fontWeight: "700" },
+  badge: { fontSize: 10, fontWeight: "800", letterSpacing: 0.5, paddingHorizontal: 6, paddingVertical: 2, borderRadius: 6, overflow: "hidden" },
+  links: { flexDirection: "row", flexWrap: "wrap", gap: 16, marginTop: 4 },
+  link: { fontSize: 14, fontWeight: "600" }
 });
 
 // src/ui/StepLayer.tsx
@@ -4076,7 +5259,19 @@ function StepCard({ view, client, palette: p, width, style, compact }) {
   const showProgress = step.showProgress && view.total > 1;
   const onLink = (url) => client.navigate(url);
   return /* @__PURE__ */ jsx7(Surface, { palette: p, style: [{ width }, style], children: /* @__PURE__ */ jsxs5(View6, { accessible: false, accessibilityViewIsModal: view.asModal || step.type === "modal", style: compact ? styles6.compact : styles6.inner, children: [
-    step.imageUrl ? /* @__PURE__ */ jsx7(Image2, { source: { uri: step.imageUrl }, style: [styles6.image, { borderRadius: Math.max(0, p.radius - 4) }], resizeMode: "cover", accessibilityIgnoresInvertColors: true }) : null,
+    step.imageUrl ? (
+      // An empty description marks the image as decorative: screen readers skip it.
+      /* @__PURE__ */ jsx7(
+        Image2,
+        {
+          source: { uri: step.imageUrl },
+          style: [styles6.image, { borderRadius: Math.max(0, p.radius - 4) }],
+          resizeMode: "cover",
+          accessibilityIgnoresInvertColors: true,
+          ...step.imageAlt?.trim() ? { accessible: true, accessibilityRole: "image", accessibilityLabel: step.imageAlt.trim() } : { accessible: false, importantForAccessibility: "no" }
+        }
+      )
+    ) : null,
     step.title ? /* @__PURE__ */ jsxs5(View6, { style: styles6.header, children: [
       /* @__PURE__ */ jsx7(Text6, { accessibilityRole: "header", style: [styles6.title, { color: p.text, fontFamily: p.fontFamily }], children: step.title }),
       step.showClose ? /* @__PURE__ */ jsx7(CloseButton, { palette: p, onPress: () => client.closeStep(guide.id), label: "Dismiss guide" }) : null
@@ -4674,18 +5869,22 @@ function GuidelyOverlay({ client, insets: insetsProp, launcherOffset }) {
   const basePalette = palette(ui.theme, scheme);
   const messenger = ui.messenger ? client.getMessenger() : null;
   const showRcLauncher = !messenger && !!client.options.showResourceCenterLauncher && !!client.getResourceCenter();
+  const unread = showRcLauncher ? client.getUnreadAnnouncements() : 0;
   const messengerLeft = messenger?.getSnapshot().config.launcher.position === "bottom-left";
   const checklistOnSameSide = ui.checklists.some((c) => c.guide.config.checklist?.position === "bottom-left" === messengerLeft) && client.options.showChecklistLauncher !== false;
   return /* @__PURE__ */ jsxs8(View9, { ref, collapsable: false, pointerEvents: "box-none", style: StyleSheet9.absoluteFill, onLayout: measureOrigin, children: [
     ui.checklists.map((c) => /* @__PURE__ */ jsx10(Checklist, { view: c, client, palette: palette(client.themeFor(c.guide), scheme), geometry, showLauncher: client.options.showChecklistLauncher !== false, launcherBottom: launcherOffset }, c.guide.id)),
-    showRcLauncher ? /* @__PURE__ */ jsx10(
+    showRcLauncher ? /* @__PURE__ */ jsxs8(
       Pressable8,
       {
         accessibilityRole: "button",
-        accessibilityLabel: client.getResourceCenter()?.launcher.label || "Help",
+        accessibilityLabel: rcLauncherLabel(client),
         onPress: () => client.openResourceCenter(),
         style: [styles9.rc, client.getResourceCenter()?.launcher.position === "bottom-left" ? { left: insets.left + 16 } : { right: insets.right + 16 }, { bottom: insets.bottom + launcherOffset + (ui.checklists.length ? 56 : 0), backgroundColor: basePalette.primary }],
-        children: /* @__PURE__ */ jsx10(Text8, { style: [styles9.rcText, { color: basePalette.onPrimary }], children: "?" })
+        children: [
+          /* @__PURE__ */ jsx10(Text8, { style: [styles9.rcText, { color: basePalette.onPrimary }], children: "?" }),
+          unread ? /* @__PURE__ */ jsx10(View9, { pointerEvents: "none", style: [styles9.rcBadge, { borderColor: basePalette.primary }], children: /* @__PURE__ */ jsx10(Text8, { style: styles9.rcBadgeText, children: unread > 9 ? "9+" : unread }) }) : null
+        ]
       }
     ) : null,
     messenger && client.options.showMessengerLauncher !== false ? /* @__PURE__ */ jsx10(MessengerLauncher, { store: messenger, palette: basePalette, style: [messengerLeft ? { left: insets.left + 16 } : { right: insets.right + 16 }, { bottom: insets.bottom + launcherOffset + (checklistOnSameSide ? 56 : 0) }] }) : null,
@@ -4696,27 +5895,75 @@ function GuidelyOverlay({ client, insets: insetsProp, launcherOffset }) {
 }
 var styles9 = StyleSheet9.create({
   rc: { position: "absolute", width: 48, height: 48, borderRadius: 24, alignItems: "center", justifyContent: "center", elevation: 8, shadowColor: "#000", shadowOpacity: 0.2, shadowRadius: 10, shadowOffset: { width: 0, height: 4 } },
-  rcText: { fontSize: 22, fontWeight: "800" }
+  rcText: { fontSize: 22, fontWeight: "800" },
+  rcBadge: { position: "absolute", top: -4, right: -4, minWidth: 20, height: 20, paddingHorizontal: 5, borderRadius: 10, borderWidth: 2, backgroundColor: "#dc2626", alignItems: "center", justifyContent: "center" },
+  rcBadgeText: { color: "#ffffff", fontSize: 11, fontWeight: "800" }
 });
+function rcLauncherLabel(client) {
+  const label = client.getResourceCenter()?.launcher.label || "Help";
+  const unread = client.getUnreadAnnouncements();
+  return unread ? `${label} (${unread} new update${unread === 1 ? "" : "s"})` : label;
+}
 
-// src/ui/Target.tsx
-import { createContext as createContext2, useCallback as useCallback3, useContext as useContext2, useEffect as useEffect8, useRef as useRef5 } from "react";
-import { View as View10 } from "react-native";
+// src/ui/Autocapture.tsx
 import { jsx as jsx11 } from "react/jsx-runtime";
+function GuidelyMask({ children, ...rest }) {
+  return /* @__PURE__ */ jsx11(View10, { ...rest, children });
+}
+var RESOLVE = {
+  isIgnored: (type) => type === GuidelyOverlay,
+  isMask: (type) => type === GuidelyMask
+};
+function useTapObserver(client) {
+  const clientRef = useRef5(client);
+  clientRef.current = client;
+  return useMemo5(() => {
+    const tracker = new TapTracker();
+    const guard = (fn) => (e) => {
+      try {
+        fn(e);
+      } catch {
+        tracker.cancel();
+      }
+    };
+    return {
+      onTouchStartCapture: guard((e) => {
+        const n = e.nativeEvent;
+        if (!clientRef.current?.isTapCaptureOn()) return tracker.cancel();
+        tracker.begin(n.pageX, n.pageY, Date.now(), Array.isArray(n.touches) ? n.touches.length : 1, n.identifier);
+      }),
+      onTouchMoveCapture: guard((e) => tracker.move(e.nativeEvent.pageX, e.nativeEvent.pageY, e.nativeEvent.identifier)),
+      onTouchEndCapture: guard((e) => {
+        const n = e.nativeEvent;
+        const tap = tracker.end(n.pageX, n.pageY, Date.now(), n.identifier);
+        const c = clientRef.current;
+        if (!tap || !c) return;
+        const r = resolveTapTarget(e, RESOLVE);
+        if (!r.ignored) c.recordTap({ x: tap.x, y: tap.y, t: Date.now(), element: r.element, hit: r.hit });
+      }),
+      onTouchCancelCapture: guard(() => tracker.cancel())
+    };
+  }, []);
+}
+
+// src/ui/Target.tsx
+import { createContext as createContext2, useCallback as useCallback3, useContext as useContext2, useEffect as useEffect8, useRef as useRef6 } from "react";
+import { View as View11 } from "react-native";
+import { jsx as jsx12 } from "react/jsx-runtime";
 var GuidelyContext = createContext2(null);
 var GuidelyScreenContext = createContext2(null);
 function GuidelyScreenScope({ name, children }) {
-  return /* @__PURE__ */ jsx11(GuidelyScreenContext.Provider, { value: name, children });
+  return /* @__PURE__ */ jsx12(GuidelyScreenContext.Provider, { value: name, children });
 }
 function guidelyScreenLayout({ route, children }) {
-  return /* @__PURE__ */ jsx11(GuidelyScreenScope, { name: route.name, children });
+  return /* @__PURE__ */ jsx12(GuidelyScreenScope, { name: route.name, children });
 }
-var TAP_SLOP = 10;
+var TAP_SLOP2 = 10;
 function useGuidelyTarget(id) {
   const client = useContext2(GuidelyContext);
   const screen = useContext2(GuidelyScreenContext);
-  const ref = useRef5(null);
-  const start = useRef5(null);
+  const ref = useRef6(null);
+  const start = useRef6(null);
   useEffect8(() => {
     if (!client || !id) return;
     return client.targets.register(id, {
@@ -4736,7 +5983,7 @@ function useGuidelyTarget(id) {
     (e) => {
       const s = start.current;
       start.current = null;
-      if (s && Math.abs(e.nativeEvent.pageX - s.x) < TAP_SLOP && Math.abs(e.nativeEvent.pageY - s.y) < TAP_SLOP) client?.targets.tapped(id);
+      if (s && Math.abs(e.nativeEvent.pageX - s.x) < TAP_SLOP2 && Math.abs(e.nativeEvent.pageY - s.y) < TAP_SLOP2) client?.targets.tapped(id);
     },
     [client, id]
   );
@@ -4744,8 +5991,8 @@ function useGuidelyTarget(id) {
 }
 function GuidelyTarget({ id, children, onLayout, onTouchStart, onTouchEnd, ...rest }) {
   const t = useGuidelyTarget(id);
-  return /* @__PURE__ */ jsx11(
-    View10,
+  return /* @__PURE__ */ jsx12(
+    View11,
     {
       ...rest,
       ref: t.ref,
@@ -4769,7 +6016,7 @@ function GuidelyTarget({ id, children, onLayout, onTouchStart, onTouchEnd, ...re
 
 // src/index.tsx
 import { createFlagsClient as createFlagsClient3, InMemoryStickyBucketStore } from "@guidelytech/flags";
-import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
 function deviceLocale() {
   try {
     return Intl.DateTimeFormat().resolvedOptions().locale;
@@ -4787,21 +6034,22 @@ function defaultBridge(appVersion) {
       appVersion
     },
     openExternal: (url) => void Linking.openURL(url).catch(() => {
-    })
+    }),
+    windowSize: () => Dimensions.get("window")
   };
 }
 function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPayload, flagAttributes, ...options }) {
   const [client, setClient] = useState8(null);
-  const optionsRef = useRef6(options);
+  const optionsRef = useRef7(options);
   optionsRef.current = options;
-  const userRef = useRef6(user);
+  const userRef = useRef7(user);
   userRef.current = user;
   const flagsOpts = options.flags === false ? null : options.flags ?? {};
   const payload = flagsPayload ?? flagsOpts?.payload ?? null;
-  const payloadRef = useRef6(payload);
+  const payloadRef = useRef7(payload);
   payloadRef.current = payload;
-  const appAttributes = useMemo5(() => ({ ...flagsOpts?.attributes ?? {}, ...flagAttributes ?? {} }), [stableStringify2(flagsOpts?.attributes ?? {}), stableStringify2(flagAttributes ?? {})]);
-  const appAttributesRef = useRef6(appAttributes);
+  const appAttributes = useMemo6(() => ({ ...flagsOpts?.attributes ?? {}, ...flagAttributes ?? {} }), [stableStringify3(flagsOpts?.attributes ?? {}), stableStringify3(flagAttributes ?? {})]);
+  const appAttributesRef = useRef7(appAttributes);
   appAttributesRef.current = appAttributes;
   const { projectId, environment, apiUrl, storage } = options;
   useEffect9(() => {
@@ -4838,7 +6086,7 @@ function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPay
     };
   }, [projectId, environment, apiUrl, storage]);
   const userKey = user ? JSON.stringify([user.id, user.traits ?? null, user.account ?? null]) : "";
-  const hadUser = useRef6(false);
+  const hadUser = useRef7(false);
   useEffect9(() => {
     if (!client) return;
     if (user && user.id) {
@@ -4852,13 +6100,18 @@ function GuidelyProvider({ children, user, insets, launcherOffset = 72, flagsPay
   useEffect9(() => {
     client?.flags.setAttributes(appAttributes);
   }, [client, appAttributes]);
+  useEffect9(() => {
+    client?.setLocale(options.locale ?? null);
+  }, [client, options.locale]);
   const bootstrap = useBootstrap(payload, { ...user?.id ? { ...user.traits ?? {}, id: user.id } : {}, ...appAttributes });
-  const flags = useMemo5(() => ({ client: client?.flags ?? null, bootstrap }), [client, bootstrap]);
-  return /* @__PURE__ */ jsx12(GuidelyContext.Provider, { value: client, children: /* @__PURE__ */ jsxs9(FlagsContext.Provider, { value: flags, children: [
-    children,
-    client ? /* @__PURE__ */ jsx12(GuidelyOverlay, { client, insets, launcherOffset }) : null
+  const flags = useMemo6(() => ({ client: client?.flags ?? null, bootstrap }), [client, bootstrap]);
+  const tapObserver = useTapObserver(client);
+  return /* @__PURE__ */ jsx13(GuidelyContext.Provider, { value: client, children: /* @__PURE__ */ jsxs9(FlagsContext.Provider, { value: flags, children: [
+    options.autocapture === false ? children : /* @__PURE__ */ jsx13(View12, { style: styles10.root, ...tapObserver, children }),
+    client ? /* @__PURE__ */ jsx13(GuidelyOverlay, { client, insets, launcherOffset }) : null
   ] }) });
 }
+var styles10 = StyleSheet10.create({ root: { flex: 1 } });
 var NOOP_RESULTS = {
   init: Promise.resolve(),
   ready: Promise.resolve(),
@@ -4930,7 +6183,7 @@ function useGuidelyIdentify(userId, traits, account) {
 }
 function useGuidelyEvent(event, handler) {
   const client = useContext3(GuidelyContext);
-  const ref = useRef6(handler);
+  const ref = useRef7(handler);
   ref.current = handler;
   useEffect9(() => {
     if (!client) return;
@@ -4945,7 +6198,7 @@ function useGuidelyScreen(name, properties) {
 }
 function useGuidelyNavigation(navigationRef, options = {}) {
   const client = useContext3(GuidelyContext);
-  const nameRef = useRef6(options.screenName);
+  const nameRef = useRef7(options.screenName);
   nameRef.current = options.screenName;
   const report = () => {
     const route = navigationRef.getCurrentRoute?.();
@@ -4956,7 +6209,7 @@ function useGuidelyNavigation(navigationRef, options = {}) {
 }
 function useUiSelector(select, fallback) {
   const client = useContext3(GuidelyContext);
-  const selectRef = useRef6(select);
+  const selectRef = useRef7(select);
   selectRef.current = select;
   const [value, setValue] = useState8(() => client ? select(client) : fallback);
   useEffect9(() => {
@@ -4998,14 +6251,18 @@ export {
   FeatureValue,
   FlagsProvider,
   GuidelyClient,
+  GuidelyMask,
   GuidelyOverlay,
   GuidelyProvider,
   GuidelyScreenScope,
   GuidelyTarget,
+  HeatmapBuffer,
   InMemoryStickyBucketStore,
   Messenger,
+  RageClickDetector,
   SDK_NAME,
   SDK_VERSION,
+  TapTracker,
   TargetRegistry,
   createFlagsClient3 as createFlagsClient,
   createSseParser,