@guidelytech/react-native 0.0.0-stage → 0.4.1

package/dist/index.js

@@ -0,0 +1,4451 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.tsx
+import { useContext as useContext2, useEffect as useEffect7, useRef as useRef5, useState as useState6 } from "react";
+import { AppState, Dimensions, Linking, Platform as Platform6 } from "react-native";
+
+// ../shared/dist/chunk-QUKMOTT4.js
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function rolloutBucket(subject, salt) {
+  return fnv1a(`${salt}:${subject}`) % 100;
+}
+var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function randomId(size = 16) {
+  const g = typeof globalThis !== "undefined" ? globalThis : {};
+  let bytes;
+  if (g.crypto && typeof g.crypto.getRandomValues === "function") {
+    bytes = new Uint8Array(size);
+    g.crypto.getRandomValues(bytes);
+  } else {
+    bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  let out = "";
+  for (let i = 0; i < size; i++) out += ALPHABET[bytes[i] % ALPHABET.length];
+  return out;
+}
+function getPath(obj, path) {
+  if (!path) return obj;
+  let cur = obj;
+  for (const part of path.split(".")) {
+    if (cur == null) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function matchUrlPattern(pattern, url) {
+  if (!pattern) return true;
+  if (pattern === url) return true;
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/__GLOBSTAR__/g, ".*");
+  const re = new RegExp(`^${escaped}$`);
+  return re.test(url) || re.test(stripOrigin(url));
+}
+function stripOrigin(url) {
+  try {
+    const u = new URL(url);
+    return u.pathname + u.search + u.hash;
+  } catch {
+    return url;
+  }
+}
+function safeRegExp(source, flags = "i") {
+  if (!source || source.length > 200) return null;
+  try {
+    return new RegExp(source, flags);
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_PLATFORMS = ["web"];
+function guidePlatforms(config) {
+  return Array.isArray(config.platforms) ? [...config.platforms] : [...DEFAULT_PLATFORMS];
+}
+function supportsPlatform(config, platform) {
+  return guidePlatforms(config).includes(platform);
+}
+function guidelyIdFromSelector(value) {
+  const v = (value ?? "").trim();
+  if (!v) return null;
+  if (/^[A-Za-z0-9_][A-Za-z0-9_\-:.]*$/.test(v)) return v;
+  const hash = v.match(/^#([A-Za-z0-9_][A-Za-z0-9_\-:.]*)$/);
+  if (hash) return hash[1];
+  const attr2 = v.match(/^(?:[a-z][a-z0-9]*)?\[\s*data-(?:guidely-id|testid|tour)\s*=\s*(["']?)([^"'\]]+)\1\s*\]$/i);
+  if (attr2) return attr2[2].trim();
+  return null;
+}
+function screenPath(screen) {
+  const s = (screen ?? "").trim();
+  if (!s) return "/";
+  return s.startsWith("/") ? s : `/${s}`;
+}
+function compareVersions(a, b) {
+  const sa = a == null ? "" : String(a).trim().replace(/^v/i, "");
+  const sb = b == null ? "" : String(b).trim().replace(/^v/i, "");
+  if (!sa || !sb) return null;
+  const pa = sa.split(/[.+-]/);
+  const pb = sb.split(/[.+-]/);
+  const n = Math.max(pa.length, pb.length);
+  for (let i = 0; i < n; i++) {
+    const x = pa[i] ?? "0";
+    const y = pb[i] ?? "0";
+    const nx = /^\d+$/.test(x) ? Number(x) : NaN;
+    const ny = /^\d+$/.test(y) ? Number(y) : NaN;
+    if (!Number.isNaN(nx) && !Number.isNaN(ny)) {
+      if (nx !== ny) return nx < ny ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function isQuestionVisible(q, answers) {
+  if (!q.showWhen) return true;
+  const actual = answers[q.showWhen.questionId];
+  if (actual === void 0) return false;
+  const expected = q.showWhen.value;
+  switch (q.showWhen.op) {
+    case "equals":
+      return Array.isArray(actual) ? actual.includes(String(expected)) : String(actual) === String(expected);
+    case "lte":
+      return Number(actual) <= Number(expected);
+    case "gte":
+      return Number(actual) >= Number(expected);
+    case "in": {
+      const list = Array.isArray(expected) ? expected : [String(expected)];
+      return Array.isArray(actual) ? actual.some((a) => list.includes(a)) : list.includes(String(actual));
+    }
+    default:
+      return false;
+  }
+}
+function isChecklistComplete(config, progress) {
+  const done = new Set(progress.completedTaskIds);
+  return config.tasks.filter((t) => t.required).every((t) => done.has(t.id));
+}
+function isRuleGroup(r) {
+  return r.rules !== void 0;
+}
+function has(set, v) {
+  if (!set) return false;
+  return set instanceof Set ? set.has(v) : set.includes(v);
+}
+function resolveField(rule, ctx) {
+  switch (rule.field) {
+    case "user.attribute":
+      return rule.key ? getPath(ctx.userAttributes, rule.key) : void 0;
+    case "account.attribute":
+      return rule.key ? getPath(ctx.accountAttributes, rule.key) : void 0;
+    case "user.role":
+      return ctx.userAttributes.role;
+    case "user.plan":
+      return ctx.userAttributes.plan ?? ctx.accountAttributes.plan;
+    case "url.path":
+      return ctx.path;
+    case "url.full":
+      return ctx.url;
+    case "url.query":
+      return rule.key ? ctx.query[rule.key] : void 0;
+    case "device.type":
+      return ctx.device.type;
+    case "device.browser":
+      return ctx.device.browser;
+    case "device.os":
+      return ctx.device.os;
+    case "visitor.firstVisit":
+      return ctx.firstVisit;
+    case "visitor.returning":
+      return !ctx.firstVisit;
+    case "event.seen":
+      return rule.key ? has(ctx.eventsSeen, rule.key) : false;
+    case "guide.completed":
+      return rule.key ? has(ctx.completedGuides, rule.key) : false;
+    case "guide.dismissed":
+      return rule.key ? has(ctx.dismissedGuides, rule.key) : false;
+    case "guide.seen":
+      return rule.key ? has(ctx.seenGuides, rule.key) : false;
+    case "checklist.completed":
+      return rule.key ? has(ctx.completedChecklists, rule.key) : false;
+    case "audience.member":
+      return rule.key ? has(ctx.audienceIds, rule.key) : false;
+    case "datetime.now":
+      return ctx.now.toISOString();
+    case "datetime.dayOfWeek":
+      return ctx.now.getDay();
+    case "datetime.hour":
+      return ctx.now.getHours();
+    case "rollout.percentage":
+      return rolloutBucket(ctx.userId || ctx.anonymousId, ctx.rolloutSalt || "guidely");
+    case "environment":
+      return ctx.environment;
+    case "locale":
+      return ctx.locale;
+    case "app.platform":
+      return ctx.platform ?? "web";
+    case "app.screen":
+      return ctx.screen;
+    case "app.version":
+      return ctx.appVersion;
+    default:
+      return void 0;
+  }
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v))) return Number(v);
+  if (v instanceof Date) return v.getTime();
+  return null;
+}
+function toDateMs(v) {
+  if (v instanceof Date) return v.getTime();
+  if (typeof v === "string") {
+    const t = Date.parse(v);
+    return Number.isNaN(t) ? null : t;
+  }
+  if (typeof v === "number") return v;
+  return null;
+}
+function compare(op, actual, expected) {
+  switch (op) {
+    case "exists":
+      return actual !== void 0 && actual !== null && actual !== "";
+    case "not_exists":
+      return actual === void 0 || actual === null || actual === "";
+    case "is_true":
+      return actual === true || actual === "true";
+    case "is_false":
+      return actual === false || actual === "false";
+    case "equals":
+      if (typeof actual === "boolean") return String(actual) === String(expected);
+      return String(actual ?? "") === String(expected ?? "");
+    case "not_equals":
+      return String(actual ?? "") !== String(expected ?? "");
+    case "contains":
+      return typeof actual === "string" && actual.toLowerCase().includes(String(expected ?? "").toLowerCase());
+    case "not_contains":
+      return !(typeof actual === "string" && actual.toLowerCase().includes(String(expected ?? "").toLowerCase()));
+    case "starts_with":
+      return typeof actual === "string" && actual.startsWith(String(expected ?? ""));
+    case "ends_with":
+      return typeof actual === "string" && actual.endsWith(String(expected ?? ""));
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const a = toNumber(actual);
+      const b = toNumber(expected);
+      if (a === null || b === null) return false;
+      return op === "gt" ? a > b : op === "gte" ? a >= b : op === "lt" ? a < b : a <= b;
+    }
+    case "in": {
+      const list = Array.isArray(expected) ? expected : String(expected ?? "").split(",").map((s) => s.trim());
+      return list.includes(String(actual ?? ""));
+    }
+    case "not_in": {
+      const list = Array.isArray(expected) ? expected : String(expected ?? "").split(",").map((s) => s.trim());
+      return !list.includes(String(actual ?? ""));
+    }
+    case "regex": {
+      const re = safeRegExp(String(expected ?? ""));
+      return !!re && typeof actual === "string" && re.test(actual);
+    }
+    case "before": {
+      const a = toDateMs(actual);
+      const b = toDateMs(expected);
+      return a !== null && b !== null && a < b;
+    }
+    case "after": {
+      const a = toDateMs(actual);
+      const b = toDateMs(expected);
+      return a !== null && b !== null && a > b;
+    }
+    default:
+      return false;
+  }
+}
+function evaluateRule(rule, ctx) {
+  let result;
+  if (rule.field === "url.path" || rule.field === "url.full" || rule.field === "app.screen") {
+    const actual = String(resolveField(rule, ctx) ?? "");
+    if (rule.op === "equals") result = matchUrlPattern(String(rule.value ?? ""), actual);
+    else if (rule.op === "not_equals") result = !matchUrlPattern(String(rule.value ?? ""), actual);
+    else result = compare(rule.op, actual, rule.value);
+  } else if (rule.field === "app.version" && ["equals", "not_equals", "gt", "gte", "lt", "lte"].includes(rule.op)) {
+    const c = compareVersions(resolveField(rule, ctx), rule.value);
+    if (c === null) result = rule.op === "not_equals";
+    else result = rule.op === "equals" ? c === 0 : rule.op === "not_equals" ? c !== 0 : rule.op === "gt" ? c > 0 : rule.op === "gte" ? c >= 0 : rule.op === "lt" ? c < 0 : c <= 0;
+  } else {
+    result = compare(rule.op, resolveField(rule, ctx), rule.value);
+  }
+  return rule.negate ? !result : result;
+}
+function evaluateRules(group, ctx) {
+  if (!group || group.rules.length === 0) return group?.negate ? false : true;
+  const results = group.rules.map((r) => isRuleGroup(r) ? evaluateRules(r, ctx) : evaluateRule(r, ctx));
+  const value = group.op === "and" ? results.every(Boolean) : results.some(Boolean);
+  return group.negate ? !value : value;
+}
+var SENSITIVE_PROPERTY_PATTERN = /(password|passwd|secret|token|credit|card|cvv|ssn|iban)/i;
+var MAX_PROPERTY_BYTES = 8 * 1024;
+function sanitizeProperties(props) {
+  if (!props) return {};
+  const out = {};
+  let size = 0;
+  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);
+    if (size > MAX_PROPERTY_BYTES) break;
+    out[k.slice(0, 100)] = typeof v === "string" ? v.slice(0, 1e3) : v;
+  }
+  return out;
+}
+var SOURCEMAP_MAX_FILE_BYTES = 25 * 1024 * 1024;
+
+// ../sdk-core/dist/chunk-GJT7CFAC.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 Api = class {
+  constructor(baseUrl, key, fetchImpl) {
+    __publicField2(this, "baseUrl", baseUrl);
+    __publicField2(this, "key", key);
+    __publicField2(this, "fetchImpl", fetchImpl);
+  }
+  url(path, params = {}) {
+    const query = Object.entries({ key: this.key, ...params }).filter((e) => e[1] != null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+    return `${this.baseUrl.replace(/\/$/, "")}/api/v1/sdk${path}?${query}`;
+  }
+  get fetcher() {
+    if (this.fetchImpl) return this.fetchImpl;
+    return typeof fetch === "function" ? fetch.bind(globalThis) : null;
+  }
+  async request(method, path, options = {}) {
+    const f = this.fetcher;
+    if (!f) throw new Error("fetch is not available");
+    const headers = { ...options.headers, "X-Guidely-Key": this.key, Accept: "application/json" };
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    if (options.etag) headers["If-None-Match"] = options.etag;
+    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 : JSON.stringify(options.body),
+        keepalive: options.keepalive,
+        signal: ac?.signal,
+        credentials: "omit",
+        mode: "cors"
+      });
+      let data = null;
+      if (res.status !== 304 && res.status !== 204) {
+        try {
+          data = await res.json();
+        } catch {
+          data = null;
+        }
+      }
+      return { status: res.status, ok: res.ok, data, etag: res.headers?.get?.("etag") ?? null };
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  get(path, options) {
+    return this.request("GET", path, options);
+  }
+  post(path, body, options) {
+    return this.request("POST", path, { body, ...options });
+  }
+  /**
+   * 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.
+   */
+  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;
+      try {
+        data = await res.json();
+      } catch {
+        data = null;
+      }
+      return { status: res.status, ok: res.ok, data, etag: null };
+    }
+    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) {
+    try {
+      if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") return false;
+      const blob = new Blob([JSON.stringify(body)], { type: "text/plain;charset=UTF-8" });
+      return navigator.sendBeacon(this.url(path), blob);
+    } catch {
+      return false;
+    }
+  }
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function backoffMs(attempt, baseMs = 1e3, maxMs = 3e4) {
+  return Math.min(maxMs, baseMs * 2 ** Math.max(0, attempt));
+}
+async function postWithRetry(api, path, body, attempts = 3, baseMs = 500) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await api.post(path, body);
+      if (res.ok || res.status >= 400 && res.status < 500 && res.status !== 429) return res;
+    } catch {
+    }
+    if (i < attempts - 1) await sleep(backoffMs(i, baseMs, 8e3));
+  }
+  return null;
+}
+async function readEventStream(body, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const dispatch = (raw) => {
+    let event = "message";
+    const data = [];
+    for (const line of raw.split("\n")) {
+      if (!line || line.startsWith(":")) continue;
+      const i = line.indexOf(":");
+      const field = i < 0 ? line : line.slice(0, i);
+      const value = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
+      if (field === "event") event = value;
+      else if (field === "data") data.push(value);
+    }
+    if (!data.length) return;
+    try {
+      onEvent(event, JSON.parse(data.join("\n")));
+    } catch {
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (value) buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
+    let sep;
+    while ((sep = buffer.indexOf("\n\n")) >= 0) {
+      dispatch(buffer.slice(0, sep));
+      buffer = buffer.slice(sep + 2);
+    }
+    if (done) break;
+  }
+  if (buffer.trim()) dispatch(buffer);
+}
+
+// ../sdk-core/dist/chunk-HLR3W63Z.js
+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}`,
+  session: "guidely:session",
+  active: "guidely:active",
+  authoring: "guidely:authoring",
+  /** Messenger conversations this browser can read: [{ id, token }]. */
+  conversations: (key) => `guidely:conversations:${key}`
+};
+var EventQueue = class {
+  constructor(opts) {
+    __publicField2(this, "opts", opts);
+    __publicField2(this, "events", []);
+    __publicField2(this, "timer", null);
+    __publicField2(this, "retryTimer", null);
+    __publicField2(this, "inflight", false);
+    __publicField2(this, "inflightIds", /* @__PURE__ */ new Set());
+    __publicField2(this, "attempt", 0);
+    __publicField2(this, "destroyed", false);
+    __publicField2(this, "flushIntervalMs");
+    __publicField2(this, "maxQueue");
+    __publicField2(this, "batchSize");
+    __publicField2(this, "maxAttempts");
+    this.flushIntervalMs = opts.flushIntervalMs ?? 2e3;
+    this.maxQueue = opts.maxQueue ?? 200;
+    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();
+  }
+  get size() {
+    return this.events.length;
+  }
+  /** Pending events (read-only copy, for debugging). */
+  peek() {
+    return this.events.slice();
+  }
+  enqueue(event) {
+    if (this.destroyed) return;
+    if (this.events.some((e) => e.eventId === event.eventId)) return;
+    this.events.push(event);
+    if (this.events.length > this.maxQueue) this.events.splice(0, this.events.length - this.maxQueue);
+    this.persist();
+    this.schedule();
+  }
+  persist() {
+    writeJson(this.opts.store, this.opts.storageKey, this.events);
+  }
+  schedule() {
+    if (this.timer || this.retryTimer || this.destroyed) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, this.flushIntervalMs);
+  }
+  /** Sends queued events now (one batch at a time). Safe to call at any time. */
+  async flush() {
+    if (this.destroyed || this.inflight || !this.events.length || !this.opts.enabled()) return;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.inflight = true;
+    const batch = this.events.slice(0, this.batchSize);
+    this.inflightIds = new Set(batch.map((e) => e.eventId));
+    let ok = false;
+    let retry = true;
+    try {
+      const res = await this.opts.send(batch);
+      ok = res.ok;
+      retry = res.retry ?? !res.ok;
+    } catch (err) {
+      this.opts.onError?.(err);
+    }
+    this.inflight = false;
+    this.inflightIds.clear();
+    if (this.destroyed) return;
+    if (ok || !retry) {
+      const ids = new Set(batch.map((e) => e.eventId));
+      this.events = this.events.filter((e) => !ids.has(e.eventId));
+      this.attempt = 0;
+      this.persist();
+      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));
+  }
+  /** 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)) {
+      const ids = new Set(batch.map((e) => e.eventId));
+      this.events = this.events.filter((e) => !ids.has(e.eventId));
+      this.persist();
+    }
+  }
+  clear() {
+    this.events = [];
+    this.persist();
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.timer) clearTimeout(this.timer);
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.timer = null;
+    this.retryTimer = null;
+    this.persist();
+  }
+};
+var Emitter = class {
+  constructor(onError) {
+    __publicField2(this, "onError", onError);
+    __publicField2(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  on(event, cb) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(cb);
+    return () => this.off(event, cb);
+  }
+  off(event, cb) {
+    this.listeners.get(event)?.delete(cb);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const cb of Array.from(set)) {
+      try {
+        cb(...args);
+      } catch (err) {
+        this.onError?.(err);
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+var HOUR = 3600 * 1e3;
+function isFrequencyEligible(freq, state, shownThisSession, now = Date.now()) {
+  const s = state ?? { impressions: 0 };
+  if (freq.maxImpressions != null && s.impressions >= freq.maxImpressions) return false;
+  if (s.completedAt && freq.mode !== "every_time") return false;
+  if (s.dismissedAt) {
+    if (!freq.reshowAfterDismiss) return false;
+    if (freq.cooldownHours > 0 && now - Date.parse(s.dismissedAt) < freq.cooldownHours * HOUR) return false;
+  }
+  switch (freq.mode) {
+    case "once":
+      return s.impressions === 0 || !!s.dismissedAt && freq.reshowAfterDismiss;
+    case "once_per_session":
+      return !shownThisSession;
+    case "interval": {
+      if (!s.lastShownAt) return true;
+      const hours = freq.intervalHours ?? 24;
+      return now - Date.parse(s.lastShownAt) >= hours * HOUR;
+    }
+    case "every_time":
+    default:
+      return true;
+  }
+}
+function isExclusiveGuide(guide) {
+  if (guide.kind === "banner" || guide.kind === "checklist") return false;
+  const steps = guide.config.steps;
+  if (steps.length > 0 && steps.every((s) => s.type === "hotspot" || s.type === "banner")) return false;
+  return true;
+}
+function areMutuallyExclusive(a, b) {
+  const la = a.config.frequency.mutuallyExclusiveWith;
+  const lb = b.config.frequency.mutuallyExclusiveWith;
+  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;
+  return true;
+}
+
+// src/core/targets.ts
+var TargetTimeoutError = class extends Error {
+  constructor(ids) {
+    super(`[Guidely] target not found: ${ids.join(", ") || "(no mobile-compatible selector)"}`);
+    this.name = "TargetTimeoutError";
+  }
+};
+function targetIdsFor(selectors) {
+  const ids = [];
+  for (const s of selectors) {
+    let id = null;
+    if (s.kind === "guidely-id" || s.kind === "id") id = s.value.trim().replace(/^#/, "") || null;
+    else if (s.kind === "css" || s.kind === "data-attr") id = guidelyIdFromSelector(s.value);
+    if (id && !ids.includes(id)) ids.push(id);
+  }
+  return ids;
+}
+var TargetRegistry = class {
+  constructor() {
+    __publicField(this, "targets", /* @__PURE__ */ new Map());
+    __publicField(this, "changeListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "tapListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "viewport", null);
+    __publicField(this, "screen", null);
+  }
+  register(id, handle) {
+    const list = this.targets.get(id) ?? [];
+    list.push(handle);
+    this.targets.set(id, list);
+    this.changed();
+    return () => {
+      const cur = this.targets.get(id);
+      if (!cur) return;
+      const next = cur.filter((h) => h !== handle);
+      if (next.length) this.targets.set(id, next);
+      else this.targets.delete(id);
+      this.changed();
+    };
+  }
+  /** Window size used for the on-screen check. */
+  setViewport(width, height) {
+    this.viewport = { width, height };
+  }
+  /** The current screen; targets scoped to other screens are treated as hidden. */
+  setScreen(name) {
+    if (name === this.screen) return;
+    this.screen = name;
+    this.changed();
+  }
+  has(id) {
+    return this.targets.has(id);
+  }
+  ids() {
+    return Array.from(this.targets.keys());
+  }
+  /** Call when a target's layout may have changed (onLayout, scroll). */
+  changed() {
+    for (const cb of Array.from(this.changeListeners)) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+  onChange(cb) {
+    this.changeListeners.add(cb);
+    return () => this.changeListeners.delete(cb);
+  }
+  tapped(id) {
+    for (const cb of Array.from(this.tapListeners)) {
+      try {
+        cb(id);
+      } catch {
+      }
+    }
+  }
+  onTap(cb) {
+    this.tapListeners.add(cb);
+    return () => this.tapListeners.delete(cb);
+  }
+  /** Frame of a visible target (the most recently mounted visible one when an id is used twice), else null. */
+  async measure(id) {
+    const list = this.targets.get(id) ?? [];
+    for (let i = list.length - 1; i >= 0; i--) {
+      const handle = list[i];
+      if (handle.screen && this.screen && handle.screen !== this.screen) continue;
+      const r = await this.measureHandle(handle);
+      if (r) return r;
+    }
+    return null;
+  }
+  async measureHandle(handle) {
+    try {
+      const r = await handle.measure();
+      if (!r || !(r.width > 0) || !(r.height > 0)) return null;
+      const vp = this.viewport;
+      if (vp && (r.x + r.width <= 0 || r.y + r.height <= 0 || r.x >= vp.width || r.y >= vp.height)) return null;
+      return r;
+    } catch {
+      return null;
+    }
+  }
+  /** First of `ids` that is mounted and visible. */
+  async resolve(ids) {
+    for (const id of ids) {
+      const rect = await this.measure(id);
+      if (rect) return { id, rect };
+    }
+    return null;
+  }
+  /** Resolves when one of `ids` is visible; `timeoutMs` 0 waits forever. Re-checks on registry changes and every 300ms. */
+  waitFor(ids, options) {
+    return new Promise((resolve, reject) => {
+      let done = false;
+      let checking = false;
+      let again = false;
+      const timers = [];
+      const finish = (fn) => {
+        if (done) return;
+        done = true;
+        off();
+        timers.forEach((t) => clearTimeout(t));
+        timers.forEach((t) => clearInterval(t));
+        options.signal?.removeEventListener?.("abort", onAbort);
+        fn();
+      };
+      const check = async () => {
+        if (done) return;
+        if (checking) {
+          again = true;
+          return;
+        }
+        checking = true;
+        const hit = ids.length ? await this.resolve(ids) : null;
+        checking = false;
+        if (hit) return finish(() => resolve(hit));
+        if (again) {
+          again = false;
+          void check();
+        }
+      };
+      const onAbort = () => finish(() => reject(Object.assign(new Error("aborted"), { name: "AbortError" })));
+      if (options.signal?.aborted) return onAbort();
+      options.signal?.addEventListener?.("abort", onAbort);
+      const off = this.onChange(() => void check());
+      timers.push(setInterval(() => void check(), 300));
+      if (options.timeoutMs > 0) timers.push(setTimeout(() => finish(() => reject(new TargetTimeoutError(ids))), options.timeoutMs));
+      void check();
+    });
+  }
+};
+
+// src/core/controller.ts
+var ANCHORED = /* @__PURE__ */ new Set(["tooltip", "popover", "spotlight", "hotspot"]);
+var isAnchoredStep = (step) => ANCHORED.has(step.type);
+function visibleButtons(step, canGoBack) {
+  return canGoBack ? step.buttons : step.buttons.filter((b) => b.action !== "back");
+}
+function screenMatches(pattern, url) {
+  if (!pattern) return true;
+  if (matchUrlPattern(pattern, url)) return true;
+  if (!pattern.includes("?") && !pattern.includes("#")) return matchUrlPattern(pattern, url.split(/[?#]/)[0] ?? url);
+  return false;
+}
+function runGuide(guide, o) {
+  const steps = guide.config.steps;
+  const total = steps.length;
+  const onError = o.onError ?? (() => {
+  });
+  let status = "idle";
+  let index = -1;
+  let pendingIndex = -1;
+  let rendered = false;
+  let started = false;
+  let stepDone = false;
+  let ended = false;
+  const history = [];
+  const stepCleanups = [];
+  const emit = (name, step, stepIndex, properties) => {
+    try {
+      o.onEvent({ name, stepId: step?.id, stepIndex, properties });
+    } catch (err) {
+      onError(err);
+    }
+  };
+  const clearStep = () => {
+    stepCleanups.splice(0).forEach((fn) => {
+      try {
+        fn();
+      } catch {
+      }
+    });
+    if (rendered) {
+      rendered = false;
+      try {
+        o.onClear();
+      } catch (err) {
+        onError(err);
+      }
+    }
+    stepDone = false;
+  };
+  const end = (reason) => {
+    if (ended) return;
+    ended = true;
+    const step = steps[index];
+    clearStep();
+    status = "ended";
+    if (reason === "completed") emit("guide_completed", step, index);
+    else if (reason === "dismissed") emit("guide_dismissed", step, index);
+    else if (reason === "skipped") emit("guide_skipped", step, index);
+    try {
+      o.onEnd(reason);
+    } catch (err) {
+      onError(err);
+    }
+  };
+  const completeStep = () => {
+    if (stepDone || index < 0) return;
+    stepDone = true;
+    emit("step_completed", steps[index], index);
+  };
+  const goNext = (overrideStepId) => {
+    const step = steps[index];
+    let target = -1;
+    const ctx = o.ctx();
+    if (step) {
+      for (const branch of step.branches) {
+        if (evaluateRules(branch.when, ctx)) {
+          target = steps.findIndex((s) => s.id === branch.goTo);
+          if (target >= 0) break;
+        }
+      }
+    }
+    if (target < 0 && overrideStepId) target = steps.findIndex((s) => s.id === overrideStepId);
+    if (target < 0) target = index + 1;
+    if (target >= total) return end("completed");
+    history.push(index);
+    showStep(target, 1);
+  };
+  const advance = () => {
+    if (ended) return;
+    completeStep();
+    goNext();
+  };
+  const press = (b) => {
+    try {
+      switch (b.action) {
+        case "next":
+          completeStep();
+          goNext(b.value);
+          break;
+        case "back":
+          controller.back();
+          break;
+        case "dismiss":
+          end("dismissed");
+          break;
+        case "complete":
+          completeStep();
+          end("completed");
+          break;
+        case "skip":
+          end("skipped");
+          break;
+        case "url":
+          completeStep();
+          o.onNavigate(b.value || "");
+          if (index + 1 >= total) end("completed");
+          else goNext();
+          break;
+        case "start_guide":
+          completeStep();
+          end("completed");
+          o.onAction("start_guide", b.value);
+          break;
+        case "event":
+          o.onAction("event", b.value);
+          break;
+        case "open_resource_center":
+          o.onAction("open_resource_center", b.value);
+          break;
+        default:
+          break;
+      }
+    } catch (err) {
+      onError(err);
+    }
+  };
+  const setupAdvance = (step, targetId) => {
+    const modes = step.advanceOn === "any" ? ["element_click", "element_visible", "event", "delay"] : [step.advanceOn];
+    for (const mode of modes) {
+      const id = guidelyIdFromSelector(step.advanceValue) ?? (mode === "element_click" ? targetId : null);
+      if (mode === "element_click" && id) {
+        stepCleanups.push(o.targets.onTap((tapped) => tapped === id && advance()));
+      } else if (mode === "element_visible" && id) {
+        const ac = new AbortController();
+        stepCleanups.push(() => ac.abort());
+        o.targets.waitFor([id], { timeoutMs: 0, signal: ac.signal }).then(() => !ac.signal.aborted && advance(), () => {
+        });
+      } else if (mode === "event" && step.advanceValue) {
+        stepCleanups.push(o.eventBus.on(step.advanceValue, advance));
+      } else if (mode === "delay") {
+        const t = setTimeout(advance, step.advanceDelayMs ?? 3e3);
+        stepCleanups.push(() => clearTimeout(t));
+      }
+    }
+  };
+  const render = (step, targetId, asModal = false) => {
+    if (ended) return;
+    status = "running";
+    try {
+      o.onRender({ step, index, total, canGoBack: history.length > 0 || index > 0, targetId, asModal });
+      rendered = true;
+    } catch (err) {
+      onError(err);
+      if (index + 1 < total) return goNext();
+      return end("skipped");
+    }
+    if (!started) {
+      started = true;
+      emit("guide_started", step, index);
+    }
+    emit("step_viewed", step, index, asModal ? { fallback: "show_as_modal" } : void 0);
+    setupAdvance(step, targetId);
+  };
+  const applyFallback = (step, direction) => {
+    const fallback = step.target?.fallback ?? "skip";
+    emit("step_viewed", step, index, { fallback, targetMissing: true });
+    if (fallback === "show_as_modal") return render(step, null, true);
+    if (fallback === "end_guide") return end("skipped");
+    const nextIndex = index + direction;
+    if (nextIndex < 0) return showStep(0, 1);
+    if (nextIndex >= total) return end("completed");
+    showStep(nextIndex, direction);
+  };
+  function showStep(i, direction = 1) {
+    if (ended) return;
+    clearStep();
+    if (i < 0) i = 0;
+    if (i >= total) return end("completed");
+    index = i;
+    const step = steps[i];
+    if (step.targeting && step.targeting.rules.length && !evaluateRules(step.targeting, o.ctx())) {
+      const nextIndex = i + direction;
+      if (nextIndex >= total) return end("completed");
+      if (nextIndex < 0) return;
+      return showStep(nextIndex, direction);
+    }
+    if (step.url && !screenMatches(step.url, o.currentUrl())) {
+      status = "waiting_url";
+      pendingIndex = i;
+      return;
+    }
+    pendingIndex = -1;
+    if (isAnchoredStep(step) && step.target) {
+      status = "waiting_target";
+      const ids = targetIdsFor(step.target.selectors);
+      if (!ids.length) return applyFallback(step, direction);
+      const ac = new AbortController();
+      stepCleanups.push(() => ac.abort());
+      const timeoutMs = step.target.fallback === "wait" ? 0 : step.target.waitMs;
+      o.targets.waitFor(ids, { timeoutMs, signal: ac.signal }).then(
+        (hit) => {
+          if (ac.signal.aborted || ended) return;
+          render(step, hit.id);
+        },
+        (err) => {
+          if (ac.signal.aborted || ended || err?.name === "AbortError") return;
+          applyFallback(step, direction);
+        }
+      );
+      return;
+    }
+    render(step, null);
+  }
+  const controller = {
+    guide,
+    start() {
+      if (status !== "idle") return;
+      emit("guide_viewed");
+      if (total === 0) return end("completed");
+      let startIndex = o.startAtStep ? steps.findIndex((s) => s.id === o.startAtStep) : 0;
+      if (startIndex < 0) startIndex = 0;
+      showStep(startIndex, 1);
+    },
+    next() {
+      if (ended || index < 0) return;
+      completeStep();
+      goNext();
+    },
+    back() {
+      if (ended) return;
+      const prev = history.pop();
+      if (prev == null) {
+        if (index > 0) showStep(index - 1, -1);
+        return;
+      }
+      showStep(prev, -1);
+    },
+    goTo(stepId) {
+      const i = steps.findIndex((s) => s.id === stepId);
+      if (i >= 0 && !ended) {
+        if (index >= 0) history.push(index);
+        showStep(i, 1);
+      }
+    },
+    dismiss: () => end("dismissed"),
+    complete() {
+      completeStep();
+      end("completed");
+    },
+    skip: () => end("skipped"),
+    press,
+    resume() {
+      if (ended) return;
+      if (status === "waiting_url" && pendingIndex >= 0) return showStep(pendingIndex, 1);
+      const step = steps[index];
+      if (step?.url && status === "running" && !screenMatches(step.url, o.currentUrl())) showStep(index, 1);
+    },
+    destroy() {
+      if (ended) return;
+      ended = true;
+      clearStep();
+      status = "ended";
+      try {
+        o.onEnd("destroyed");
+      } catch (err) {
+        onError(err);
+      }
+    },
+    getState: () => ({ status, stepId: steps[index]?.id ?? null, stepIndex: index, total })
+  };
+  return controller;
+}
+
+// src/core/messenger.ts
+var TOKEN_HEADER = "X-Guidely-Conversation";
+var MAX_STORED = 50;
+function createSseParser(onEvent) {
+  let buffer = "";
+  const dispatch = (raw) => {
+    let event = "message";
+    const data = [];
+    for (const line of raw.split("\n")) {
+      if (!line || line.startsWith(":")) continue;
+      const i = line.indexOf(":");
+      const field = i < 0 ? line : line.slice(0, i);
+      const value = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
+      if (field === "event") event = value;
+      else if (field === "data") data.push(value);
+    }
+    if (!data.length) return;
+    try {
+      onEvent(event, JSON.parse(data.join("\n")));
+    } catch {
+    }
+  };
+  return {
+    feed(chunk) {
+      buffer += chunk.replace(/\r\n?/g, "\n");
+      let sep;
+      while ((sep = buffer.indexOf("\n\n")) >= 0) {
+        dispatch(buffer.slice(0, sep));
+        buffer = buffer.slice(sep + 2);
+      }
+    },
+    end() {
+      if (buffer.trim()) dispatch(buffer);
+      buffer = "";
+    }
+  };
+}
+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;
+    const pump = () => {
+      const type = xhr.getResponseHeader("content-type") || "";
+      if (!type.includes("text/event-stream")) return;
+      streamed = true;
+      const text = xhr.responseText || "";
+      if (text.length > seen) {
+        onChunk(text.slice(seen));
+        seen = text.length;
+      }
+    };
+    xhr.open("POST", url);
+    for (const [k, v] of Object.entries(headers)) xhr.setRequestHeader(k, v);
+    xhr.onprogress = pump;
+    xhr.onload = () => {
+      pump();
+      let json = null;
+      if (!streamed) {
+        try {
+          json = JSON.parse(xhr.responseText || "null");
+        } catch {
+          json = null;
+        }
+      }
+      resolve({ status: xhr.status, json, streamed });
+    };
+    xhr.onerror = () => reject(new Error("Network request failed"));
+    xhr.send(JSON.stringify(body));
+  });
+}
+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;
+    try {
+      json = JSON.parse(text || "null");
+    } catch {
+      json = null;
+    }
+    return { status: res.status, json, streamed: false };
+  };
+}
+var byNewest = (a, b) => Date.parse(b.lastMessageAt) - Date.parse(a.lastMessageAt);
+var Messenger = class {
+  constructor(config, deps) {
+    __publicField(this, "deps", deps);
+    __publicField(this, "snapshot");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "threadTimer", null);
+    __publicField(this, "backgroundTimer", null);
+    __publicField(this, "foreground", true);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "poll");
+    this.poll = deps.pollMs ?? { thread: 5e3, background: 6e4 };
+    this.snapshot = { config, open: false, view: { kind: "tab", tab: "home" }, conversations: [], thread: null, unread: 0, articles: null, article: null };
+    void this.refreshConversations();
+    this.startBackgroundPolling();
+  }
+  // -------------------------------------------------------------------------- state
+  getSnapshot() {
+    return this.snapshot;
+  }
+  subscribe(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  set(patch) {
+    if (this.destroyed) return;
+    const next = { ...this.snapshot, ...patch };
+    next.unread = next.conversations.filter((c) => c.unread > 0).length;
+    this.snapshot = next;
+    for (const cb of Array.from(this.listeners)) {
+      try {
+        cb();
+      } catch (err) {
+        this.deps.onError(err);
+      }
+    }
+  }
+  setThread(patch) {
+    const t = this.snapshot.thread;
+    if (!t) return;
+    this.set({ thread: { ...t, ...patch } });
+  }
+  updateConfig(config) {
+    this.set({ config });
+  }
+  // -------------------------------------------------------------------------- tokens
+  stored() {
+    const list = readJson(this.deps.store, KEYS.conversations(this.deps.publicKey), []);
+    return Array.isArray(list) ? list.filter((c) => c && typeof c.id === "string" && typeof c.token === "string") : [];
+  }
+  remember(id, token) {
+    writeJson(this.deps.store, KEYS.conversations(this.deps.publicKey), [{ id, token }, ...this.stored().filter((c) => c.id !== id)].slice(0, MAX_STORED));
+  }
+  tokenFor(id) {
+    return this.stored().find((c) => c.id === id)?.token ?? "";
+  }
+  /** Forgets every conversation (logout). */
+  forgetAll() {
+    this.deps.store.remove(KEYS.conversations(this.deps.publicKey));
+    this.stopThreadPolling();
+    this.set({ open: false, view: { kind: "tab", tab: "home" }, conversations: [], thread: null, article: null });
+  }
+  // -------------------------------------------------------------------------- http
+  url(path, params = {}) {
+    const query = Object.entries({ key: this.deps.publicKey, ...params }).filter((e) => e[1] != null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+    return `${this.deps.baseUrl.replace(/\/$/, "")}/api/v1/sdk${path}?${query}`;
+  }
+  headers(extra = {}) {
+    return { "X-Guidely-Key": this.deps.publicKey, Accept: "application/json", "Content-Type": "application/json", ...extra };
+  }
+  async request(method, path, opts = {}) {
+    const headers = this.headers(opts.conversationId ? { [TOKEN_HEADER]: this.tokenFor(opts.conversationId) } : {});
+    const res = await this.deps.fetch(this.url(path, opts.params), { method, headers, body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body) });
+    if (!res.ok) throw new Error(`Request failed (${res.status})`);
+    return await res.json();
+  }
+  // -------------------------------------------------------------------------- navigation
+  open(tab) {
+    const wasOpen = this.snapshot.open;
+    this.set({ open: true, ...tab ? { view: { kind: "tab", tab } } : {} });
+    if (!wasOpen) {
+      this.deps.onOpen();
+      void this.refreshConversations();
+    }
+    if (tab === "help" || this.snapshot.view.kind === "tab") this.onView();
+  }
+  close() {
+    this.stopThreadPolling();
+    this.set({ open: false });
+  }
+  setTab(tab) {
+    this.stopThreadPolling();
+    this.set({ view: { kind: "tab", tab }, thread: null });
+    this.onView();
+  }
+  onView() {
+    const v = this.snapshot.view;
+    if (v.kind === "tab" && v.tab === "help" && !this.snapshot.articles) void this.loadArticles();
+    if (v.kind === "tab" && v.tab === "messages") void this.refreshConversations();
+  }
+  /** Opens a new thread (optionally pre-filling the composer). */
+  showNewMessage(text = "") {
+    this.stopThreadPolling();
+    if (!this.snapshot.open) this.deps.onOpen();
+    this.set({ open: true, view: { kind: "thread", conversationId: null }, thread: { conversation: null, messages: [], streaming: {}, sending: false, error: null, draft: text } });
+  }
+  async openConversation(id) {
+    const known = this.snapshot.conversations.find((c) => c.id === id) ?? null;
+    this.stopThreadPolling();
+    this.set({ open: true, view: { kind: "thread", conversationId: id }, thread: { conversation: known, messages: [], streaming: {}, sending: false, error: null, draft: "" } });
+    try {
+      const res = await this.request("GET", `/conversations/${encodeURIComponent(id)}/messages`, { conversationId: id });
+      this.markRead(res.conversation);
+      this.setThread({ conversation: { ...res.conversation, unread: 0 }, messages: res.messages });
+    } catch (err) {
+      this.setThread({ error: "Couldn't load this conversation." });
+      this.deps.onError(err);
+    }
+    this.scheduleThreadPoll();
+  }
+  back() {
+    const v = this.snapshot.view;
+    if (v.kind === "article") return this.set({ view: v.from, article: null });
+    this.setTab(this.snapshot.thread?.conversation ? "messages" : "home");
+  }
+  // -------------------------------------------------------------------------- conversations
+  upsertConversation(c) {
+    const list = [c, ...this.snapshot.conversations.filter((x) => x.id !== c.id)].sort(byNewest);
+    this.set({ conversations: list });
+  }
+  markRead(c) {
+    this.upsertConversation({ ...c, unread: 0 });
+  }
+  async refreshConversations() {
+    const stored = this.stored();
+    if (!stored.length) return;
+    try {
+      const res = await this.request("POST", "/conversations/lookup", { body: { tokens: stored.map((c) => c.token) } });
+      const known = new Set(res.conversations.map((c) => c.id));
+      if (stored.some((c) => !known.has(c.id))) writeJson(this.deps.store, KEYS.conversations(this.deps.publicKey), stored.filter((c) => known.has(c.id)));
+      const openId = this.snapshot.view.kind === "thread" ? this.snapshot.view.conversationId : null;
+      const list = res.conversations.map(({ token: _token, ...c }) => c.id === openId && this.snapshot.open ? { ...c, unread: 0 } : c).sort(byNewest);
+      this.set({ conversations: list });
+    } catch (err) {
+      this.deps.onError(err);
+    }
+  }
+  /** Sends the composer text: starts a conversation or posts to the open one. Streams Scout's reply. */
+  async send(text) {
+    const body = text.trim().slice(0, 4e3);
+    const thread = this.snapshot.thread;
+    if (!body || !thread || thread.sending) return;
+    this.setThread({ sending: true, error: null, draft: "" });
+    const conversationId = thread.conversation?.id ?? null;
+    const path = conversationId ? `/conversations/${encodeURIComponent(conversationId)}/messages` : "/conversations";
+    const payload = conversationId ? { message: body } : { anonymousId: this.deps.anonymousId(), userId: this.deps.userId(), message: body, pageUrl: this.deps.pageUrl() };
+    const headers = { ...this.headers(conversationId ? { [TOKEN_HEADER]: this.tokenFor(conversationId) } : {}), Accept: "text/event-stream, application/json" };
+    let finished = false;
+    const parser = createSseParser((event, data) => {
+      if (event === "conversation") {
+        const d = data;
+        this.remember(d.conversation.id, d.token);
+        this.markRead(d.conversation);
+        this.set({ view: { kind: "thread", conversationId: d.conversation.id } });
+        this.setThread({ conversation: { ...d.conversation, unread: 0 } });
+        d.messages.forEach((m) => this.addMessage(m));
+      } else if (event === "message") this.addMessage(data);
+      else if (event === "delta") {
+        const d = data;
+        const t = this.snapshot.thread;
+        if (t) this.setThread({ streaming: { ...t.streaming, [d.messageId]: (t.streaming[d.messageId] ?? "") + d.text } });
+      } else if (event === "done") {
+        finished = true;
+        const d = data;
+        if (d.message) this.addMessage(d.message);
+        this.markRead(d.conversation);
+        this.setThread({ conversation: { ...d.conversation, unread: 0 } });
+      } else if (event === "error") {
+        this.setThread({ error: data?.message ?? "Something went wrong" });
+      }
+    });
+    try {
+      const res = await this.deps.streamPost(this.url(path), headers, payload, (chunk) => parser.feed(chunk));
+      parser.end();
+      if (res.status < 200 || res.status >= 300) throw new Error(`Request failed (${res.status})`);
+      if (!res.streamed && res.json) {
+        const d = res.json;
+        if ("token" in d) {
+          this.remember(d.conversation.id, d.token);
+          this.set({ view: { kind: "thread", conversationId: d.conversation.id } });
+        }
+        this.markRead(d.conversation);
+        this.setThread({ conversation: { ...d.conversation, unread: 0 } });
+        d.messages.forEach((m) => this.addMessage(m));
+      } else if (res.streamed && !finished) this.setThread({ error: "The reply was interrupted. Pull to refresh in a moment." });
+    } catch (err) {
+      this.setThread({ error: "Your message wasn't sent. Check your connection and try again.", draft: body });
+      this.deps.onError(err);
+    } finally {
+      const t = this.snapshot.thread;
+      if (t) this.setThread({ sending: false, streaming: {} });
+      this.scheduleThreadPoll();
+    }
+  }
+  addMessage(m) {
+    const t = this.snapshot.thread;
+    if (!t) return;
+    const exists = t.messages.some((x) => x.id === m.id);
+    const messages = exists ? t.messages.map((x) => x.id === m.id ? m : x) : [...t.messages, m];
+    const streaming = { ...t.streaming };
+    if (m.status !== "pending") delete streaming[m.id];
+    this.setThread({ messages, streaming });
+    if (!exists && m.status !== "pending" && (m.author === "scout" || m.author === "agent") && t.conversation) this.deps.onMessage(m, t.conversation);
+  }
+  async handoff() {
+    const id = this.snapshot.thread?.conversation?.id;
+    if (!id) return;
+    try {
+      const res = await this.request("POST", `/conversations/${encodeURIComponent(id)}/handoff`, { body: {}, conversationId: id });
+      this.markRead(res.conversation);
+      this.setThread({ conversation: { ...res.conversation, unread: 0 } });
+      res.messages.forEach((m) => this.addMessage(m));
+    } catch (err) {
+      this.setThread({ error: "Couldn't reach the team. Try again." });
+      this.deps.onError(err);
+    }
+  }
+  async rate(rating) {
+    const c = this.snapshot.thread?.conversation;
+    if (!c) return;
+    this.setThread({ conversation: { ...c, rating } });
+    try {
+      await this.request("POST", `/conversations/${encodeURIComponent(c.id)}/rating`, { body: { rating }, conversationId: c.id });
+    } catch (err) {
+      this.deps.onError(err);
+    }
+  }
+  startGuide(key) {
+    this.close();
+    this.deps.onStartGuide(key);
+  }
+  // -------------------------------------------------------------------------- help
+  async loadArticles() {
+    try {
+      this.set({ articles: await this.request("GET", "/articles") });
+    } catch (err) {
+      this.deps.onError(err);
+    }
+  }
+  async openArticle(id) {
+    const from = this.snapshot.view.kind === "article" ? this.snapshot.view.from : this.snapshot.view;
+    this.stopThreadPolling();
+    this.set({ open: true, view: { kind: "article", articleId: id, from }, article: null });
+    try {
+      const res = await this.request("GET", `/articles/${encodeURIComponent(id)}`);
+      this.set({ article: res.article });
+    } catch (err) {
+      this.deps.onError(err);
+    }
+  }
+  async search(q) {
+    try {
+      return (await this.request("GET", "/resource-center/search", { params: { q } })).articles;
+    } catch {
+      return [];
+    }
+  }
+  // -------------------------------------------------------------------------- polling
+  /** Called with app foreground/background changes; polling only runs in the foreground. */
+  setForeground(active) {
+    this.foreground = active;
+    if (!active) {
+      this.stopThreadPolling();
+      return;
+    }
+    void this.refreshConversations();
+    if (this.snapshot.open && this.snapshot.view.kind === "thread") this.scheduleThreadPoll();
+  }
+  startBackgroundPolling() {
+    this.backgroundTimer = setInterval(() => {
+      if (this.foreground && !(this.snapshot.open && this.snapshot.view.kind === "thread")) void this.refreshConversations();
+    }, this.poll.background);
+  }
+  scheduleThreadPoll() {
+    this.stopThreadPolling();
+    if (this.destroyed || !this.foreground) return;
+    this.threadTimer = setTimeout(() => void this.pollThread(), this.poll.thread);
+  }
+  stopThreadPolling() {
+    if (this.threadTimer) clearTimeout(this.threadTimer);
+    this.threadTimer = null;
+  }
+  async pollThread() {
+    const t = this.snapshot.thread;
+    const id = t?.conversation?.id;
+    if (!t || !id || !this.snapshot.open || t.sending) return this.scheduleThreadPoll();
+    const since = t.messages[t.messages.length - 1]?.createdAt;
+    try {
+      const res = await this.request("GET", `/conversations/${encodeURIComponent(id)}/messages`, { params: { since }, conversationId: id });
+      if (this.snapshot.thread?.conversation?.id !== id) return;
+      this.markRead(res.conversation);
+      this.setThread({ conversation: { ...res.conversation, unread: 0 } });
+      res.messages.forEach((m) => this.addMessage(m));
+    } catch (err) {
+      this.deps.onError(err);
+    }
+    this.scheduleThreadPoll();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.stopThreadPolling();
+    if (this.backgroundTimer) clearInterval(this.backgroundTimer);
+    this.listeners.clear();
+  }
+};
+
+// src/core/storage.ts
+var PersistentStore = class {
+  constructor(backing, onError = () => {
+  }) {
+    __publicField(this, "backing", backing);
+    __publicField(this, "onError", onError);
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "chain", Promise.resolve());
+  }
+  async hydrate(keys) {
+    if (!this.backing) return;
+    await Promise.all(
+      keys.map(async (k) => {
+        try {
+          const v = await this.backing.getItem(k);
+          if (v != null && !this.cache.has(k)) this.cache.set(k, v);
+        } catch (err) {
+          this.onError(err);
+        }
+      })
+    );
+  }
+  get(key) {
+    return this.cache.get(key) ?? null;
+  }
+  set(key, value) {
+    if (this.cache.get(key) === value) return;
+    this.cache.set(key, value);
+    this.write(() => this.backing?.setItem(key, value));
+  }
+  remove(key) {
+    if (!this.cache.has(key)) return;
+    this.cache.delete(key);
+    this.write(() => this.backing?.removeItem(key));
+  }
+  /** Resolves once every pending write has reached the backing storage. */
+  flush() {
+    return this.chain.then(() => void 0);
+  }
+  write(op) {
+    if (!this.backing) return;
+    this.chain = this.chain.then(async () => {
+      try {
+        await op();
+      } catch (err) {
+        this.onError(err);
+      }
+    });
+  }
+};
+
+// src/core/client.ts
+var SDK_NAME = "@guidelytech/react-native";
+var SDK_VERSION = "0.4.1";
+var DEFAULT_API_URL = "https://guidelytech.com";
+var PAGE_SCOPED = /* @__PURE__ */ new Set(["page_load", "url_match", "element_click", "element_visible", "delay"]);
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var emptyState = () => ({ guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] });
+var newSession = () => ({ id: `s_${randomId(16)}`, startedAt: nowIso(), lastActiveAt: nowIso(), shownGuides: [], events: [] });
+var GuidelyClient = class {
+  constructor(options, bridge) {
+    __publicField(this, "options");
+    __publicField(this, "targets", new TargetRegistry());
+    __publicField(this, "bridge");
+    __publicField(this, "api");
+    __publicField(this, "store");
+    __publicField(this, "emitter");
+    __publicField(this, "queue", null);
+    __publicField(this, "config", null);
+    __publicField(this, "configFetchedAt", 0);
+    __publicField(this, "etag", null);
+    __publicField(this, "anonymousId", "");
+    __publicField(this, "user", null);
+    __publicField(this, "state", emptyState());
+    __publicField(this, "session", newSession());
+    __publicField(this, "consent");
+    __publicField(this, "readyPromise", null);
+    __publicField(this, "hydrated", false);
+    __publicField(this, "pending", []);
+    __publicField(this, "isReady", false);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "active", null);
+    __publicField(this, "activeSurvey", null);
+    __publicField(this, "queued", []);
+    __publicField(this, "flows", /* @__PURE__ */ new Map());
+    __publicField(this, "checklists", /* @__PURE__ */ new Map());
+    __publicField(this, "expanded", /* @__PURE__ */ new Set());
+    __publicField(this, "surveyView", null);
+    __publicField(this, "resourceCenterOpen", false);
+    __publicField(this, "cleanups", []);
+    __publicField(this, "timers", /* @__PURE__ */ new Set());
+    __publicField(this, "visibilityWatchers", /* @__PURE__ */ new Map());
+    __publicField(this, "firedDelays", /* @__PURE__ */ new Set());
+    __publicField(this, "firstVisit", true);
+    __publicField(this, "screenName", "");
+    __publicField(this, "lastAudiences", /* @__PURE__ */ new Set());
+    __publicField(this, "backgroundedAt", null);
+    __publicField(this, "messenger", null);
+    __publicField(this, "ui", { steps: [], checklists: [], survey: null, resourceCenterOpen: false, theme: {}, messenger: false });
+    __publicField(this, "uiListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "customListeners", /* @__PURE__ */ new Map());
+    __publicField(this, "eventBus", {
+      on: (name, cb) => {
+        let set = this.customListeners.get(name);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.customListeners.set(name, set);
+        }
+        set.add(cb);
+        return () => void set?.delete(cb);
+      }
+    });
+    if (!options || !options.projectId) throw new Error("[Guidely] `projectId` (your environment public key, e.g. pk_dev_\u2026) is required.");
+    this.options = {
+      ...options,
+      environment: options.environment ?? (options.projectId.startsWith("pk_prod") ? "production" : options.projectId.startsWith("pk_stag") ? "staging" : "development"),
+      apiUrl: options.apiUrl ?? DEFAULT_API_URL,
+      analytics: options.analytics ?? true,
+      configRefreshMs: options.configRefreshMs ?? 5 * 60 * 1e3,
+      debug: options.debug ?? false
+    };
+    this.bridge = bridge;
+    this.consent = options.consent ?? "granted";
+    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.");
+    this.cleanups.push(this.targets.onTap((id) => this.handleTap(id)));
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /** Loads persisted state and config, identifies the stored user and evaluates triggers. Idempotent. */
+  init() {
+    if (!this.readyPromise) this.readyPromise = this.bootstrap();
+    return this.readyPromise;
+  }
+  ready() {
+    return this.init();
+  }
+  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)]);
+      if (this.destroyed) return;
+      this.anonymousId = this.store.get(KEYS.anon) || "";
+      if (!this.anonymousId) {
+        this.anonymousId = `anon_${randomId(20)}`;
+        this.store.set(KEYS.anon, this.anonymousId);
+      }
+      this.firstVisit = !this.store.get(KEYS.seen);
+      this.store.set(KEYS.seen, nowIso());
+      this.state = { ...emptyState(), ...readJson(this.store, KEYS.state(key), {}) };
+      this.user = this.options.user ? { ...this.options.user } : readJson(this.store, KEYS.user(key), null);
+      const saved = readJson(this.store, KEYS.session, null);
+      this.session = saved?.id && !this.sessionExpired(Date.parse(saved.lastActiveAt)) ? saved : newSession();
+      this.persistSession();
+      this.lastAudiences = new Set(this.state.audienceIds);
+      this.queue = new EventQueue({
+        store: this.store,
+        storageKey: KEYS.queue(key),
+        enabled: () => this.analyticsEnabled(),
+        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.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();
+      if (this.destroyed) return;
+      this.wireTimers();
+      if (this.user?.id) await this.identify(this.user.id, this.user.traits, this.user.account);
+      if (this.destroyed) return;
+      this.isReady = true;
+      if (this.config) this.emitter.emit("ready", this.config);
+      this.notify();
+      this.evaluate("ready");
+    } catch (err) {
+      this.reportError(err);
+      this.isReady = true;
+    }
+  }
+  whenHydrated(fn) {
+    if (this.destroyed) return;
+    if (this.hydrated) fn();
+    else this.pending.push(fn);
+  }
+  async fetchConfig() {
+    try {
+      const res = await this.api.get("/config", { etag: this.etag, params: { platform: this.bridge.device.platform } });
+      this.configFetchedAt = Date.now();
+      if (res.status === 304) return true;
+      if (res.ok && res.data && Array.isArray(res.data.guides)) {
+        this.config = forPlatform(res.data, this.bridge.device.platform);
+        this.etag = res.etag;
+        writeJson(this.store, KEYS.config(this.options.projectId), res.data);
+        if (res.etag) this.store.set(KEYS.etag(this.options.projectId), res.etag);
+        else this.store.remove(KEYS.etag(this.options.projectId));
+        this.syncMessenger();
+        this.emitter.emit("config", this.config);
+        this.log("config loaded", this.config.configVersion, `${this.config.guides.length} guides`);
+        return true;
+      }
+      this.reportError(new Error(`[Guidely] config request failed (${res.status})${this.config ? "; using cached config" : ""}`));
+      return false;
+    } catch (err) {
+      this.reportError(new Error(`[Guidely] config request failed: ${err instanceof Error ? err.message : String(err)}${this.config ? "; using cached config" : ""}`));
+      return false;
+    }
+  }
+  wireTimers() {
+    const refresh = setInterval(() => 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);
+      this.drainQueue(url, ctx);
+    }, 1e3);
+    this.cleanups.push(() => clearInterval(poll));
+  }
+  /** Re-fetches the published config and re-evaluates triggers. */
+  async refresh() {
+    if (this.destroyed) return;
+    const before = this.config?.configVersion;
+    await this.fetchConfig();
+    if (this.config && this.config.configVersion !== before) {
+      this.notify();
+      this.evaluate("ready");
+    }
+  }
+  /** Called by the provider with React Native `AppState` changes. */
+  setAppState(state) {
+    if (this.destroyed || !this.hydrated) return;
+    if (state === "background") {
+      this.backgroundedAt = Date.now();
+      this.session.lastActiveAt = nowIso();
+      this.persistSession();
+      void this.queue?.flush();
+      void this.store.flush();
+      this.messenger?.setForeground(false);
+    } else if (state === "active" && this.backgroundedAt !== null) {
+      this.messenger?.setForeground(true);
+      const away = this.backgroundedAt;
+      this.backgroundedAt = null;
+      if (this.sessionExpired(away)) {
+        this.session = newSession();
+        this.persistSession();
+        this.firedDelays.clear();
+      }
+      if (Date.now() - this.configFetchedAt > this.options.configRefreshMs) void this.refresh();
+      else if (this.isReady) this.evaluate("ready");
+    }
+  }
+  sessionExpired(lastActiveMs) {
+    const minutes = this.config?.settings?.sessionTimeoutMinutes ?? 30;
+    return !Number.isFinite(lastActiveMs) || Date.now() - lastActiveMs > minutes * 6e4;
+  }
+  /** Tears everything down. Create a new client to start again. */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.active?.controller.destroy();
+    this.active = null;
+    this.flows.forEach((f) => f.controller.destroy());
+    this.flows.clear();
+    this.queued = [];
+    this.messenger?.destroy();
+    this.messenger = null;
+    this.visibilityWatchers.forEach((stop) => stop());
+    this.visibilityWatchers.clear();
+    this.timers.forEach((t) => clearTimeout(t));
+    this.timers.clear();
+    this.cleanups.splice(0).forEach((fn) => fn());
+    void this.queue?.flush();
+    this.queue?.destroy();
+    this.emitter.clear();
+    this.uiListeners.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Identity
+  // ---------------------------------------------------------------------------
+  /** Identifies the end user and loads server-held state (audiences, guide history, checklist progress). */
+  identify(userId, traits, account) {
+    return new Promise(
+      (resolve) => this.whenHydrated(() => {
+        const id = String(userId);
+        const same = this.user?.id === id;
+        this.user = { id, traits: { ...same ? this.user?.traits : {}, ...traits || {} }, account: account ?? (same ? this.user?.account : void 0) };
+        writeJson(this.store, KEYS.user(this.options.projectId), this.user);
+        this.enqueue("identify", { properties: { traits: sanitizeProperties(this.user.traits) } });
+        void this.syncIdentify().then(() => {
+          this.emitter.emit("identify", { userId: id, anonymousId: this.anonymousId });
+          if (this.isReady) this.evaluate("identify");
+          resolve();
+        });
+      })
+    );
+  }
+  async syncIdentify() {
+    const body = { anonymousId: this.anonymousId, userId: this.user?.id || null, traits: this.user?.traits, account: this.user?.account ? { id: this.user.account.id, traits: this.user.account.traits } : null, sessionId: this.session.id, url: this.collectUrls() ? this.currentUrl() : void 0 };
+    const res = await postWithRetry(this.api, "/identify", body, 2);
+    if (res?.ok && res.data) this.mergeServerState(res.data);
+  }
+  mergeServerState(data) {
+    const guides = { ...this.state.guides };
+    for (const [id, s] of Object.entries(data.guideState || {})) {
+      const local = guides[id];
+      guides[id] = {
+        impressions: Math.max(local?.impressions ?? 0, s.impressions ?? 0),
+        completedAt: local?.completedAt ?? s.completedAt ?? null,
+        dismissedAt: local?.dismissedAt ?? s.dismissedAt ?? null,
+        lastShownAt: local?.lastShownAt ?? s.lastShownAt ?? null
+      };
+    }
+    const checklists = { ...this.state.checklists };
+    for (const [id, p] of Object.entries(data.checklistProgress || {})) {
+      const local = checklists[id];
+      checklists[id] = {
+        completedTaskIds: Array.from(/* @__PURE__ */ new Set([...local?.completedTaskIds ?? [], ...p.completedTaskIds ?? []])),
+        completedAt: local?.completedAt ?? p.completedAt ?? null,
+        dismissedAt: local?.dismissedAt ?? p.dismissedAt ?? null
+      };
+    }
+    this.state = {
+      guides,
+      checklists,
+      surveysSubmitted: Array.from(/* @__PURE__ */ new Set([...this.state.surveysSubmitted, ...data.surveysSubmitted || []])),
+      audienceIds: data.audienceIds || [],
+      firstSeenAt: this.state.firstSeenAt ?? data.firstSeenAt
+    };
+    if (data.firstSeenAt && Date.now() - Date.parse(data.firstSeenAt) > 6e4) this.firstVisit = false;
+    this.persistState();
+    this.notify();
+  }
+  /** Sets or replaces the account (company / organisation) for the current user. */
+  async setAccount(account) {
+    await this.init();
+    if (!this.user?.id) {
+      this.user = { id: "", traits: this.user?.traits, account };
+      writeJson(this.store, KEYS.user(this.options.projectId), this.user);
+      return;
+    }
+    await this.identify(this.user.id, void 0, account);
+  }
+  /** Merges additional traits into the current user. */
+  async updateTraits(traits) {
+    await this.init();
+    if (!this.user?.id) {
+      this.user = { id: "", traits: { ...this.user?.traits || {}, ...traits }, account: this.user?.account };
+      return;
+    }
+    await this.identify(this.user.id, traits, this.user.account);
+  }
+  /** Forgets the user (call on logout): new anonymous id, cleared guide/checklist state, new session. */
+  reset() {
+    this.whenHydrated(() => {
+      this.stopGuide();
+      this.flows.forEach((f) => f.controller.destroy());
+      this.flows.clear();
+      this.checklists.clear();
+      this.surveyView = null;
+      this.activeSurvey = null;
+      this.resourceCenterOpen = false;
+      if (this.messenger) this.messenger.forgetAll();
+      else this.store.remove(KEYS.conversations(this.options.projectId));
+      this.user = null;
+      this.store.remove(KEYS.user(this.options.projectId));
+      this.anonymousId = `anon_${randomId(20)}`;
+      this.store.set(KEYS.anon, this.anonymousId);
+      this.state = emptyState();
+      this.persistState();
+      this.session = newSession();
+      this.persistSession();
+      this.lastAudiences = /* @__PURE__ */ new Set();
+      this.firedDelays.clear();
+      this.firstVisit = true;
+      this.emitter.emit("identify", { userId: null, anonymousId: this.anonymousId });
+      this.notify();
+      if (this.isReady) this.evaluate("identify");
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Events & screens
+  // ---------------------------------------------------------------------------
+  /** Updates consent at runtime (`granted` flushes buffered events; `denied` drops them). */
+  setConsent(consent) {
+    this.consent = consent;
+    this.whenHydrated(() => {
+      if (consent === "denied") this.queue?.clear();
+      else if (consent === "granted") void this.queue?.flush();
+    });
+  }
+  analyticsEnabled() {
+    return this.options.analytics && this.consent === "granted" && (this.config?.settings?.analyticsEnabled ?? true);
+  }
+  collectUrls() {
+    return this.config?.settings?.collectUrls ?? true;
+  }
+  currentUrl() {
+    return screenPath(this.screenName);
+  }
+  enqueue(name, extra = {}) {
+    if (this.consent === "denied" || !this.options.analytics || !this.queue) return null;
+    const event = {
+      eventId: randomId(24),
+      name,
+      occurredAt: nowIso(),
+      anonymousId: this.anonymousId,
+      userId: this.user?.id || null,
+      accountId: this.user?.account?.id || null,
+      sessionId: this.session.id,
+      url: this.collectUrls() && this.screenName ? this.currentUrl() : void 0,
+      ...extra
+    };
+    if (extra.properties) event.properties = sanitizeProperties(extra.properties);
+    this.queue.enqueue(event);
+    this.emitter.emit("track", event);
+    return event;
+  }
+  /** Tracks a custom event. Events drive `event` triggers, `advanceOn: "event"` steps and checklist tasks. */
+  track(name, properties) {
+    if (!name) return;
+    this.whenHydrated(() => {
+      if (!this.session.events.includes(name)) {
+        this.session.events.push(name);
+        this.persistSession();
+      }
+      this.enqueue("custom", { customName: name.slice(0, 120), properties: properties ?? {} });
+      this.customListeners.get(name)?.forEach((cb) => {
+        try {
+          cb();
+        } catch (err) {
+          this.reportError(err);
+        }
+      });
+      this.completeChecklistTasksBy("event", name);
+      if (this.isReady) this.evaluate("event", { eventName: name });
+    });
+  }
+  /**
+   * Records a screen view (the mobile equivalent of a page view) and re-evaluates triggers. URL
+   * patterns, `url_match` triggers, multi-screen steps and `url_visited` tasks match `/<name>`.
+   */
+  screen(name, properties) {
+    if (!name) return;
+    this.whenHydrated(() => {
+      const changed = name !== this.screenName;
+      this.screenName = name;
+      this.targets.setScreen(name);
+      const url = this.currentUrl();
+      if (changed) this.enqueue("page_view", { properties: { ...properties, path: url, screen: name } });
+      this.completeChecklistTasksBy("url_visited", url);
+      this.active?.controller.resume();
+      this.flows.forEach((f) => f.controller.resume());
+      if (this.active) {
+        const st = this.active.controller.getState();
+        const g = this.active.guide;
+        if (st.status === "running" && !this.active.manual && g.config.urlPatterns.length && !g.config.urlPatterns.some((p) => screenMatches(p, url))) this.active.controller.destroy();
+      }
+      this.flows.forEach((f) => {
+        const patterns = f.guide.config.urlPatterns;
+        if (!f.manual && patterns.length && !patterns.some((p) => screenMatches(p, url))) f.controller.destroy();
+      });
+      this.firedDelays.clear();
+      if (this.isReady) this.evaluate("navigation");
+      if (changed) void this.queue?.flush();
+    });
+  }
+  /** The current screen name (last value passed to `screen()`). */
+  getScreen() {
+    return this.screenName;
+  }
+  handleTap(targetId) {
+    if (!this.hydrated) return;
+    this.completeChecklistTasksBy("click", targetId);
+    if (this.isReady) this.evaluate("click", { targetId });
+  }
+  // ---------------------------------------------------------------------------
+  // Targeting + triggers
+  // ---------------------------------------------------------------------------
+  /** Builds the targeting context for the current moment. */
+  getContext() {
+    const guides = this.state.guides;
+    const keysOf = (ids) => ids.flatMap((id) => [id, this.findGuide(id)?.key ?? id]);
+    const url = this.currentUrl();
+    const device = this.bridge.device;
+    return {
+      anonymousId: this.anonymousId,
+      userId: this.user?.id || null,
+      userAttributes: this.user?.traits ?? {},
+      accountAttributes: this.user?.account?.traits ?? {},
+      url,
+      path: url,
+      query: {},
+      device: { type: device.deviceType, os: device.platform },
+      firstVisit: this.firstVisit,
+      eventsSeen: new Set(this.session.events),
+      completedGuides: new Set(keysOf(Object.keys(guides).filter((id) => guides[id]?.completedAt))),
+      dismissedGuides: new Set(keysOf(Object.keys(guides).filter((id) => guides[id]?.dismissedAt))),
+      seenGuides: new Set(keysOf(Object.keys(guides).filter((id) => (guides[id]?.impressions ?? 0) > 0))),
+      completedChecklists: new Set(keysOf(Object.entries(this.state.checklists).filter(([, p]) => !!p.completedAt).map(([id]) => id))),
+      audienceIds: new Set(this.state.audienceIds),
+      now: /* @__PURE__ */ new Date(),
+      environment: this.options.environment,
+      locale: device.locale,
+      platform: device.platform,
+      screen: this.screenName,
+      appVersion: this.options.appVersion ?? device.appVersion
+    };
+  }
+  isTargeted(guide, ctx, url) {
+    const c = guide.config;
+    if (c.urlPatterns.length && !c.urlPatterns.some((p) => screenMatches(p, url))) return false;
+    if (c.trigger.urlPattern && !screenMatches(c.trigger.urlPattern, url)) return false;
+    if (!isWithinSchedule(guide)) return false;
+    if (guide.kind === "survey" && (this.state.surveysSubmitted.includes(guide.id) || this.state.surveysSubmitted.includes(guide.key))) return false;
+    ctx.rolloutSalt = guide.id;
+    return evaluateRules(c.targeting, ctx);
+  }
+  isEligible(guide, ctx, url) {
+    if (!this.isTargeted(guide, ctx, url)) return false;
+    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));
+  }
+  triggerFires(guide, reason, detail) {
+    const t = guide.config.trigger;
+    switch (t.type) {
+      case "page_load":
+        if (t.delayMs > 0) return reason === "timer" && detail.guideId === guide.id;
+        return reason === "ready" || reason === "navigation" || reason === "identify";
+      case "url_match":
+        return (reason === "ready" || reason === "navigation" || reason === "identify") && screenMatches(t.value, this.currentUrl());
+      case "event":
+        return reason === "event" && !!t.value && detail.eventName === t.value;
+      case "element_click":
+        return reason === "click" && !!detail.targetId && guidelyIdFromSelector(t.value) === detail.targetId;
+      case "element_visible":
+        return reason === "visible" && detail.guideId === guide.id;
+      case "delay":
+        return reason === "timer" && detail.guideId === guide.id;
+      case "after_guide":
+        return reason === "after_guide" && !!detail.endedGuide && (detail.endedGuide.id === t.value || detail.endedGuide.key === t.value);
+      case "segment_enter":
+        return reason === "identify" && !!t.value && !!detail.newAudiences?.has(t.value);
+      case "manual":
+      default:
+        return false;
+    }
+  }
+  evaluate(reason, detail = {}) {
+    if (!this.config || this.destroyed) return;
+    const url = this.currentUrl();
+    const ctx = this.getContext();
+    if (reason === "identify") {
+      const current = new Set(this.state.audienceIds);
+      detail.newAudiences = new Set(Array.from(current).filter((a) => !this.lastAudiences.has(a)));
+      this.lastAudiences = current;
+    }
+    const candidates = [];
+    for (const guide of this.config.guides) {
+      const t = guide.config.trigger;
+      if (detail.endedGuide && detail.endedGuide.id === guide.id) continue;
+      if (reason === "ready" || reason === "navigation") {
+        if (t.type === "element_visible" && t.value) this.armVisibility(guide, ctx, url);
+        if ((t.type === "delay" || t.type === "page_load" && t.delayMs > 0) && !this.firedDelays.has(guide.id)) {
+          if (!this.isEligible(guide, ctx, url)) continue;
+          this.firedDelays.add(guide.id);
+          this.setTimer(() => this.evaluate("timer", { guideId: guide.id }), t.delayMs);
+          continue;
+        }
+      }
+      if (t.type === "page_load" && t.delayMs > 0 && reason !== "timer") continue;
+      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;
+      candidates.push(guide);
+    }
+    if (reason === "after_guide" || reason === "navigation") this.drainQueue(url, ctx);
+    if (!candidates.length) return;
+    candidates.sort((a, b) => a.config.frequency.priority - b.config.frequency.priority);
+    for (const guide of candidates) {
+      if (this.isShowing(guide.id)) continue;
+      const delay = guide.config.trigger.type !== "delay" && guide.config.trigger.type !== "page_load" ? guide.config.trigger.delayMs : 0;
+      if (delay > 0) this.setTimer(() => this.tryShow(guide, url, false), delay);
+      else this.tryShow(guide, url, false);
+    }
+  }
+  armVisibility(guide, ctx, url) {
+    const id = guidelyIdFromSelector(guide.config.trigger.value);
+    if (!id || this.visibilityWatchers.has(guide.id) || !this.isEligible(guide, ctx, url)) return;
+    const ac = new AbortController();
+    const stop = () => {
+      ac.abort();
+      this.visibilityWatchers.delete(guide.id);
+    };
+    this.visibilityWatchers.set(guide.id, stop);
+    this.targets.waitFor([id], { timeoutMs: 0, signal: ac.signal }).then(
+      () => {
+        if (ac.signal.aborted) return;
+        stop();
+        this.evaluate("visible", { guideId: guide.id });
+      },
+      () => stop()
+    );
+  }
+  setTimer(fn, ms) {
+    const t = setTimeout(() => {
+      this.timers.delete(t);
+      if (!this.destroyed) fn();
+    }, ms);
+    this.timers.add(t);
+  }
+  isShowing(id) {
+    return this.flows.has(id) || this.checklists.has(id) || this.active?.guide.id === id || this.activeSurvey?.guide.id === id;
+  }
+  hasExclusive() {
+    return this.active?.guide ?? this.activeSurvey?.guide ?? null;
+  }
+  tryShow(guide, url, manual) {
+    if (this.destroyed) return false;
+    if (!isExclusiveGuide(guide)) {
+      if (this.flows.has(guide.id) || this.checklists.has(guide.id)) return false;
+      this.show(guide, manual);
+      return true;
+    }
+    const current = this.hasExclusive();
+    if (current) {
+      if (current.id === guide.id) return false;
+      if (manual) this.stopGuide();
+      else {
+        if (!this.queued.some((q) => q.guide.id === guide.id)) this.queued.push({ guide, url, pageScoped: PAGE_SCOPED.has(guide.config.trigger.type) });
+        this.log("queued", guide.key, "behind", current.key);
+        return false;
+      }
+    }
+    const blocked = [...this.flows.values()].map((f) => f.guide).some((g) => areMutuallyExclusive(g, guide));
+    if (blocked && !manual) {
+      if (!this.queued.some((q) => q.guide.id === guide.id)) this.queued.push({ guide, url, pageScoped: true });
+      return false;
+    }
+    this.show(guide, manual);
+    return true;
+  }
+  drainQueue(url, ctx) {
+    if (this.hasExclusive()) return;
+    this.queued = this.queued.filter((q) => !(q.pageScoped && q.url !== url));
+    while (this.queued.length) {
+      const next = this.queued.shift();
+      if (!this.isEligible(next.guide, ctx, url)) continue;
+      if (this.tryShow(next.guide, url, false)) return;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Showing guides
+  // ---------------------------------------------------------------------------
+  findGuide(idOrKey) {
+    return this.config?.guides.find((g) => g.id === idOrKey || g.key === idOrKey);
+  }
+  guideState(id) {
+    return this.state.guides[id] ?? (this.state.guides[id] = { impressions: 0 });
+  }
+  recordImpression(guide) {
+    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.persistState();
+    this.persistSession();
+    this.syncGuideState(guide.id, { impression: true });
+  }
+  recordEnd(guide, reason) {
+    const s = this.guideState(guide.id);
+    if (reason === "completed") s.completedAt = nowIso();
+    else s.dismissedAt = nowIso();
+    this.persistState();
+    this.syncGuideState(guide.id, reason === "completed" ? { completed: true } : { dismissed: true });
+    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 }] });
+  }
+  show(guide, manual, stepId) {
+    try {
+      if (guide.kind === "checklist" && guide.config.checklist) return this.showChecklist(guide);
+      if (guide.kind === "survey" && guide.config.survey) return this.showSurvey(guide, manual);
+      this.showFlow(guide, manual, stepId);
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  showFlow(guide, manual, stepId) {
+    const exclusive = isExclusiveGuide(guide);
+    const flow = { guide, manual, view: null, controller: null };
+    let renders = 0;
+    flow.controller = runGuide(guide, {
+      targets: this.targets,
+      ctx: () => this.getContext(),
+      currentUrl: () => this.currentUrl(),
+      startAtStep: stepId,
+      eventBus: this.eventBus,
+      onError: (err) => this.reportError(err),
+      onEvent: (e) => {
+        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.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 });
+        } else if (e.name === "guide_completed") {
+          this.recordEnd(guide, "completed");
+          this.emitter.emit("guide:complete", guide);
+        } else if (e.name === "guide_dismissed") {
+          this.recordEnd(guide, "dismissed");
+          this.emitter.emit("guide:dismiss", guide);
+        } else if (e.name === "guide_skipped") {
+          this.recordEnd(guide, "skipped");
+          this.emitter.emit("guide:skip", guide);
+        }
+      },
+      onRender: (r) => {
+        renders += 1;
+        this.expanded.delete(guide.id);
+        flow.view = { key: `${guide.id}:${r.step.id}:${renders}`, guide, step: r.step, index: r.index, total: r.total, canGoBack: r.canGoBack, targetId: r.targetId, asModal: r.asModal, expanded: false };
+        this.notify();
+      },
+      onClear: () => {
+        flow.view = null;
+        this.notify();
+      },
+      onNavigate: (url) => this.navigate(url),
+      onAction: (action, value) => {
+        if (action === "start_guide" && value) this.setTimer(() => this.startGuide(value), 0);
+        else if (action === "event" && value) this.track(value);
+        else if (action === "open_resource_center") this.openResourceCenter();
+      },
+      onEnd: (reason) => {
+        if (exclusive) {
+          if (this.active === flow) this.active = null;
+        } else if (this.flows.get(guide.id) === flow) this.flows.delete(guide.id);
+        this.notify();
+        if (reason !== "destroyed" && !this.destroyed) this.setTimer(() => this.evaluate("after_guide", { endedGuide: guide }), 0);
+      }
+    });
+    if (exclusive) this.active = flow;
+    else this.flows.set(guide.id, flow);
+    flow.controller.start();
+    if (flow.controller.getState().status === "ended") {
+      if (this.active === flow) this.active = null;
+      if (this.flows.get(guide.id) === flow) this.flows.delete(guide.id);
+    }
+  }
+  showChecklist(guide, open) {
+    const config = guide.config.checklist;
+    if (!config || this.checklists.has(guide.id)) 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) });
+    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;
+    this.activeSurvey = { guide, manual };
+    this.surveyView = { key: `${guide.id}:${randomId(6)}`, guide, submitted: false };
+    this.recordImpression(guide);
+    this.enqueue("survey_displayed", { guideId: guide.id, guideVersion: guide.version });
+    this.emitter.emit("guide:start", guide);
+    this.notify();
+  }
+  finishSurvey(reason) {
+    const s = this.activeSurvey;
+    if (!s) return;
+    this.activeSurvey = null;
+    this.surveyView = null;
+    if (reason === "dismissed") {
+      this.enqueue("survey_dismissed", { guideId: s.guide.id, guideVersion: s.guide.version });
+      this.recordEnd(s.guide, "dismissed");
+      this.emitter.emit("guide:dismiss", s.guide);
+    }
+    this.notify();
+    this.setTimer(() => this.evaluate("after_guide", { endedGuide: s.guide }), 0);
+  }
+  /** Theme for a guide: project theme ← app overrides ← guide appearance. */
+  themeFor(guide) {
+    const a = guide?.config.appearance;
+    return {
+      ...this.config?.theme || {},
+      ...this.options.theme || {},
+      ...a?.primaryColor ? { primaryColor: a.primaryColor } : {},
+      ...a?.backgroundColor ? { backgroundColor: a.backgroundColor } : {},
+      ...a?.textColor ? { textColor: a.textColor } : {},
+      ...a?.borderRadius != null ? { borderRadius: a.borderRadius } : {},
+      dark: a?.theme ?? "auto",
+      overlayOpacity: a?.overlayOpacity
+    };
+  }
+  /**
+   * Opens a URL from a button, link or task: the app's `onNavigate` handler first (deep links and
+   * in-app routes), then http(s) and custom-scheme URLs through the OS.
+   */
+  navigate(url) {
+    if (!url) return;
+    try {
+      if (this.options.onNavigate?.(url) === true) return;
+      if (/^[a-z][a-z0-9+.-]*:/i.test(url)) this.bridge.openExternal(url);
+      else if (!this.options.onNavigate) this.log(`no onNavigate handler for in-app URL "${url}"`);
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // UI state (consumed by the overlay)
+  // ---------------------------------------------------------------------------
+  getUiState() {
+    return this.ui;
+  }
+  subscribeUi(cb) {
+    this.uiListeners.add(cb);
+    return () => this.uiListeners.delete(cb);
+  }
+  notify() {
+    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.ui = { steps, checklists, survey: this.surveyView, resourceCenterOpen: this.resourceCenterOpen, theme: this.themeFor(), messenger: !!this.messenger };
+    for (const cb of Array.from(this.uiListeners)) {
+      try {
+        cb();
+      } catch (err) {
+        this.reportError(err);
+      }
+    }
+  }
+  flowFor(guideId) {
+    return this.active?.guide.id === guideId ? this.active : this.flows.get(guideId);
+  }
+  /** A step button was pressed in the overlay. */
+  pressButton(guideId, button) {
+    this.flowFor(guideId)?.controller.press(button);
+  }
+  /** The close (×) button of a step. */
+  closeStep(guideId) {
+    this.flowFor(guideId)?.controller.dismiss();
+  }
+  /** The dimmed backdrop behind a step was tapped. */
+  backdropPressed(guideId) {
+    const f = this.flowFor(guideId);
+    if (f?.view?.step.dismissOnOutsideClick) f.controller.dismiss();
+  }
+  /** Hotspot dot tapped: show (or hide) its card. */
+  toggleHotspot(guideId) {
+    if (this.expanded.has(guideId)) this.expanded.delete(guideId);
+    else this.expanded.add(guideId);
+    this.notify();
+  }
+  setChecklistOpen(guideId, open) {
+    const w = this.checklists.get(guideId);
+    const guide = this.findGuide(guideId);
+    if (!w || !guide || w.open === open) return;
+    w.open = open;
+    if (open) this.enqueue("guide_viewed", { guideId: guide.id, guideVersion: guide.version });
+    this.notify();
+  }
+  checklistTaskPressed(guideId, taskId) {
+    const guide = this.findGuide(guideId);
+    const task = guide?.config.checklist?.tasks.find((t) => t.id === taskId);
+    if (!guide || !task) return;
+    if (task.completion === "manual") this.markTaskDone(guide, task);
+    if (task.action === "start_guide" && task.actionValue) {
+      this.setChecklistOpen(guide.id, false);
+      this.startGuide(task.actionValue);
+    } else if (task.action === "url" && task.actionValue) this.navigate(task.actionValue);
+    else if (task.action === "event" && task.actionValue) this.track(task.actionValue);
+  }
+  dismissChecklist(guideId) {
+    const guide = this.findGuide(guideId);
+    if (!guide) return;
+    const progress = this.state.checklists[guide.id] ?? (this.state.checklists[guide.id] = { completedTaskIds: [] });
+    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.checklists.delete(guide.id);
+    this.notify();
+  }
+  submitSurvey(guideId, answers) {
+    const s = this.activeSurvey;
+    if (!s || s.guide.id !== guideId || !this.surveyView || this.surveyView.submitted) return;
+    const guide = s.guide;
+    const responseId = randomId(24);
+    this.state.surveysSubmitted.push(guide.id);
+    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.emitter.emit("survey:submit", { guide, answers, responseId });
+    this.emitter.emit("guide:complete", guide);
+    this.surveyView = { ...this.surveyView, submitted: true };
+    this.notify();
+  }
+  closeSurvey(guideId) {
+    if (this.activeSurvey?.guide.id !== guideId) return;
+    this.finishSurvey(this.surveyView?.submitted ? "submitted" : "dismissed");
+  }
+  getResourceCenter() {
+    const rc = this.config?.resourceCenter;
+    return rc && rc.enabled ? rc : null;
+  }
+  async searchResourceCenter(q) {
+    try {
+      const res = await this.api.get("/resource-center/search", { params: { q } });
+      return res.ok && res.data ? res.data.articles : [];
+    } catch {
+      return [];
+    }
+  }
+  articleViewed(article) {
+    this.enqueue("article_viewed", { properties: { articleId: article.id, slug: article.slug } });
+  }
+  // ---------------------------------------------------------------------------
+  // Checklists
+  // ---------------------------------------------------------------------------
+  getChecklistProgress(idOrKey) {
+    const id = this.findGuide(idOrKey)?.id ?? idOrKey;
+    const p = this.state.checklists[id];
+    return p ? { completedTaskIds: [...p.completedTaskIds], completedAt: p.completedAt ?? null, dismissedAt: p.dismissedAt ?? null } : { completedTaskIds: [], completedAt: null, dismissedAt: null };
+  }
+  completeChecklistTask(idOrKey, taskId) {
+    this.whenHydrated(() => {
+      const guide = this.findGuide(idOrKey);
+      const task = guide?.config.checklist?.tasks.find((t) => t.id === taskId);
+      if (guide && task) this.markTaskDone(guide, task);
+    });
+  }
+  markTaskDone(guide, task) {
+    const config = guide.config.checklist;
+    if (!config) return;
+    const progress = this.state.checklists[guide.id] ?? (this.state.checklists[guide.id] = { completedTaskIds: [] });
+    if (progress.completedTaskIds.includes(task.id)) return;
+    progress.completedTaskIds.push(task.id);
+    this.enqueue("checklist_task_completed", { guideId: guide.id, guideVersion: guide.version, properties: { taskId: task.id } });
+    const complete = isChecklistComplete(config, progress) && !progress.completedAt;
+    if (complete) {
+      progress.completedAt = nowIso();
+      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.emitter.emit("checklist:task", { guide, task, progress: this.getChecklistProgress(guide.id) });
+    if (complete) {
+      this.emitter.emit("checklist:complete", guide);
+      const w = this.checklists.get(guide.id);
+      if (w) w.open = true;
+    }
+    this.notify();
+  }
+  completeChecklistTasksBy(kind, value) {
+    if (!this.config) return;
+    for (const guide of this.config.guides) {
+      for (const task of guide.config.checklist?.tasks ?? []) {
+        if (task.completion !== kind || !task.completionValue) continue;
+        let hit = false;
+        if (kind === "event") hit = value === task.completionValue;
+        else if (kind === "url_visited") hit = screenMatches(screenPath(task.completionValue), value) || screenMatches(task.completionValue, value);
+        else if (kind === "guide_completed") hit = value.id === task.completionValue || value.key === task.completionValue;
+        else if (kind === "click") hit = guidelyIdFromSelector(task.completionValue) === value;
+        if (hit) this.markTaskDone(guide, task);
+      }
+    }
+  }
+  openChecklist(idOrKey) {
+    this.whenHydrated(() => {
+      const guide = this.findGuide(idOrKey);
+      if (!guide?.config.checklist) return;
+      if (!this.checklists.has(guide.id)) {
+        const p = this.state.checklists[guide.id];
+        if (p?.dismissedAt) {
+          delete p.dismissedAt;
+          this.persistState();
+        }
+        this.showChecklist(guide, true);
+      }
+      this.setChecklistOpen(guide.id, true);
+    });
+  }
+  closeChecklist(idOrKey) {
+    const guide = this.findGuide(idOrKey);
+    if (guide) this.setChecklistOpen(guide.id, false);
+  }
+  // ---------------------------------------------------------------------------
+  // Public guide controls
+  // ---------------------------------------------------------------------------
+  /** Starts a guide by id or key, bypassing targeting and frequency rules. */
+  startGuide(idOrKey, options = {}) {
+    const guide = this.findGuide(idOrKey);
+    if (!guide) {
+      this.reportError(new Error(`[Guidely] startGuide: unknown guide "${idOrKey}"`));
+      return false;
+    }
+    if (guide.kind === "checklist") {
+      this.openChecklist(guide.id);
+      return true;
+    }
+    if (this.hasExclusive()) this.stopGuide();
+    this.flows.get(guide.id)?.controller.destroy();
+    this.flows.delete(guide.id);
+    this.show(guide, true, options.stepId);
+    return true;
+  }
+  /** Stops the active guide silently (no dismiss event). */
+  stopGuide() {
+    const a = this.active;
+    if (a) {
+      this.active = null;
+      a.controller.destroy();
+    }
+    if (this.activeSurvey) {
+      this.activeSurvey = null;
+      this.surveyView = null;
+    }
+    this.notify();
+  }
+  /** Dismisses the active guide (records a dismissal). */
+  dismissGuide() {
+    if (this.active) this.active.controller.dismiss();
+    else if (this.activeSurvey) this.finishSurvey("dismissed");
+  }
+  getActiveGuide() {
+    return this.hasExclusive();
+  }
+  getGuides() {
+    return this.config?.guides ?? [];
+  }
+  isGuideCompleted(idOrKey) {
+    const guide = this.findGuide(idOrKey);
+    return !!this.state.guides[guide?.id ?? idOrKey]?.completedAt;
+  }
+  /** Impressions, completion and dismissal for a guide. */
+  getGuideState(idOrKey) {
+    const guide = this.findGuide(idOrKey);
+    return { impressions: 0, ...this.state.guides[guide?.id ?? idOrKey] ?? {} };
+  }
+  openResourceCenter() {
+    if (this.messenger) return this.openMessenger("help");
+    if (!this.getResourceCenter()) {
+      this.log("openResourceCenter: the resource center is not enabled or published for this environment");
+      return;
+    }
+    if (this.resourceCenterOpen) return;
+    this.resourceCenterOpen = true;
+    this.enqueue("resource_center_opened");
+    this.emitter.emit("resource-center:open");
+    this.notify();
+  }
+  closeResourceCenter() {
+    if (this.messenger) return this.closeMessenger();
+    if (!this.resourceCenterOpen) return;
+    this.resourceCenterOpen = false;
+    this.notify();
+  }
+  // ---------------------------------------------------------------------------
+  // Scout messenger
+  // ---------------------------------------------------------------------------
+  /** Creates or removes the messenger to match the config (on only when enabled for this platform). */
+  syncMessenger() {
+    const cfg = this.config?.messenger;
+    if (cfg?.enabled) {
+      if (this.messenger) this.messenger.updateConfig(cfg);
+      else {
+        this.messenger = new Messenger(cfg, {
+          baseUrl: this.options.apiUrl,
+          publicKey: this.options.projectId,
+          store: this.store,
+          fetch: this.options.fetch ?? fetch,
+          streamPost: (this.options.fetch ? null : xhrStreamPost()) ?? fetchStreamPost(this.options.fetch ?? fetch),
+          anonymousId: () => this.anonymousId,
+          userId: () => this.user?.id || null,
+          pageUrl: () => this.collectUrls() && this.screenName ? this.currentUrl() : void 0,
+          onOpen: () => {
+            this.enqueue("messenger_opened");
+            this.emitter.emit("messenger:open");
+          },
+          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)
+        });
+        this.resourceCenterOpen = false;
+      }
+    } else if (this.messenger) {
+      this.messenger.destroy();
+      this.messenger = null;
+    }
+    this.notify();
+  }
+  /** The Scout messenger store when Scout is on for this platform (rendered by the overlay). */
+  getMessenger() {
+    return this.messenger;
+  }
+  /** Opens the Scout messenger, optionally on a tab. No-op when Scout is off for this platform. */
+  openMessenger(tab) {
+    this.whenHydrated(() => this.messenger?.open(tab));
+  }
+  closeMessenger() {
+    this.messenger?.close();
+  }
+  /** Opens a new messenger conversation, optionally pre-filling the message. */
+  showNewMessage(text) {
+    this.whenHydrated(() => this.messenger?.showNewMessage(text));
+  }
+  on(event, cb) {
+    return this.emitter.on(event, cb);
+  }
+  off(event, cb) {
+    this.emitter.off(event, cb);
+  }
+  isClientReady() {
+    return this.isReady;
+  }
+  /** Snapshot for debugging. */
+  getState() {
+    return {
+      ready: this.isReady,
+      destroyed: this.destroyed,
+      anonymousId: this.anonymousId,
+      user: this.user,
+      consent: this.consent,
+      screen: this.screenName,
+      configVersion: this.config?.configVersion ?? null,
+      guides: this.getGuides().map((g) => ({ id: g.id, key: g.key, kind: g.kind })),
+      activeGuide: this.active ? { id: this.active.guide.id, key: this.active.guide.key, ...this.active.controller.getState() } : this.activeSurvey ? { id: this.activeSurvey.guide.id, key: this.activeSurvey.guide.key } : null,
+      queued: this.queued.map((q) => q.guide.key),
+      widgets: [...this.flows.keys(), ...this.checklists.keys()],
+      guideState: this.state.guides,
+      checklists: this.state.checklists,
+      audienceIds: this.state.audienceIds,
+      session: this.session,
+      pendingEvents: this.queue?.size ?? 0,
+      targets: this.targets.ids()
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------------
+  persistState() {
+    writeJson(this.store, KEYS.state(this.options.projectId), this.state);
+  }
+  persistSession() {
+    this.session.lastActiveAt = nowIso();
+    writeJson(this.store, KEYS.session, this.session);
+  }
+  reportError(err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    this.log("error", error.message);
+    try {
+      this.options.onError?.(error);
+    } catch {
+    }
+    this.emitter.emit("error", error);
+  }
+  log(...args) {
+    if (this.options.debug && typeof console !== "undefined") console.log("[Guidely]", ...args);
+  }
+};
+function forPlatform(config, platform) {
+  return config.guides.every((g) => supportsPlatform(g.config, platform)) ? config : { ...config, guides: config.guides.filter((g) => supportsPlatform(g.config, platform)) };
+}
+
+// src/ui/Overlay.tsx
+import { useCallback as useCallback2, useEffect as useEffect5, useRef as useRef3, useState as useState5, useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { Platform as Platform5, Pressable as Pressable7, StatusBar, StyleSheet as StyleSheet9, Text as Text8, useColorScheme, useWindowDimensions, View as View9 } from "react-native";
+
+// src/ui/Checklist.tsx
+import { Pressable as Pressable2, ScrollView, StyleSheet as StyleSheet3, Text as Text3, View as View3 } from "react-native";
+
+// src/ui/primitives.tsx
+import { Pressable, StyleSheet, Text, View } from "react-native";
+import { jsx } from "react/jsx-runtime";
+function GButton({ label, variant = "primary", onPress, palette: p, style, accessibilityHint, disabled }) {
+  const filled = variant === "primary";
+  const outlined = variant === "secondary";
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      accessibilityRole: "button",
+      accessibilityLabel: label,
+      accessibilityHint,
+      accessibilityState: { disabled: !!disabled },
+      disabled,
+      onPress,
+      hitSlop: 6,
+      style: ({ pressed }) => [
+        styles.btn,
+        { borderRadius: Math.min(p.radius, 10), opacity: disabled ? 0.5 : pressed ? 0.75 : 1 },
+        filled && { backgroundColor: p.primary },
+        outlined && { borderWidth: 1, borderColor: p.border, backgroundColor: p.background },
+        variant === "link" && styles.link,
+        style
+      ],
+      children: /* @__PURE__ */ jsx(Text, { style: [styles.btnText, { color: filled ? p.onPrimary : variant === "link" ? p.primary : variant === "ghost" ? p.muted : p.text, fontFamily: p.fontFamily }, variant === "link" && styles.underline], numberOfLines: 1, children: label })
+    }
+  );
+}
+function CloseButton({ onPress, palette: p, label = "Close" }) {
+  return /* @__PURE__ */ jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: label, onPress, hitSlop: 10, style: ({ pressed }) => [styles.close, { opacity: pressed ? 0.6 : 1 }], children: /* @__PURE__ */ jsx(Text, { style: [styles.closeText, { color: p.muted }], children: "\xD7" }) });
+}
+function Surface({ palette: p, children, style }) {
+  return /* @__PURE__ */ jsx(View, { style: [styles.surface, { backgroundColor: p.background, borderRadius: p.radius, borderColor: p.border }, style], children });
+}
+var styles = StyleSheet.create({
+  btn: { minHeight: 36, paddingHorizontal: 14, paddingVertical: 8, alignItems: "center", justifyContent: "center" },
+  link: { paddingHorizontal: 4 },
+  btnText: { fontSize: 14, fontWeight: "600" },
+  underline: { textDecorationLine: "underline" },
+  close: { width: 28, height: 28, alignItems: "center", justifyContent: "center", marginTop: -4, marginRight: -6 },
+  closeText: { fontSize: 24, lineHeight: 26, fontWeight: "400" },
+  surface: {
+    borderWidth: StyleSheet.hairlineWidth,
+    shadowColor: "#000",
+    shadowOpacity: 0.18,
+    shadowRadius: 18,
+    shadowOffset: { width: 0, height: 8 },
+    elevation: 10
+  }
+});
+
+// src/ui/RichText.tsx
+import { useMemo } from "react";
+import { Platform, StyleSheet as StyleSheet2, Text as Text2, View as View2 } from "react-native";
+
+// src/core/html.ts
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0", mdash: "\u2014", ndash: "\u2013", hellip: "\u2026", rsquo: "\u2019", lsquo: "\u2018", rdquo: "\u201D", ldquo: "\u201C", copy: "\xA9", reg: "\xAE", trade: "\u2122", times: "\xD7", rarr: "\u2192", larr: "\u2190", bull: "\u2022" };
+function decodeEntities(s) {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+    if (e[0] === "#") {
+      const code = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+      return Number.isFinite(code) && code > 0 && code < 1114112 ? String.fromCodePoint(code) : m;
+    }
+    return ENTITIES[e.toLowerCase()] ?? m;
+  });
+}
+var BLOCK_TAGS = /* @__PURE__ */ new Set(["p", "div", "section", "article", "header", "footer", "h1", "h2", "h3", "h4", "h5", "h6", "li", "blockquote", "ul", "ol", "table", "tr", "pre"]);
+var SKIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "head", "title", "svg", "template"]);
+function attr(attrs, name) {
+  const m = attrs.match(new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, "i"));
+  return m ? decodeEntities(m[2] ?? m[3] ?? m[4] ?? "") : void 0;
+}
+function parseHtml(html) {
+  const blocks = [];
+  const style = { bold: 0, italic: 0, underline: 0, code: 0 };
+  const hrefs = [];
+  const lists = [];
+  let current = null;
+  let skipping = null;
+  const flush = () => {
+    if (current) {
+      const runs = current.runs;
+      while (runs.length && !runs[0].text.trim()) runs.shift();
+      while (runs.length && !runs[runs.length - 1].text.trim()) runs.pop();
+      if (runs.length) {
+        runs[0].text = runs[0].text.replace(/^[ \t\n]+/, "");
+        runs[runs.length - 1].text = runs[runs.length - 1].text.replace(/[ \t\n]+$/, "");
+        blocks.push(current);
+      }
+    }
+    current = null;
+  };
+  const open = (kind, level = 1, marker) => {
+    flush();
+    current = { kind, level, marker, runs: [] };
+  };
+  const push = (text) => {
+    if (!text) return;
+    if (!current) current = { kind: "paragraph", level: 1, runs: [] };
+    const run = { text };
+    if (style.bold) run.bold = true;
+    if (style.italic) run.italic = true;
+    if (style.underline) run.underline = true;
+    if (style.code) run.code = true;
+    if (hrefs.length) run.href = hrefs[hrefs.length - 1];
+    const last = current.runs[current.runs.length - 1];
+    if (last && last.bold === run.bold && last.italic === run.italic && last.underline === run.underline && last.code === run.code && last.href === run.href) last.text += text;
+    else current.runs.push(run);
+  };
+  const re = /<!--[\s\S]*?-->|<\/?([a-zA-Z][a-zA-Z0-9]*)\b([^>]*)>|([^<]+|<)/g;
+  let m;
+  while (m = re.exec(html || "")) {
+    const [token, rawTag, attrs = "", text] = m;
+    if (text !== void 0) {
+      if (skipping) continue;
+      push(decodeEntities(text.replace(/\s+/g, " ")));
+      continue;
+    }
+    if (!rawTag) continue;
+    const tag = rawTag.toLowerCase();
+    const closing = token.startsWith("</");
+    if (skipping) {
+      if (closing && tag === skipping) skipping = null;
+      continue;
+    }
+    if (SKIP_TAGS.has(tag)) {
+      if (!closing && !token.endsWith("/>")) skipping = tag;
+      continue;
+    }
+    if (closing) {
+      if (tag === "b" || tag === "strong") style.bold = Math.max(0, style.bold - 1);
+      else if (tag === "i" || tag === "em") style.italic = Math.max(0, style.italic - 1);
+      else if (tag === "u") style.underline = Math.max(0, style.underline - 1);
+      else if (tag === "code") style.code = Math.max(0, style.code - 1);
+      else if (tag === "a") hrefs.pop();
+      else if (tag === "ul" || tag === "ol") {
+        lists.pop();
+        flush();
+      } else if (BLOCK_TAGS.has(tag)) flush();
+      continue;
+    }
+    switch (tag) {
+      case "br":
+        push("\n");
+        break;
+      case "b":
+      case "strong":
+        style.bold += 1;
+        break;
+      case "i":
+      case "em":
+        style.italic += 1;
+        break;
+      case "u":
+        style.underline += 1;
+        break;
+      case "code":
+        style.code += 1;
+        break;
+      case "a":
+        hrefs.push(attr(attrs, "href") ?? "");
+        break;
+      case "ul":
+      case "ol":
+        flush();
+        lists.push({ ordered: tag === "ol", n: 0 });
+        break;
+      case "li": {
+        const list = lists[lists.length - 1];
+        if (list) list.n += 1;
+        open("list-item", Math.max(1, lists.length), list?.ordered ? `${list.n}.` : "\u2022");
+        break;
+      }
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6":
+        open("heading", Math.min(3, Number(tag[1])));
+        break;
+      case "blockquote":
+        open("quote");
+        break;
+      default:
+        if (BLOCK_TAGS.has(tag)) open("paragraph");
+        else if (tag === "img") {
+          const alt = attr(attrs, "alt");
+          if (alt) push(alt);
+        }
+    }
+  }
+  flush();
+  return blocks;
+}
+function htmlToText(html) {
+  return parseHtml(html).map((b) => (b.marker ? `${b.marker} ` : "") + b.runs.map((r) => r.text).join("")).join("\n");
+}
+
+// src/ui/RichText.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var MONO = Platform.select({ ios: "Menlo", android: "monospace", default: "monospace" });
+var HEADING_SIZE = [0, 20, 17, 15];
+function runStyle(run, p) {
+  return {
+    fontWeight: run.bold ? "700" : void 0,
+    fontStyle: run.italic ? "italic" : void 0,
+    textDecorationLine: run.underline || run.href ? "underline" : void 0,
+    fontFamily: run.code ? MONO : void 0,
+    backgroundColor: run.code ? p.surface : void 0,
+    color: run.href ? p.primary : void 0
+  };
+}
+function RichText({ html, palette: p, onLink, size = 15 }) {
+  const blocks = useMemo(() => parseHtml(html), [html]);
+  if (!blocks.length) return null;
+  const base = { color: p.text, fontSize: size, lineHeight: Math.round(size * 1.42), fontFamily: p.fontFamily };
+  return /* @__PURE__ */ jsx2(View2, { style: styles2.wrap, children: blocks.map((b, i) => {
+    const runs = b.runs.map((r, j) => /* @__PURE__ */ jsx2(Text2, { style: runStyle(r, p), onPress: r.href ? () => onLink(r.href) : void 0, accessibilityRole: r.href ? "link" : void 0, children: r.text }, j));
+    if (b.kind === "list-item") {
+      return /* @__PURE__ */ jsxs(View2, { style: [styles2.li, { paddingLeft: (b.level - 1) * 14 }], children: [
+        /* @__PURE__ */ jsx2(Text2, { style: [base, styles2.marker], children: b.marker }),
+        /* @__PURE__ */ jsx2(Text2, { style: [base, styles2.flex], children: runs })
+      ] }, i);
+    }
+    if (b.kind === "heading") {
+      const fs = HEADING_SIZE[b.level] ?? 15;
+      return /* @__PURE__ */ jsx2(Text2, { accessibilityRole: "header", style: [base, { fontSize: fs, lineHeight: Math.round(fs * 1.3), fontWeight: "700" }], children: runs }, i);
+    }
+    return /* @__PURE__ */ jsx2(Text2, { style: [base, b.kind === "quote" && { borderLeftWidth: 3, borderLeftColor: p.border, paddingLeft: 8, color: p.muted }], children: runs }, i);
+  }) });
+}
+var styles2 = StyleSheet2.create({
+  wrap: { gap: 6 },
+  li: { flexDirection: "row", gap: 6 },
+  marker: { minWidth: 14 },
+  flex: { flex: 1 }
+});
+
+// src/ui/Checklist.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function Checklist({ view, client, palette: p, geometry, showLauncher, launcherBottom }) {
+  const config = view.guide.config.checklist;
+  if (!config) return null;
+  const done = new Set(view.progress.completedTaskIds);
+  const total = config.tasks.length;
+  const completed = config.tasks.filter((t) => done.has(t.id)).length;
+  const finished = !!view.progress.completedAt;
+  const left = config.position === "bottom-left";
+  const { insets, viewport } = geometry;
+  const side = left ? { left: insets.left + 16 } : { right: insets.right + 16 };
+  const width = Math.min(viewport.width - insets.left - insets.right - 32, 360);
+  const nextOpen = config.ordered ? config.tasks.find((t) => !done.has(t.id))?.id : void 0;
+  const bottom = insets.bottom + launcherBottom;
+  return /* @__PURE__ */ jsxs2(View3, { pointerEvents: "box-none", style: StyleSheet3.absoluteFill, children: [
+    view.open ? /* @__PURE__ */ jsx3(Surface, { palette: p, style: [styles3.panel, side, { width, bottom: bottom + (showLauncher ? 56 : 0), maxHeight: viewport.height - insets.top - bottom - 80 }], children: /* @__PURE__ */ jsxs2(View3, { accessibilityViewIsModal: true, style: styles3.panelInner, children: [
+      /* @__PURE__ */ jsxs2(View3, { style: styles3.head, children: [
+        /* @__PURE__ */ jsxs2(View3, { style: styles3.flex, children: [
+          /* @__PURE__ */ jsx3(Text3, { accessibilityRole: "header", style: [styles3.title, { color: p.text, fontFamily: p.fontFamily }], children: finished ? config.completionTitle : config.launcherLabel }),
+          /* @__PURE__ */ jsxs2(Text3, { style: [styles3.sub, { color: p.muted }], children: [
+            completed,
+            " of ",
+            total,
+            " complete"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx3(CloseButton, { palette: p, onPress: () => client.setChecklistOpen(view.guide.id, false), label: "Close checklist" })
+      ] }),
+      /* @__PURE__ */ jsx3(View3, { style: [styles3.bar, { backgroundColor: p.surface }], accessibilityRole: "progressbar", accessibilityValue: { min: 0, max: total, now: completed }, children: /* @__PURE__ */ jsx3(View3, { style: [styles3.fill, { backgroundColor: p.primary, width: `${total ? completed / total * 100 : 0}%` }] }) }),
+      finished && config.completionBody ? /* @__PURE__ */ jsx3(RichText, { html: config.completionBody, palette: p, onLink: (u) => client.navigate(u), size: 14 }) : null,
+      /* @__PURE__ */ jsx3(ScrollView, { style: styles3.tasks, contentContainerStyle: styles3.tasksContent, children: config.tasks.map((task) => {
+        const isDone = done.has(task.id);
+        const locked = !!nextOpen && !isDone && task.id !== nextOpen;
+        return /* @__PURE__ */ jsxs2(
+          Pressable2,
+          {
+            disabled: locked,
+            accessibilityRole: "button",
+            accessibilityState: { checked: isDone, disabled: locked },
+            accessibilityLabel: `${task.title}${isDone ? ", done" : ""}`,
+            onPress: () => client.checklistTaskPressed(view.guide.id, task.id),
+            style: ({ pressed }) => [styles3.task, { borderColor: p.border, opacity: locked ? 0.5 : pressed ? 0.7 : 1 }],
+            children: [
+              /* @__PURE__ */ jsx3(View3, { style: [styles3.check, isDone ? { backgroundColor: p.primary, borderColor: p.primary } : { borderColor: p.border }], children: isDone ? /* @__PURE__ */ jsx3(Text3, { style: [styles3.tick, { color: p.onPrimary }], children: "\u2713" }) : null }),
+              /* @__PURE__ */ jsxs2(View3, { style: styles3.flex, children: [
+                /* @__PURE__ */ jsxs2(Text3, { style: [styles3.taskTitle, { color: p.text, fontFamily: p.fontFamily }, isDone && { textDecorationLine: "line-through", color: p.muted }], children: [
+                  task.title,
+                  !task.required ? /* @__PURE__ */ jsx3(Text3, { style: { color: p.muted, fontWeight: "400" }, children: " (optional)" }) : null
+                ] }),
+                task.description ? /* @__PURE__ */ jsx3(Text3, { style: [styles3.taskDesc, { color: p.muted }], children: task.description }) : null
+              ] })
+            ]
+          },
+          task.id
+        );
+      }) }),
+      config.dismissible ? /* @__PURE__ */ jsx3(GButton, { label: finished ? "Close for good" : "Dismiss checklist", variant: "ghost", palette: p, onPress: () => client.dismissChecklist(view.guide.id), style: styles3.dismiss }) : null
+    ] }) }) : null,
+    showLauncher ? /* @__PURE__ */ jsxs2(
+      Pressable2,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: `${config.launcherLabel}, ${completed} of ${total} complete`,
+        accessibilityState: { expanded: view.open },
+        onPress: () => client.setChecklistOpen(view.guide.id, !view.open),
+        style: ({ pressed }) => [styles3.launcher, side, { bottom, backgroundColor: p.primary, opacity: pressed ? 0.85 : 1 }],
+        children: [
+          /* @__PURE__ */ jsx3(View3, { style: [styles3.count, { borderColor: p.onPrimary }], children: /* @__PURE__ */ jsx3(Text3, { style: [styles3.countText, { color: p.onPrimary }], children: finished ? "\u2713" : `${completed}/${total}` }) }),
+          /* @__PURE__ */ jsx3(Text3, { style: [styles3.launcherText, { color: p.onPrimary, fontFamily: p.fontFamily }], numberOfLines: 1, children: config.launcherLabel })
+        ]
+      }
+    ) : null
+  ] });
+}
+var styles3 = StyleSheet3.create({
+  flex: { flex: 1 },
+  panel: { position: "absolute" },
+  panelInner: { padding: 16, gap: 10, flexShrink: 1 },
+  head: { flexDirection: "row", alignItems: "flex-start", gap: 8 },
+  title: { fontSize: 17, fontWeight: "700" },
+  sub: { fontSize: 13, marginTop: 2 },
+  bar: { height: 6, borderRadius: 3, overflow: "hidden" },
+  fill: { height: 6, borderRadius: 3 },
+  tasks: { flexGrow: 0 },
+  tasksContent: { gap: 8 },
+  task: { flexDirection: "row", gap: 10, alignItems: "flex-start", borderWidth: StyleSheet3.hairlineWidth, borderRadius: 10, padding: 10 },
+  check: { width: 22, height: 22, borderRadius: 11, borderWidth: 2, alignItems: "center", justifyContent: "center", marginTop: 1 },
+  tick: { fontSize: 13, fontWeight: "800" },
+  taskTitle: { fontSize: 15, fontWeight: "600" },
+  taskDesc: { fontSize: 13, marginTop: 2 },
+  dismiss: { alignSelf: "center" },
+  launcher: {
+    position: "absolute",
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8,
+    paddingVertical: 10,
+    paddingHorizontal: 14,
+    borderRadius: 24,
+    shadowColor: "#000",
+    shadowOpacity: 0.22,
+    shadowRadius: 12,
+    shadowOffset: { width: 0, height: 4 },
+    elevation: 8,
+    maxWidth: 240
+  },
+  count: { minWidth: 30, height: 22, borderRadius: 11, borderWidth: 1.5, alignItems: "center", justifyContent: "center", paddingHorizontal: 4 },
+  countText: { fontSize: 11, fontWeight: "700" },
+  launcherText: { fontSize: 14, fontWeight: "700", flexShrink: 1 }
+});
+
+// src/ui/Messenger.tsx
+import { useCallback, useEffect, useMemo as useMemo2, useRef, useState, useSyncExternalStore } from "react";
+import { ActivityIndicator, Keyboard, Modal, Platform as Platform2, Pressable as Pressable3, ScrollView as ScrollView2, StyleSheet as StyleSheet4, Text as Text4, TextInput, View as View4 } from "react-native";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function useMessenger(store) {
+  return useSyncExternalStore(
+    useCallback((cb) => store.subscribe(cb), [store]),
+    () => store.getSnapshot(),
+    () => store.getSnapshot()
+  );
+}
+function useKeyboardHeight() {
+  const [h, setH] = useState(0);
+  useEffect(() => {
+    if (Platform2.OS !== "ios") return;
+    const show = Keyboard.addListener("keyboardWillShow", (e) => setH(e.endCoordinates.height));
+    const hide = Keyboard.addListener("keyboardWillHide", () => setH(0));
+    return () => {
+      show.remove();
+      hide.remove();
+    };
+  }, []);
+  return h;
+}
+function ago(iso) {
+  const s = Math.max(0, (Date.now() - Date.parse(iso)) / 1e3);
+  if (s < 60) return "now";
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`;
+  return `${Math.floor(s / 86400)}d`;
+}
+function MessengerLauncher({ store, palette: p, style }) {
+  const snap = useMessenger(store);
+  if (snap.open) return null;
+  const label = snap.unread ? `Open ${snap.config.name}, ${snap.unread} unread` : `Open ${snap.config.name}`;
+  return /* @__PURE__ */ jsxs3(Pressable3, { accessibilityRole: "button", accessibilityLabel: label, onPress: () => store.open(), style: ({ pressed }) => [styles4.launcher, style, { backgroundColor: p.primary, opacity: pressed ? 0.85 : 1 }], children: [
+    /* @__PURE__ */ jsx4(Text4, { style: [styles4.launcherIcon, { color: p.onPrimary }], children: "\u{1F4AC}" }),
+    snap.unread ? /* @__PURE__ */ jsx4(View4, { style: styles4.badge, children: /* @__PURE__ */ jsx4(Text4, { style: styles4.badgeText, children: snap.unread }) }) : null
+  ] });
+}
+function MessengerSheet({ store, client, palette: p, topInset, bottomInset }) {
+  const snap = useMessenger(store);
+  const keyboard = useKeyboardHeight();
+  const v = snap.view;
+  const title = v.kind === "thread" ? snap.thread?.conversation?.subject || "New conversation" : v.kind === "article" ? "" : v.tab === "home" ? snap.config.name : v.tab === "messages" ? "Messages" : "Help";
+  return /* @__PURE__ */ jsx4(Modal, { visible: snap.open, animationType: "slide", presentationStyle: Platform2.OS === "ios" ? "pageSheet" : "fullScreen", onRequestClose: () => v.kind === "tab" ? store.close() : store.back(), children: /* @__PURE__ */ jsxs3(View4, { style: [styles4.sheet, { backgroundColor: p.background, paddingTop: Platform2.OS === "ios" ? 8 : topInset, paddingBottom: keyboard }], children: [
+    /* @__PURE__ */ jsxs3(View4, { style: [styles4.header, { borderColor: p.border }], children: [
+      v.kind !== "tab" ? /* @__PURE__ */ jsx4(Pressable3, { accessibilityRole: "button", accessibilityLabel: "Back", onPress: () => store.back(), hitSlop: 10, children: /* @__PURE__ */ jsx4(Text4, { style: [styles4.back, { color: p.primary }], children: "\u2039 Back" }) }) : null,
+      /* @__PURE__ */ jsx4(Text4, { accessibilityRole: "header", numberOfLines: 1, style: [styles4.title, { color: p.text, fontFamily: p.fontFamily }], children: title }),
+      /* @__PURE__ */ jsx4(CloseButton, { palette: p, onPress: () => store.close(), label: `Close ${snap.config.name}` })
+    ] }),
+    /* @__PURE__ */ jsx4(View4, { style: styles4.flex, children: v.kind === "thread" ? /* @__PURE__ */ jsx4(Thread, { store, palette: p, bottomInset: keyboard ? 0 : bottomInset }) : v.kind === "article" ? /* @__PURE__ */ jsx4(Article, { article: snap.article, palette: p, client }) : v.tab === "home" ? /* @__PURE__ */ jsx4(Home, { store, palette: p }) : v.tab === "messages" ? /* @__PURE__ */ jsx4(Conversations, { store, palette: p }) : /* @__PURE__ */ jsx4(Help, { store, client, palette: p }) }),
+    v.kind === "tab" && !keyboard ? /* @__PURE__ */ jsx4(Tabs, { store, active: v.tab, palette: p, bottomInset }) : null
+  ] }) });
+}
+function Tabs({ store, active, palette: p, bottomInset }) {
+  const unread = useMessenger(store).unread;
+  const tabs = [
+    ["home", "\u2302", "Home"],
+    ["messages", "\u2709\uFE0E", "Messages"],
+    ["help", "?", "Help"]
+  ];
+  return /* @__PURE__ */ jsx4(View4, { accessibilityRole: "tablist", style: [styles4.tabs, { borderColor: p.border, paddingBottom: Math.max(8, bottomInset) }], children: tabs.map(([tab, icon, label]) => {
+    const on = tab === active;
+    return /* @__PURE__ */ jsxs3(Pressable3, { accessibilityRole: "tab", accessibilityState: { selected: on }, accessibilityLabel: tab === "messages" && unread ? `${label}, ${unread} unread` : label, onPress: () => store.setTab(tab), style: styles4.tab, children: [
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.tabIcon, { color: on ? p.primary : p.muted }], children: icon }),
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.tabLabel, { color: on ? p.primary : p.muted }], children: label }),
+      tab === "messages" && unread ? /* @__PURE__ */ jsx4(View4, { style: [styles4.dot, styles4.tabDot] }) : null
+    ] }, tab);
+  }) });
+}
+function Home({ store, palette: p }) {
+  const snap = useMessenger(store);
+  const recent = snap.conversations[0];
+  const [q, setQ] = useState("");
+  return /* @__PURE__ */ jsxs3(ScrollView2, { contentContainerStyle: styles4.content, keyboardShouldPersistTaps: "handled", children: [
+    /* @__PURE__ */ jsxs3(View4, { style: [styles4.hero, { backgroundColor: p.primary, borderRadius: p.radius }], children: [
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.heroTitle, { color: p.onPrimary }], children: snap.config.greeting || `Hi! I'm ${snap.config.name}.` }),
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.heroSub, { color: p.onPrimary }], children: snap.config.aiAvailable ? `${snap.config.name} answers right away${snap.config.handoffEnabled ? ", and the team is here when you need a person" : ""}.` : "The team usually replies within a few hours." })
+    ] }),
+    /* @__PURE__ */ jsx4(GButton, { label: "Send us a message", palette: p, onPress: () => store.showNewMessage(), style: styles4.fullWidth }),
+    recent ? /* @__PURE__ */ jsxs3(View4, { style: styles4.section, children: [
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.sectionTitle, { color: p.muted }], children: "RECENT" }),
+      /* @__PURE__ */ jsx4(ConversationRow, { c: recent, palette: p, onPress: () => void store.openConversation(recent.id) })
+    ] }) : null,
+    /* @__PURE__ */ jsxs3(View4, { style: styles4.section, children: [
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.sectionTitle, { color: p.muted }], children: "SEARCH FOR HELP" }),
+      /* @__PURE__ */ jsx4(
+        TextInput,
+        {
+          value: q,
+          onChangeText: setQ,
+          onSubmitEditing: () => {
+            pendingSearch.current = q;
+            store.setTab("help");
+          },
+          returnKeyType: "search",
+          placeholder: "Search articles",
+          placeholderTextColor: p.muted,
+          accessibilityLabel: "Search help articles",
+          style: [styles4.search, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(10, p.radius) }]
+        }
+      )
+    ] })
+  ] });
+}
+var pendingSearch = { current: "" };
+function ConversationRow({ c, palette: p, onPress }) {
+  return /* @__PURE__ */ jsxs3(Pressable3, { accessibilityRole: "button", accessibilityLabel: `${c.subject || "Conversation"}${c.unread ? ", unread" : ""}`, onPress, style: ({ pressed }) => [styles4.row, { borderColor: p.border, opacity: pressed ? 0.7 : 1 }], children: [
+    /* @__PURE__ */ jsxs3(View4, { style: styles4.flex, children: [
+      /* @__PURE__ */ jsx4(Text4, { numberOfLines: 1, style: [styles4.rowTitle, { color: p.text }], children: c.subject || "Conversation" }),
+      /* @__PURE__ */ jsx4(Text4, { numberOfLines: 1, style: [styles4.rowSub, { color: p.muted }], children: c.lastMessagePreview || (c.status === "closed" ? "Closed" : " ") })
+    ] }),
+    /* @__PURE__ */ jsxs3(View4, { style: styles4.rowEnd, children: [
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.time, { color: p.muted }], children: ago(c.lastMessageAt) }),
+      c.unread ? /* @__PURE__ */ jsx4(View4, { style: [styles4.dot, { backgroundColor: p.primary }] }) : null
+    ] })
+  ] });
+}
+function Conversations({ store, palette: p }) {
+  const snap = useMessenger(store);
+  return /* @__PURE__ */ jsxs3(ScrollView2, { contentContainerStyle: styles4.content, children: [
+    snap.conversations.length ? snap.conversations.map((c) => /* @__PURE__ */ jsx4(ConversationRow, { c, palette: p, onPress: () => void store.openConversation(c.id) }, c.id)) : /* @__PURE__ */ jsx4(Text4, { style: [styles4.empty, { color: p.muted }], children: "No conversations yet." }),
+    /* @__PURE__ */ jsx4(GButton, { label: "New conversation", palette: p, onPress: () => store.showNewMessage(), style: styles4.fullWidth })
+  ] });
+}
+function Bubble({ m, text, name, palette: p, onArticle, onGuide }) {
+  if (m.author === "system")
+    return /* @__PURE__ */ jsx4(Text4, { accessibilityRole: "text", style: [styles4.system, { color: p.muted }], children: text });
+  const mine = m.author === "user";
+  return /* @__PURE__ */ jsxs3(View4, { style: [styles4.bubbleWrap, mine ? styles4.mine : styles4.theirs], children: [
+    !mine ? /* @__PURE__ */ jsx4(Text4, { style: [styles4.author, { color: p.muted }], children: m.author === "agent" ? m.authorName || "Team" : name }) : null,
+    /* @__PURE__ */ jsx4(View4, { style: [styles4.bubble, { borderRadius: Math.max(12, p.radius) }, mine ? { backgroundColor: p.primary } : { backgroundColor: p.surface }], children: m.status === "pending" && !text ? /* @__PURE__ */ jsx4(TypingDots, { color: p.muted }) : /* @__PURE__ */ jsx4(Text4, { style: [styles4.bubbleText, { color: mine ? p.onPrimary : p.text }], children: text }) }),
+    m.citations.length || m.suggestedGuides.length ? /* @__PURE__ */ jsxs3(View4, { style: styles4.chips, children: [
+      m.citations.map((c) => /* @__PURE__ */ jsx4(Pressable3, { accessibilityRole: "link", accessibilityLabel: `Article: ${c.title}`, onPress: () => onArticle(c.articleId), style: [styles4.chip, { borderColor: p.border }], children: /* @__PURE__ */ jsxs3(Text4, { style: [styles4.chipText, { color: p.text }], children: [
+        "\u{1F4C4} ",
+        c.title
+      ] }) }, c.articleId)),
+      m.suggestedGuides.map((g) => /* @__PURE__ */ jsx4(Pressable3, { accessibilityRole: "button", accessibilityLabel: `Show me: ${g.name}`, onPress: () => onGuide(g.key), style: [styles4.chip, { borderColor: p.primary }], children: /* @__PURE__ */ jsxs3(Text4, { style: [styles4.chipText, { color: p.primary }], children: [
+        "\u25B6 Show me: ",
+        g.name
+      ] }) }, g.key))
+    ] }) : null
+  ] });
+}
+function TypingDots({ color }) {
+  return /* @__PURE__ */ jsx4(ActivityIndicator, { size: "small", color, accessibilityLabel: "Typing" });
+}
+function Thread({ store, palette: p, bottomInset }) {
+  const snap = useMessenger(store);
+  const t = snap.thread;
+  const [text, setText] = useState(t?.draft ?? "");
+  const scroll = useRef(null);
+  const convo = t?.conversation ?? null;
+  useEffect(() => {
+    if (t?.draft) setText(t.draft);
+  }, [t?.draft]);
+  const streamingIds = useMemo2(() => Object.keys(t?.streaming ?? {}).filter((id) => !t?.messages.some((m) => m.id === id)), [t]);
+  if (!t) return null;
+  const send = () => {
+    const value = text;
+    setText("");
+    void store.send(value);
+  };
+  const canHandoff = snap.config.handoffEnabled && snap.config.aiAvailable && convo?.status === "bot" && !t.sending;
+  return /* @__PURE__ */ jsxs3(View4, { style: styles4.flex, children: [
+    /* @__PURE__ */ jsxs3(ScrollView2, { ref: scroll, contentContainerStyle: styles4.thread, onContentSizeChange: () => scroll.current?.scrollToEnd({ animated: true }), keyboardShouldPersistTaps: "handled", children: [
+      !t.messages.length && !t.sending ? /* @__PURE__ */ jsx4(Text4, { style: [styles4.empty, { color: p.muted }], children: snap.config.greeting || "Ask us anything." }) : null,
+      t.messages.map((m) => /* @__PURE__ */ jsx4(Bubble, { m, text: t.streaming[m.id] ?? m.body, name: snap.config.name, palette: p, onArticle: (id) => void store.openArticle(id), onGuide: (k) => store.startGuide(k) }, m.id)),
+      streamingIds.map((id) => /* @__PURE__ */ jsx4(Bubble, { m: { id, author: "scout", body: "", citations: [], suggestedGuides: [], status: "pending", createdAt: (/* @__PURE__ */ new Date()).toISOString() }, text: t.streaming[id] ?? "", name: snap.config.name, palette: p, onArticle: () => {
+      }, onGuide: () => {
+      } }, id)),
+      t.sending && !streamingIds.length && snap.config.aiAvailable && t.messages.length ? /* @__PURE__ */ jsx4(TypingDots, { color: p.muted }) : null,
+      t.error ? /* @__PURE__ */ jsx4(Text4, { accessibilityLiveRegion: "polite", style: styles4.error, children: t.error }) : null,
+      convo?.status === "closed" && convo.rating == null ? /* @__PURE__ */ jsx4(Rating, { palette: p, onRate: (n) => void store.rate(n) }) : null,
+      convo?.status === "closed" && convo.rating != null ? /* @__PURE__ */ jsx4(Text4, { style: [styles4.system, { color: p.muted }], children: "Thanks for rating this conversation." }) : null
+    ] }),
+    canHandoff ? /* @__PURE__ */ jsx4(GButton, { label: "Talk to a person", variant: "secondary", palette: p, onPress: () => void store.handoff(), style: styles4.handoff }) : null,
+    /* @__PURE__ */ jsxs3(View4, { style: [styles4.composer, { borderColor: p.border, paddingBottom: Math.max(10, bottomInset) }], children: [
+      /* @__PURE__ */ jsx4(
+        TextInput,
+        {
+          value: text,
+          onChangeText: (v) => setText(v.slice(0, 4e3)),
+          placeholder: convo ? "Reply\u2026" : "Write a message\u2026",
+          placeholderTextColor: p.muted,
+          multiline: true,
+          accessibilityLabel: "Message",
+          style: [styles4.input, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(18, p.radius + 6) }]
+        }
+      ),
+      /* @__PURE__ */ jsx4(GButton, { label: "Send", palette: p, onPress: send, disabled: !text.trim() || t.sending })
+    ] })
+  ] });
+}
+function Rating({ palette: p, onRate }) {
+  return /* @__PURE__ */ jsxs3(View4, { style: styles4.rating, children: [
+    /* @__PURE__ */ jsx4(Text4, { style: [styles4.ratingTitle, { color: p.text }], children: "How did we do?" }),
+    /* @__PURE__ */ jsx4(View4, { accessibilityRole: "radiogroup", style: styles4.stars, children: [1, 2, 3, 4, 5].map((n) => /* @__PURE__ */ jsx4(Pressable3, { accessibilityRole: "radio", accessibilityLabel: `${n} of 5`, onPress: () => onRate(n), hitSlop: 6, children: /* @__PURE__ */ jsx4(Text4, { style: [styles4.star, { color: p.primary }], children: "\u2605" }) }, n)) })
+  ] });
+}
+function Help({ store, client, palette: p }) {
+  const snap = useMessenger(store);
+  const rc = client.getResourceCenter();
+  const [q, setQ] = useState(pendingSearch.current);
+  const [results, setResults] = useState(null);
+  const [faq, setFaq] = useState(null);
+  useEffect(() => {
+    pendingSearch.current = "";
+  }, []);
+  useEffect(() => {
+    const query = q.trim();
+    if (query.length < 2) return setResults(null);
+    let alive = true;
+    const t = setTimeout(() => void store.search(query).then((r) => alive && setResults(r)), 250);
+    return () => {
+      alive = false;
+      clearTimeout(t);
+    };
+  }, [q, store]);
+  const guides = client.getGuides();
+  const recommended = (rc?.recommendedGuideIds ?? []).map((id) => guides.find((g) => g.id === id || g.key === id)).filter((g) => !!g);
+  const articles = snap.articles;
+  const row = (key, title, sub, onPress, icon = "\u203A") => /* @__PURE__ */ jsxs3(Pressable3, { accessibilityRole: "button", accessibilityLabel: title, onPress, style: ({ pressed }) => [styles4.row, { borderColor: p.border, opacity: pressed ? 0.7 : 1 }], children: [
+    /* @__PURE__ */ jsxs3(View4, { style: styles4.flex, children: [
+      /* @__PURE__ */ jsx4(Text4, { style: [styles4.rowTitle, { color: p.text }], children: title }),
+      sub ? /* @__PURE__ */ jsx4(Text4, { numberOfLines: 2, style: [styles4.rowSub, { color: p.muted }], children: sub }) : null
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { style: [styles4.chev, { color: p.muted }], children: icon })
+  ] }, key);
+  const open = (a) => a.externalUrl ? client.navigate(a.externalUrl) : void store.openArticle(a.id);
+  const section = (title, children) => /* @__PURE__ */ jsxs3(View4, { style: styles4.section, children: [
+    /* @__PURE__ */ jsx4(Text4, { accessibilityRole: "header", style: [styles4.sectionTitle, { color: p.muted }], children: title.toUpperCase() }),
+    children
+  ] }, title);
+  const collections = [...articles?.collections ?? []].sort((a, b) => a.order - b.order);
+  const loose = (articles?.articles ?? []).filter((a) => !a.collectionId || !collections.some((c) => c.id === a.collectionId));
+  return /* @__PURE__ */ jsxs3(ScrollView2, { contentContainerStyle: styles4.content, keyboardShouldPersistTaps: "handled", children: [
+    /* @__PURE__ */ jsx4(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) }] }),
+    results ? section(`Results for \u201C${q.trim()}\u201D`, results.length ? results.map((a) => row(a.id, a.title, a.summary, () => open(a))) : /* @__PURE__ */ jsx4(Text4, { style: [styles4.rowSub, { color: p.muted }], children: "No articles found." })) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+      recommended.length ? section("Recommended", recommended.map((g) => row(g.id, g.name, void 0, () => store.startGuide(g.key), "\u25B6"))) : null,
+      !articles ? /* @__PURE__ */ jsx4(ActivityIndicator, { color: p.muted }) : null,
+      collections.map((c) => {
+        const items = (articles?.articles ?? []).filter((a) => a.collectionId === c.id);
+        return items.length ? section(c.name, items.map((a) => row(a.id, a.title, a.summary, () => open(a)))) : null;
+      }),
+      loose.length ? section("Articles", loose.map((a) => row(a.id, a.title, a.summary, () => open(a)))) : null,
+      rc?.faqs.length ? section(
+        "FAQ",
+        rc.faqs.map((f) => /* @__PURE__ */ jsxs3(View4, { style: [styles4.row, styles4.faq, { borderColor: p.border }], children: [
+          /* @__PURE__ */ jsxs3(Pressable3, { accessibilityRole: "button", accessibilityState: { expanded: faq === f.id }, onPress: () => setFaq(faq === f.id ? null : f.id), style: styles4.faqHead, children: [
+            /* @__PURE__ */ jsx4(Text4, { style: [styles4.rowTitle, styles4.flex, { color: p.text }], children: f.question }),
+            /* @__PURE__ */ jsx4(Text4, { style: [styles4.chev, { color: p.muted }], children: faq === f.id ? "\u2212" : "+" })
+          ] }),
+          faq === f.id ? /* @__PURE__ */ jsx4(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
+    ] })
+  ] });
+}
+function Article({ article, palette: p, client }) {
+  if (!article) return /* @__PURE__ */ jsx4(ActivityIndicator, { style: styles4.loading, color: p.muted });
+  return /* @__PURE__ */ jsxs3(ScrollView2, { contentContainerStyle: styles4.content, children: [
+    /* @__PURE__ */ jsx4(Text4, { accessibilityRole: "header", style: [styles4.articleTitle, { color: p.text, fontFamily: p.fontFamily }], children: article.title }),
+    /* @__PURE__ */ jsx4(RichText, { html: article.body, palette: p, onLink: (u) => client.navigate(u) })
+  ] });
+}
+var styles4 = StyleSheet4.create({
+  flex: { flex: 1 },
+  launcher: { position: "absolute", width: 54, height: 54, borderRadius: 27, alignItems: "center", justifyContent: "center", elevation: 8, shadowColor: "#000", shadowOpacity: 0.22, shadowRadius: 12, shadowOffset: { width: 0, height: 4 } },
+  launcherIcon: { fontSize: 24 },
+  badge: { position: "absolute", top: -2, right: -2, minWidth: 20, height: 20, borderRadius: 10, backgroundColor: "#dc2626", alignItems: "center", justifyContent: "center", paddingHorizontal: 5, borderWidth: 2, borderColor: "#ffffff" },
+  badgeText: { color: "#ffffff", fontSize: 11, fontWeight: "800" },
+  sheet: { flex: 1 },
+  header: { flexDirection: "row", alignItems: "center", gap: 12, paddingHorizontal: 16, paddingVertical: 12, borderBottomWidth: StyleSheet4.hairlineWidth },
+  back: { fontSize: 16, fontWeight: "600" },
+  title: { flex: 1, fontSize: 18, fontWeight: "700" },
+  tabs: { flexDirection: "row", borderTopWidth: StyleSheet4.hairlineWidth, paddingTop: 8 },
+  tab: { flex: 1, alignItems: "center", gap: 2 },
+  tabIcon: { fontSize: 18 },
+  tabLabel: { fontSize: 11, fontWeight: "600" },
+  tabDot: { position: "absolute", top: 0, right: "34%", backgroundColor: "#dc2626" },
+  dot: { width: 8, height: 8, borderRadius: 4 },
+  content: { padding: 16, gap: 16 },
+  hero: { padding: 18, gap: 6 },
+  heroTitle: { fontSize: 20, fontWeight: "800" },
+  heroSub: { fontSize: 14, opacity: 0.9 },
+  fullWidth: { alignSelf: "stretch" },
+  section: { gap: 8 },
+  sectionTitle: { fontSize: 12, fontWeight: "700", letterSpacing: 0.6 },
+  search: { height: 42, paddingHorizontal: 12, fontSize: 15 },
+  row: { flexDirection: "row", alignItems: "center", gap: 10, borderWidth: StyleSheet4.hairlineWidth, borderRadius: 10, paddingVertical: 12, paddingHorizontal: 12 },
+  rowTitle: { fontSize: 15, fontWeight: "600" },
+  rowSub: { fontSize: 13, marginTop: 2 },
+  rowEnd: { alignItems: "flex-end", gap: 6 },
+  time: { fontSize: 12 },
+  chev: { fontSize: 18 },
+  empty: { textAlign: "center", paddingVertical: 24, fontSize: 14 },
+  faq: { flexDirection: "column", alignItems: "stretch" },
+  faqHead: { flexDirection: "row", alignItems: "center", gap: 10 },
+  thread: { padding: 16, gap: 12 },
+  system: { textAlign: "center", fontSize: 12, paddingHorizontal: 24 },
+  bubbleWrap: { maxWidth: "86%", gap: 4 },
+  mine: { alignSelf: "flex-end", alignItems: "flex-end" },
+  theirs: { alignSelf: "flex-start", alignItems: "flex-start" },
+  author: { fontSize: 12, fontWeight: "600", marginLeft: 4 },
+  bubble: { paddingHorizontal: 14, paddingVertical: 10 },
+  bubbleText: { fontSize: 15, lineHeight: 21 },
+  chips: { flexDirection: "row", flexWrap: "wrap", gap: 6 },
+  chip: { borderWidth: 1, borderRadius: 14, paddingHorizontal: 10, paddingVertical: 5 },
+  chipText: { fontSize: 13, fontWeight: "600" },
+  error: { color: "#dc2626", fontSize: 13, textAlign: "center" },
+  handoff: { alignSelf: "center", marginBottom: 8 },
+  composer: { flexDirection: "row", alignItems: "flex-end", gap: 8, paddingHorizontal: 12, paddingTop: 10, borderTopWidth: StyleSheet4.hairlineWidth },
+  input: { flex: 1, minHeight: 40, maxHeight: 120, paddingHorizontal: 14, paddingTop: 10, paddingBottom: 10, fontSize: 15 },
+  rating: { alignItems: "center", gap: 6, paddingVertical: 8 },
+  ratingTitle: { fontSize: 15, fontWeight: "600" },
+  stars: { flexDirection: "row", gap: 8 },
+  star: { fontSize: 30 },
+  articleTitle: { fontSize: 22, fontWeight: "700" },
+  loading: { marginTop: 40 }
+});
+
+// src/ui/ResourceCenter.tsx
+import { useEffect as useEffect2, useMemo as useMemo3, useState as useState2 } from "react";
+import { Modal as Modal2, Platform as Platform3, Pressable as Pressable4, ScrollView as ScrollView3, StyleSheet as StyleSheet5, Text as Text5, TextInput as TextInput2, View as View5 } from "react-native";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ResourceCenter({ client, palette: p, open, topInset, bottomInset }) {
+  const rc = client.getResourceCenter();
+  const [query, setQuery] = useState2("");
+  const [results, setResults] = useState2(null);
+  const [article, setArticle] = useState2(null);
+  const [faq, setFaq] = useState2(null);
+  useEffect2(() => {
+    if (!open) {
+      setQuery("");
+      setResults(null);
+      setArticle(null);
+    }
+  }, [open]);
+  useEffect2(() => {
+    const q = query.trim();
+    if (q.length < 2) {
+      setResults(null);
+      return;
+    }
+    let alive = true;
+    const t = setTimeout(() => {
+      void client.searchResourceCenter(q).then((r) => alive && setResults(r));
+    }, 250);
+    return () => {
+      alive = false;
+      clearTimeout(t);
+    };
+  }, [client, query]);
+  const guides = client.getGuides();
+  const recommended = useMemo3(() => (rc?.recommendedGuideIds ?? []).map((id) => guides.find((g) => g.id === id || g.key === id)).filter((g) => !!g && g.kind !== "checklist"), [rc, guides]);
+  const checklists = useMemo3(() => (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 openArticle = (a) => {
+    if (a.externalUrl) return client.navigate(a.externalUrl);
+    client.articleViewed(a);
+    setArticle(a);
+  };
+  const row = (key, title, subtitle, onPress, icon = "\u203A") => /* @__PURE__ */ jsxs4(Pressable4, { accessibilityRole: "button", accessibilityLabel: title, onPress, style: ({ pressed }) => [styles5.row, { borderColor: p.border, opacity: pressed ? 0.7 : 1 }], children: [
+    /* @__PURE__ */ jsxs4(View5, { style: styles5.flex, children: [
+      /* @__PURE__ */ jsx5(Text5, { style: [styles5.rowTitle, { color: p.text, fontFamily: p.fontFamily }], children: title }),
+      subtitle ? /* @__PURE__ */ jsx5(Text5, { style: [styles5.rowSub, { color: p.muted }], numberOfLines: 2, children: subtitle }) : null
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { style: [styles5.chev, { color: p.muted }], children: icon })
+  ] }, key);
+  const section = (title, children) => /* @__PURE__ */ jsxs4(View5, { style: styles5.section, children: [
+    /* @__PURE__ */ jsx5(Text5, { accessibilityRole: "header", style: [styles5.sectionTitle, { color: p.muted }], children: title.toUpperCase() }),
+    children
+  ] }, title);
+  const collections = [...rc.collections].sort((a, b) => a.order - b.order);
+  const loose = rc.articles.filter((a) => !a.collectionId || !rc.collections.some((c) => c.id === a.collectionId));
+  return /* @__PURE__ */ jsx5(Modal2, { 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__ */ jsx5(Pressable4, { accessibilityRole: "button", accessibilityLabel: "Back", onPress: () => setArticle(null), hitSlop: 10, children: /* @__PURE__ */ jsx5(Text5, { style: [styles5.back, { color: p.primary }], children: "\u2039 Back" }) }) : null,
+      /* @__PURE__ */ jsx5(Text5, { accessibilityRole: "header", style: [styles5.title, { color: p.text, fontFamily: p.fontFamily }], numberOfLines: 1, children: article ? "" : rc.title }),
+      /* @__PURE__ */ jsx5(CloseButton, { palette: p, onPress: close, label: "Close help" })
+    ] }),
+    article ? /* @__PURE__ */ jsxs4(ScrollView3, { contentContainerStyle: [styles5.content, { paddingBottom: bottomInset + 24 }], children: [
+      /* @__PURE__ */ jsx5(Text5, { accessibilityRole: "header", style: [styles5.articleTitle, { color: p.text, fontFamily: p.fontFamily }], children: article.title }),
+      /* @__PURE__ */ jsx5(RichText, { html: article.body, palette: p, onLink: (u) => client.navigate(u) })
+    ] }) : /* @__PURE__ */ jsxs4(ScrollView3, { contentContainerStyle: [styles5.content, { paddingBottom: bottomInset + 24 }], keyboardShouldPersistTaps: "handled", children: [
+      /* @__PURE__ */ jsx5(
+        TextInput2,
+        {
+          value: query,
+          onChangeText: setQuery,
+          placeholder: "Search help articles",
+          placeholderTextColor: p.muted,
+          accessibilityLabel: "Search help articles",
+          clearButtonMode: "while-editing",
+          returnKeyType: "search",
+          style: [styles5.search, { color: p.text, backgroundColor: p.surface, borderRadius: Math.min(10, p.radius) }]
+        }
+      ),
+      results ? section(
+        `Results for \u201C${query.trim()}\u201D`,
+        results.length ? results.map((a) => row(a.id, a.title, a.summary, () => openArticle(a))) : /* @__PURE__ */ jsx5(Text5, { style: [styles5.rowSub, { color: p.muted }], children: "No articles found." })
+      ) : /* @__PURE__ */ jsxs4(Fragment2, { 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,
+        collections.map((c) => {
+          const items = rc.articles.filter((a) => a.collectionId === c.id);
+          return items.length ? section(c.name, items.map((a) => row(a.id, a.title, a.summary, () => openArticle(a)))) : null;
+        }),
+        loose.length ? section("Articles", loose.map((a) => row(a.id, a.title, a.summary, () => openArticle(a)))) : null,
+        rc.faqs.length ? section(
+          "FAQ",
+          rc.faqs.map((f) => /* @__PURE__ */ jsxs4(View5, { style: [styles5.row, styles5.faq, { borderColor: p.border }], children: [
+            /* @__PURE__ */ jsxs4(Pressable4, { accessibilityRole: "button", accessibilityState: { expanded: faq === f.id }, onPress: () => setFaq(faq === f.id ? null : f.id), style: styles5.faqHead, children: [
+              /* @__PURE__ */ jsx5(Text5, { style: [styles5.rowTitle, styles5.flex, { color: p.text }], children: f.question }),
+              /* @__PURE__ */ jsx5(Text5, { style: [styles5.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
+      ] })
+    ] })
+  ] }) });
+}
+var styles5 = StyleSheet5.create({
+  flex: { flex: 1 },
+  sheet: { flex: 1 },
+  header: { flexDirection: "row", alignItems: "center", gap: 12, paddingHorizontal: 16, paddingVertical: 12, borderBottomWidth: StyleSheet5.hairlineWidth },
+  back: { fontSize: 16, fontWeight: "600" },
+  title: { flex: 1, fontSize: 18, fontWeight: "700" },
+  content: { padding: 16, gap: 18 },
+  search: { height: 42, paddingHorizontal: 12, fontSize: 15 },
+  section: { gap: 8 },
+  sectionTitle: { fontSize: 12, fontWeight: "700", letterSpacing: 0.6 },
+  row: { flexDirection: "row", alignItems: "center", gap: 10, borderWidth: StyleSheet5.hairlineWidth, borderRadius: 10, paddingVertical: 12, paddingHorizontal: 12 },
+  rowTitle: { fontSize: 15, fontWeight: "600" },
+  rowSub: { fontSize: 13, marginTop: 2 },
+  chev: { fontSize: 18 },
+  faq: { flexDirection: "column", alignItems: "stretch" },
+  faqHead: { flexDirection: "row", alignItems: "center", gap: 10 },
+  articleTitle: { fontSize: 22, fontWeight: "700" }
+});
+
+// src/ui/StepLayer.tsx
+import { useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
+import { AccessibilityInfo, Animated, Easing, Pressable as Pressable5, StyleSheet as StyleSheet7, View as View7 } from "react-native";
+
+// src/core/position.ts
+var MARGIN = 12;
+var ARROW_INSET = 18;
+var opposite = { top: "bottom", bottom: "top", left: "right", right: "left" };
+function positionCard(target, size, viewport, insets, placement, offset) {
+  const [rawSide, align] = placement.split("-");
+  const fits = (side2) => {
+    switch (side2) {
+      case "bottom":
+        return target.y + target.height + offset + size.height <= viewport.height - insets.bottom - MARGIN;
+      case "top":
+        return target.y - offset - size.height >= insets.top + MARGIN;
+      case "right":
+        return target.x + target.width + offset + size.width <= viewport.width - insets.right - MARGIN;
+      case "left":
+        return target.x - offset - size.width >= insets.left + MARGIN;
+    }
+  };
+  const order = rawSide === "auto" ? ["bottom", "top"] : [rawSide, opposite[rawSide], "bottom", "top"];
+  const space = { top: target.y - insets.top, bottom: viewport.height - insets.bottom - (target.y + target.height) };
+  const side = order.find(fits) ?? (space.bottom >= space.top ? "bottom" : "top");
+  const clamp2 = (v, min, max) => Math.max(min, Math.min(max, v));
+  if (side === "top" || side === "bottom") {
+    const cx = target.x + target.width / 2;
+    let x2 = align === "start" ? target.x : align === "end" ? target.x + target.width - size.width : cx - size.width / 2;
+    x2 = clamp2(x2, insets.left + MARGIN, Math.max(insets.left + MARGIN, viewport.width - insets.right - MARGIN - size.width));
+    let y2 = side === "bottom" ? target.y + target.height + offset : target.y - offset - size.height;
+    y2 = clamp2(y2, insets.top + MARGIN, Math.max(insets.top + MARGIN, viewport.height - insets.bottom - MARGIN - size.height));
+    return { x: x2, y: y2, side, arrow: clamp2(cx - x2, ARROW_INSET, size.width - ARROW_INSET) };
+  }
+  const cy = target.y + target.height / 2;
+  let y = align === "start" ? target.y : align === "end" ? target.y + target.height - size.height : cy - size.height / 2;
+  y = clamp2(y, insets.top + MARGIN, Math.max(insets.top + MARGIN, viewport.height - insets.bottom - MARGIN - size.height));
+  const x = side === "right" ? target.x + target.width + offset : target.x - offset - size.width;
+  return { x, y, side, arrow: clamp2(cy - y, ARROW_INSET, size.height - ARROW_INSET) };
+}
+
+// src/ui/StepCard.tsx
+import { Image, StyleSheet as StyleSheet6, Text as Text6, View as View6 } from "react-native";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function StepCard({ view, client, palette: p, width, style, compact }) {
+  const { step, guide } = view;
+  const buttons = visibleButtons(step, view.canGoBack);
+  const body = step.type === "custom" ? step.customHtml || step.body : step.body;
+  const showProgress = step.showProgress && view.total > 1;
+  const onLink = (url) => client.navigate(url);
+  return /* @__PURE__ */ jsx6(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__ */ jsx6(Image, { source: { uri: step.imageUrl }, style: [styles6.image, { borderRadius: Math.max(0, p.radius - 4) }], resizeMode: "cover", accessibilityIgnoresInvertColors: true }) : null,
+    step.title ? /* @__PURE__ */ jsxs5(View6, { style: styles6.header, children: [
+      /* @__PURE__ */ jsx6(Text6, { accessibilityRole: "header", style: [styles6.title, { color: p.text, fontFamily: p.fontFamily }], children: step.title }),
+      step.showClose ? /* @__PURE__ */ jsx6(CloseButton, { palette: p, onPress: () => client.closeStep(guide.id), label: "Dismiss guide" }) : null
+    ] }) : null,
+    body ? (
+      // Without a title the close button floats beside the body instead of taking a row.
+      /* @__PURE__ */ jsx6(View6, { style: !step.title && step.showClose ? styles6.bodyBesideClose : void 0, children: /* @__PURE__ */ jsx6(RichText, { html: body, palette: p, onLink }) })
+    ) : null,
+    !step.title && step.showClose ? /* @__PURE__ */ jsx6(View6, { style: compact ? styles6.floatingCloseCompact : styles6.floatingClose, children: /* @__PURE__ */ jsx6(CloseButton, { palette: p, onPress: () => client.closeStep(guide.id), label: "Dismiss guide" }) }) : null,
+    showProgress || buttons.length ? /* @__PURE__ */ jsxs5(View6, { style: styles6.footer, children: [
+      showProgress ? /* @__PURE__ */ jsxs5(Text6, { style: [styles6.progress, { color: p.muted }], accessibilityLabel: `Step ${view.index + 1} of ${view.total}`, children: [
+        view.index + 1,
+        " of ",
+        view.total
+      ] }) : /* @__PURE__ */ jsx6(View6, { style: styles6.flex }),
+      /* @__PURE__ */ jsx6(View6, { style: styles6.buttons, children: buttons.map((b) => /* @__PURE__ */ jsx6(GButton, { label: b.label, variant: b.variant, palette: p, onPress: () => client.pressButton(guide.id, b) }, b.id)) })
+    ] }) : null
+  ] }) });
+}
+function announcement(view) {
+  const parts = [view.step.title, htmlToText(view.step.body)].filter(Boolean);
+  if (view.total > 1) parts.push(`Step ${view.index + 1} of ${view.total}`);
+  return parts.join(". ");
+}
+var styles6 = StyleSheet6.create({
+  inner: { padding: 16, gap: 10 },
+  compact: { paddingHorizontal: 14, paddingVertical: 10, gap: 6 },
+  image: { width: "100%", height: 140, marginBottom: 2 },
+  header: { flexDirection: "row", alignItems: "flex-start", gap: 8 },
+  title: { flex: 1, fontSize: 17, fontWeight: "700", lineHeight: 22 },
+  flex: { flex: 1 },
+  bodyBesideClose: { paddingRight: 24 },
+  floatingClose: { position: "absolute", top: 16, right: 16 },
+  floatingCloseCompact: { position: "absolute", top: 10, right: 14 },
+  footer: { flexDirection: "row", alignItems: "center", gap: 8, marginTop: 4, flexWrap: "wrap" },
+  progress: { flex: 1, fontSize: 12, fontWeight: "500" },
+  buttons: { flexDirection: "row", gap: 8, flexWrap: "wrap", justifyContent: "flex-end" }
+});
+
+// src/ui/StepLayer.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function useTargetRect(client, targetId, origin) {
+  const [rect, setRect] = useState3(null);
+  useEffect3(() => {
+    if (!targetId) {
+      setRect(null);
+      return;
+    }
+    let alive = true;
+    const measure = async () => {
+      const r = await client.targets.measure(targetId);
+      if (!alive) return;
+      setRect((prev) => {
+        const next = r ? { x: r.x - origin.x, y: r.y - origin.y, width: r.width, height: r.height } : null;
+        if (prev && next && Math.abs(prev.x - next.x) < 0.5 && Math.abs(prev.y - next.y) < 0.5 && prev.width === next.width && prev.height === next.height) return prev;
+        return next;
+      });
+    };
+    void measure();
+    const off = client.targets.onChange(() => void measure());
+    const timer = setInterval(() => void measure(), 250);
+    return () => {
+      alive = false;
+      off();
+      clearInterval(timer);
+    };
+  }, [client, targetId, origin.x, origin.y]);
+  return rect;
+}
+function useFadeIn(key) {
+  const opacity = useRef2(new Animated.Value(0)).current;
+  useEffect3(() => {
+    opacity.setValue(0);
+    Animated.timing(opacity, { toValue: 1, duration: 160, easing: Easing.out(Easing.quad), useNativeDriver: true }).start();
+  }, [key, opacity]);
+  return opacity;
+}
+function StepLayer({ view, client, palette: p, geometry }) {
+  const { step } = view;
+  const rect = useTargetRect(client, view.asModal ? null : view.targetId, geometry.origin);
+  const opacity = useFadeIn(view.key);
+  const { viewport, insets } = geometry;
+  const cardWidth = Math.min(viewport.width - 32, step.width ?? 340);
+  useEffect3(() => {
+    if (step.type === "hotspot" && !view.expanded) return;
+    AccessibilityInfo.announceForAccessibility?.(announcement(view));
+  }, [view.key, view.expanded]);
+  const backdrop = (children) => /* @__PURE__ */ jsx7(Pressable5, { accessible: false, style: [StyleSheet7.absoluteFill, { backgroundColor: p.overlay }], onPress: () => client.backdropPressed(view.guide.id), children });
+  const anchored = !view.asModal && ["tooltip", "popover", "spotlight", "hotspot"].includes(step.type);
+  if (!anchored && step.type === "banner") {
+    const top = step.position.startsWith("top");
+    return /* @__PURE__ */ jsx7(Animated.View, { pointerEvents: "box-none", style: [styles7.banner, top ? { top: insets.top + 8 } : { bottom: insets.bottom + 8 }, { left: insets.left + 8, right: insets.right + 8, opacity }], children: /* @__PURE__ */ jsx7(StepCard, { view, client, palette: p, width: viewport.width - insets.left - insets.right - 16, compact: true }) });
+  }
+  if (!anchored && step.type === "slideout") {
+    const wide = viewport.width >= 600;
+    const right = !step.position.endsWith("left");
+    const width = wide ? Math.min(380, cardWidth) : viewport.width - insets.left - insets.right - 24;
+    return /* @__PURE__ */ jsx7(Animated.View, { pointerEvents: "box-none", style: [styles7.abs, { bottom: insets.bottom + 12, opacity }, wide ? right ? { right: insets.right + 16 } : { left: insets.left + 16 } : { left: insets.left + 12 }], children: /* @__PURE__ */ jsx7(StepCard, { view, client, palette: p, width }) });
+  }
+  if (!anchored) {
+    return /* @__PURE__ */ jsxs6(Animated.View, { pointerEvents: "box-none", style: [StyleSheet7.absoluteFill, styles7.center, { opacity }], children: [
+      step.showOverlay ? backdrop() : null,
+      /* @__PURE__ */ jsx7(StepCard, { view, client, palette: p, width: Math.min(viewport.width - 40, step.width ?? 360) })
+    ] });
+  }
+  if (!rect) return null;
+  if (step.type === "hotspot") {
+    const size = step.hotspot?.size ?? 14;
+    return /* @__PURE__ */ jsxs6(View7, { pointerEvents: "box-none", style: StyleSheet7.absoluteFill, children: [
+      /* @__PURE__ */ jsx7(Hotspot, { x: rect.x + rect.width - size / 2, y: rect.y - size / 2, size, pulse: step.hotspot?.pulse ?? true, color: p.primary, onPress: () => client.toggleHotspot(view.guide.id), label: step.title || "Show tip" }),
+      view.expanded ? /* @__PURE__ */ jsx7(Anchored, { view, client, palette: p, geometry, rect, width: cardWidth }) : null
+    ] });
+  }
+  if (step.type === "spotlight") {
+    const pad = step.spotlightPadding;
+    const hole = { x: rect.x - pad, y: rect.y - pad, width: rect.width + pad * 2, height: rect.height + pad * 2 };
+    const r = Math.max(0, Math.min(12, p.radius, hole.width / 2, hole.height / 2));
+    const shade = { backgroundColor: p.overlay };
+    const press = () => client.backdropPressed(view.guide.id);
+    const corners = [
+      [hole.x, hole.y, -r, -r],
+      [hole.x + hole.width - r, hole.y, -2 * r, -r],
+      [hole.x, hole.y + hole.height - r, -r, -2 * r],
+      [hole.x + hole.width - r, hole.y + hole.height - r, -2 * r, -2 * r]
+    ];
+    return /* @__PURE__ */ jsxs6(Animated.View, { pointerEvents: "box-none", style: [StyleSheet7.absoluteFill, { opacity }], children: [
+      /* @__PURE__ */ jsx7(Pressable5, { accessible: false, onPress: press, style: [styles7.abs, shade, { left: 0, right: 0, top: 0, height: Math.max(0, hole.y) }] }),
+      /* @__PURE__ */ jsx7(Pressable5, { accessible: false, onPress: press, style: [styles7.abs, shade, { left: 0, right: 0, top: hole.y + hole.height, bottom: 0 }] }),
+      /* @__PURE__ */ jsx7(Pressable5, { accessible: false, onPress: press, style: [styles7.abs, shade, { left: 0, width: Math.max(0, hole.x), top: hole.y, height: hole.height }] }),
+      /* @__PURE__ */ jsx7(Pressable5, { accessible: false, onPress: press, style: [styles7.abs, shade, { left: hole.x + hole.width, right: 0, top: hole.y, height: hole.height }] }),
+      r > 0 ? corners.map(([left, top, dx, dy], i) => /* @__PURE__ */ jsx7(View7, { pointerEvents: "none", style: [styles7.abs, { left, top, width: r, height: r, overflow: "hidden" }], children: /* @__PURE__ */ jsx7(View7, { style: [styles7.abs, { left: dx, top: dy, width: 4 * r, height: 4 * r, borderRadius: 2 * r, borderWidth: r, borderColor: p.overlay }] }) }, i)) : null,
+      /* @__PURE__ */ jsx7(View7, { pointerEvents: "none", style: [styles7.abs, { left: hole.x, top: hole.y, width: hole.width, height: hole.height, borderRadius: r, borderWidth: 2, borderColor: p.primary }] }),
+      /* @__PURE__ */ jsx7(Anchored, { view, client, palette: p, geometry, rect: hole, width: cardWidth })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6(Animated.View, { pointerEvents: "box-none", style: [StyleSheet7.absoluteFill, { opacity }], children: [
+    step.showOverlay ? backdrop() : null,
+    /* @__PURE__ */ jsx7(Anchored, { view, client, palette: p, geometry, rect, width: cardWidth })
+  ] });
+}
+var ARROW = 12;
+function Anchored({ view, client, palette: p, geometry, rect, width }) {
+  const [height, setHeight] = useState3(0);
+  const onLayout = (e) => setHeight(Math.round(e.nativeEvent.layout.height));
+  const offset = view.step.offset + ARROW / 2;
+  const pos = positionCard(rect, { width, height: height || 120 }, geometry.viewport, geometry.insets, view.step.placement, offset);
+  return /* @__PURE__ */ jsxs6(View7, { pointerEvents: "box-none", style: [styles7.abs, { left: pos.x, top: pos.y, width, opacity: height ? 1 : 0 }], onLayout, children: [
+    /* @__PURE__ */ jsx7(Arrow, { side: pos.side, at: pos.arrow, color: p.background, border: p.border }),
+    /* @__PURE__ */ jsx7(StepCard, { view, client, palette: p, width })
+  ] });
+}
+function Arrow({ side, at, color, border }) {
+  const half = ARROW / 2;
+  const place = side === "bottom" ? { top: -half, left: at - half } : side === "top" ? { bottom: -half, left: at - half } : side === "right" ? { left: -half, top: at - half } : { right: -half, top: at - half };
+  return /* @__PURE__ */ jsx7(View7, { pointerEvents: "none", style: [styles7.abs, styles7.arrow, place, { backgroundColor: color, borderColor: border }] });
+}
+function Hotspot({ x, y, size, pulse, color, onPress, label }) {
+  const scale = useRef2(new Animated.Value(0)).current;
+  const [reduceMotion, setReduceMotion] = useState3(false);
+  useEffect3(() => {
+    let alive = true;
+    AccessibilityInfo.isReduceMotionEnabled?.().then((v) => alive && setReduceMotion(v), () => {
+    });
+    return () => {
+      alive = false;
+    };
+  }, []);
+  useEffect3(() => {
+    if (!pulse || reduceMotion) return;
+    const loop = Animated.loop(Animated.timing(scale, { toValue: 1, duration: 1400, easing: Easing.out(Easing.ease), useNativeDriver: true }));
+    loop.start();
+    return () => loop.stop();
+  }, [pulse, reduceMotion, scale]);
+  return /* @__PURE__ */ jsxs6(Pressable5, { accessibilityRole: "button", accessibilityLabel: label, onPress, hitSlop: 14, style: [styles7.abs, { left: x, top: y, width: size, height: size }], children: [
+    pulse && !reduceMotion ? /* @__PURE__ */ jsx7(
+      Animated.View,
+      {
+        pointerEvents: "none",
+        style: [styles7.abs, { width: size, height: size, borderRadius: size / 2, backgroundColor: color, opacity: scale.interpolate({ inputRange: [0, 1], outputRange: [0.55, 0] }), transform: [{ scale: scale.interpolate({ inputRange: [0, 1], outputRange: [1, 2.6] }) }] }]
+      }
+    ) : null,
+    /* @__PURE__ */ jsx7(View7, { style: { width: size, height: size, borderRadius: size / 2, backgroundColor: color, borderWidth: 2, borderColor: "#ffffff" } })
+  ] });
+}
+var styles7 = StyleSheet7.create({
+  abs: { position: "absolute" },
+  center: { alignItems: "center", justifyContent: "center" },
+  banner: { position: "absolute" },
+  arrow: { width: ARROW, height: ARROW, transform: [{ rotate: "45deg" }], borderWidth: StyleSheet7.hairlineWidth }
+});
+
+// src/ui/Survey.tsx
+import { useEffect as useEffect4, useState as useState4 } from "react";
+import {
+  AccessibilityInfo as AccessibilityInfo2,
+  KeyboardAvoidingView,
+  Platform as Platform4,
+  Pressable as Pressable6,
+  ScrollView as ScrollView4,
+  StyleSheet as StyleSheet8,
+  Text as Text7,
+  TextInput as TextInput3,
+  View as View8
+} from "react-native";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function Survey({
+  view,
+  client,
+  palette: p,
+  geometry
+}) {
+  const config = view.guide.config.survey;
+  const [answers, setAnswers] = useState4({});
+  const [error, setError] = useState4("");
+  useEffect4(() => {
+    setAnswers({});
+    setError("");
+    AccessibilityInfo2.announceForAccessibility?.(
+      `Survey: ${config?.questions[0]?.title ?? view.guide.name}`
+    );
+  }, [view.key]);
+  if (!config) return null;
+  const { insets, viewport } = geometry;
+  const width = Math.min(viewport.width - insets.left - insets.right - 24, 420);
+  const centered = config.position === "center";
+  const set = (id, value) => setAnswers((prev) => {
+    const next = { ...prev };
+    if (value === void 0) delete next[id];
+    else next[id] = value;
+    for (const q of config.questions)
+      if (!isQuestionVisible(q, next) && next[q.id] !== void 0) delete next[q.id];
+    return next;
+  });
+  const submit = () => {
+    const missing = config.questions.filter(
+      (q) => q.required && isQuestionVisible(q, answers) && answers[q.id] === void 0
+    );
+    if (missing.length) {
+      setError(`Please answer: ${missing.map((q) => q.title).join(", ")}`);
+      return;
+    }
+    setError("");
+    client.submitSurvey(view.guide.id, { ...answers });
+  };
+  const close = () => client.closeSurvey(view.guide.id);
+  return (
+    // KeyboardAvoidingView owns its bottom padding, so the safe-area padding lives on an inner view.
+    /* @__PURE__ */ jsxs7(
+      KeyboardAvoidingView,
+      {
+        pointerEvents: "box-none",
+        behavior: Platform4.OS === "ios" ? "padding" : void 0,
+        style: StyleSheet8.absoluteFill,
+        children: [
+          centered ? /* @__PURE__ */ jsx8(
+            Pressable6,
+            {
+              accessible: false,
+              style: [StyleSheet8.absoluteFill, { backgroundColor: p.overlay }],
+              onPress: close
+            }
+          ) : null,
+          /* @__PURE__ */ jsx8(
+            View8,
+            {
+              pointerEvents: "box-none",
+              style: [
+                styles8.fill,
+                centered ? styles8.center : styles8.bottom,
+                !centered && { paddingBottom: insets.bottom + 12 }
+              ],
+              children: /* @__PURE__ */ jsx8(
+                Surface,
+                {
+                  palette: p,
+                  style: { width, maxHeight: viewport.height - insets.top - insets.bottom - 40 },
+                  children: view.submitted ? /* @__PURE__ */ jsxs7(View8, { style: styles8.inner, children: [
+                    /* @__PURE__ */ jsx8(
+                      Text7,
+                      {
+                        accessibilityRole: "header",
+                        style: [styles8.title, { color: p.text, fontFamily: p.fontFamily }],
+                        children: config.thankYouTitle
+                      }
+                    ),
+                    config.thankYouBody ? /* @__PURE__ */ jsx8(
+                      RichText,
+                      {
+                        html: config.thankYouBody,
+                        palette: p,
+                        onLink: (u) => client.navigate(u)
+                      }
+                    ) : null,
+                    /* @__PURE__ */ jsx8(GButton, { label: "Done", palette: p, onPress: close, style: styles8.end })
+                  ] }) : /* @__PURE__ */ jsxs7(ScrollView4, { contentContainerStyle: styles8.inner, keyboardShouldPersistTaps: "handled", children: [
+                    config.questions.filter((q) => isQuestionVisible(q, answers)).map((q, i) => /* @__PURE__ */ jsxs7(View8, { style: styles8.question, children: [
+                      /* @__PURE__ */ jsxs7(View8, { style: styles8.head, children: [
+                        /* @__PURE__ */ jsxs7(Text7, { style: [styles8.qTitle, { color: p.text, fontFamily: p.fontFamily }], children: [
+                          q.title,
+                          !q.required ? /* @__PURE__ */ jsx8(Text7, { style: { color: p.muted, fontWeight: "400" }, children: " (optional)" }) : null
+                        ] }),
+                        i === 0 ? /* @__PURE__ */ jsx8(CloseButton, { palette: p, onPress: close, label: "Dismiss survey" }) : null
+                      ] }),
+                      q.description ? /* @__PURE__ */ jsx8(Text7, { style: [styles8.desc, { color: p.muted }], children: q.description }) : null,
+                      /* @__PURE__ */ jsx8(
+                        QuestionInput,
+                        {
+                          q,
+                          value: answers[q.id],
+                          onChange: (v) => set(q.id, v),
+                          palette: p
+                        }
+                      )
+                    ] }, q.id)),
+                    error ? /* @__PURE__ */ jsx8(Text7, { accessibilityLiveRegion: "polite", style: [styles8.error], children: error }) : null,
+                    /* @__PURE__ */ jsx8(GButton, { label: "Submit", palette: p, onPress: submit, style: styles8.end })
+                  ] })
+                }
+              )
+            }
+          )
+        ]
+      }
+    )
+  );
+}
+function QuestionInput({
+  q,
+  value,
+  onChange,
+  palette: p
+}) {
+  const chip = (selected) => [
+    styles8.chip,
+    {
+      borderColor: selected ? p.primary : p.border,
+      backgroundColor: selected ? p.primary : p.background,
+      borderRadius: Math.min(8, p.radius)
+    }
+  ];
+  const chipText = (selected) => [
+    styles8.chipText,
+    { color: selected ? p.onPrimary : p.text }
+  ];
+  switch (q.type) {
+    case "nps":
+    case "csat": {
+      const min = q.type === "nps" ? 0 : 1;
+      const max = q.type === "nps" ? 10 : q.scaleMax ?? 5;
+      const values = Array.from({ length: max - min + 1 }, (_, i) => min + i);
+      return /* @__PURE__ */ jsxs7(View8, { children: [
+        /* @__PURE__ */ jsx8(View8, { style: styles8.scale, accessibilityRole: "radiogroup", accessibilityLabel: q.title, children: values.map((n) => /* @__PURE__ */ jsx8(
+          Pressable6,
+          {
+            accessibilityRole: "radio",
+            accessibilityState: { selected: value === n },
+            accessibilityLabel: String(n),
+            onPress: () => onChange(n),
+            style: [...chip(value === n), styles8.scaleItem],
+            children: /* @__PURE__ */ jsx8(Text7, { style: chipText(value === n), children: n })
+          },
+          n
+        )) }),
+        q.lowLabel || q.highLabel ? /* @__PURE__ */ jsxs7(View8, { style: styles8.labels, children: [
+          /* @__PURE__ */ jsx8(Text7, { style: [styles8.small, { color: p.muted }], children: q.lowLabel }),
+          /* @__PURE__ */ jsx8(Text7, { style: [styles8.small, { color: p.muted }], children: q.highLabel })
+        ] }) : null
+      ] });
+    }
+    case "rating": {
+      const max = q.scaleMax ?? 5;
+      return /* @__PURE__ */ jsx8(View8, { style: styles8.stars, accessibilityRole: "radiogroup", accessibilityLabel: q.title, children: Array.from({ length: max }, (_, i) => i + 1).map((n) => /* @__PURE__ */ jsx8(
+        Pressable6,
+        {
+          accessibilityRole: "radio",
+          accessibilityLabel: `${n} of ${max}`,
+          accessibilityState: { selected: value === n },
+          onPress: () => onChange(n),
+          hitSlop: 4,
+          children: /* @__PURE__ */ jsx8(
+            Text7,
+            {
+              style: [
+                styles8.star,
+                { color: typeof value === "number" && n <= value ? p.primary : p.border }
+              ],
+              children: "\u2605"
+            }
+          )
+        },
+        n
+      )) });
+    }
+    case "thumbs":
+      return /* @__PURE__ */ jsx8(View8, { style: styles8.row, accessibilityRole: "radiogroup", children: [
+        [true, "\u{1F44D}", "Thumbs up"],
+        [false, "\u{1F44E}", "Thumbs down"]
+      ].map(([val, icon, label]) => /* @__PURE__ */ jsx8(
+        Pressable6,
+        {
+          accessibilityRole: "radio",
+          accessibilityLabel: label,
+          accessibilityState: { selected: value === val },
+          onPress: () => onChange(val),
+          style: [...chip(value === val), styles8.thumb],
+          children: /* @__PURE__ */ jsx8(Text7, { style: styles8.thumbText, children: icon })
+        },
+        String(val)
+      )) });
+    case "single_choice":
+    case "multiple_choice": {
+      const multi = q.type === "multiple_choice";
+      const selected = new Set(
+        multi ? value ?? [] : value !== void 0 ? [String(value)] : []
+      );
+      return /* @__PURE__ */ jsx8(View8, { style: styles8.choices, children: q.options.map((o) => {
+        const on = selected.has(o.id);
+        return /* @__PURE__ */ jsxs7(
+          Pressable6,
+          {
+            accessibilityRole: multi ? "checkbox" : "radio",
+            accessibilityState: { checked: on },
+            accessibilityLabel: o.label,
+            onPress: () => {
+              if (!multi) return onChange(o.id);
+              const next = new Set(selected);
+              if (on) next.delete(o.id);
+              else next.add(o.id);
+              onChange(next.size ? Array.from(next) : void 0);
+            },
+            style: [
+              styles8.choice,
+              { borderColor: on ? p.primary : p.border, borderRadius: Math.min(10, p.radius) }
+            ],
+            children: [
+              /* @__PURE__ */ jsx8(
+                View8,
+                {
+                  style: [
+                    styles8.dot,
+                    multi && styles8.box,
+                    {
+                      borderColor: on ? p.primary : p.border,
+                      backgroundColor: on ? p.primary : "transparent"
+                    }
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx8(Text7, { style: [styles8.choiceText, { color: p.text }], children: o.label })
+            ]
+          },
+          o.id
+        );
+      }) });
+    }
+    case "text":
+    default:
+      return /* @__PURE__ */ jsx8(
+        TextInput3,
+        {
+          accessibilityLabel: q.title,
+          multiline: true,
+          value: typeof value === "string" ? value : "",
+          onChangeText: (t) => onChange(t ? t.slice(0, 5e3) : void 0),
+          placeholder: q.placeholder || "",
+          placeholderTextColor: p.muted,
+          style: [
+            styles8.input,
+            {
+              color: p.text,
+              borderColor: p.border,
+              borderRadius: Math.min(10, p.radius),
+              backgroundColor: p.surface
+            }
+          ]
+        }
+      );
+  }
+}
+var styles8 = StyleSheet8.create({
+  fill: { flex: 1 },
+  center: { alignItems: "center", justifyContent: "center" },
+  bottom: { alignItems: "center", justifyContent: "flex-end" },
+  inner: { padding: 16, gap: 14 },
+  title: { fontSize: 17, fontWeight: "700" },
+  end: { alignSelf: "flex-end" },
+  question: { gap: 8 },
+  head: { flexDirection: "row", gap: 8, alignItems: "flex-start" },
+  qTitle: { flex: 1, fontSize: 15, fontWeight: "600", lineHeight: 20 },
+  desc: { fontSize: 13 },
+  scale: { flexDirection: "row", flexWrap: "wrap", gap: 4 },
+  scaleItem: { flexGrow: 1, flexBasis: 26 },
+  chip: {
+    borderWidth: 1,
+    minHeight: 36,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 4
+  },
+  chipText: { fontSize: 14, fontWeight: "600" },
+  labels: { flexDirection: "row", justifyContent: "space-between", marginTop: 4 },
+  small: { fontSize: 12 },
+  stars: { flexDirection: "row", gap: 6 },
+  star: { fontSize: 30 },
+  row: { flexDirection: "row", gap: 10 },
+  thumb: { width: 56, height: 44 },
+  thumbText: { fontSize: 22 },
+  choices: { gap: 8 },
+  choice: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 10,
+    borderWidth: 1,
+    paddingVertical: 10,
+    paddingHorizontal: 12
+  },
+  dot: { width: 18, height: 18, borderRadius: 9, borderWidth: 2 },
+  box: { borderRadius: 4 },
+  choiceText: { fontSize: 15, flex: 1 },
+  input: { minHeight: 80, borderWidth: 1, padding: 10, fontSize: 15, textAlignVertical: "top" },
+  error: { color: "#dc2626", fontSize: 13 }
+});
+
+// src/ui/theme.ts
+var DARK = { background: "#18181b", text: "#f4f4f5", muted: "#a1a1aa", border: "#3f3f46", surface: "#27272a" };
+function luminance(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex);
+  if (!m) return 1;
+  const n = parseInt(m[1], 16);
+  const ch = [n >> 16 & 255, n >> 8 & 255, n & 255].map((c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * ch[0] + 0.7152 * ch[1] + 0.0722 * ch[2];
+}
+function mix(hex, alpha) {
+  const a = Math.round(Math.max(0, Math.min(1, alpha)) * 255).toString(16).padStart(2, "0");
+  return /^#[0-9a-f]{6}$/i.test(hex) ? `${hex}${a}` : hex;
+}
+function nativeFont(stack) {
+  const first = stack?.split(",")[0]?.trim().replace(/^["']|["']$/g, "");
+  if (!first || /^(system-ui|-apple-system|sans-serif|serif|monospace|inter|ui-sans-serif)$/i.test(first)) return void 0;
+  return first;
+}
+function palette(theme, systemScheme, explicit) {
+  const primary = theme.primaryColor ?? "#4f46e5";
+  const wantsDark = theme.dark === "dark" || theme.dark === "auto" && systemScheme === "dark";
+  const dark = wantsDark && !explicit?.backgroundColor;
+  const background = dark ? DARK.background : theme.backgroundColor ?? "#ffffff";
+  const text = dark ? DARK.text : theme.textColor ?? "#111827";
+  return {
+    primary,
+    onPrimary: luminance(primary) > 0.45 ? "#111827" : "#ffffff",
+    background,
+    text,
+    muted: dark ? DARK.muted : mix(text, 0.65),
+    border: dark ? DARK.border : mix(text, 0.12),
+    surface: dark ? DARK.surface : mix(text, 0.05),
+    radius: theme.borderRadius ?? 12,
+    overlay: `rgba(15, 23, 42, ${theme.overlayOpacity ?? 0.55})`,
+    fontFamily: nativeFont(theme.fontFamily)
+  };
+}
+
+// src/ui/Overlay.tsx
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function defaultInsets(width, height) {
+  if (Platform5.OS === "ios") {
+    const notch = Math.max(width, height) >= 812 && !Platform5.isPad;
+    const landscape = width > height;
+    return { top: landscape ? 0 : notch ? 50 : 20, bottom: notch ? landscape ? 21 : 34 : 0, left: landscape && notch ? 44 : 0, right: landscape && notch ? 44 : 0 };
+  }
+  return { top: StatusBar.currentHeight ?? 24, bottom: 16, left: 0, right: 0 };
+}
+function GuidelyOverlay({ client, insets: insetsProp, launcherOffset }) {
+  const ui = useSyncExternalStore2(
+    useCallback2((cb) => client.subscribeUi(cb), [client]),
+    () => client.getUiState(),
+    () => client.getUiState()
+  );
+  const { width, height } = useWindowDimensions();
+  const scheme = useColorScheme();
+  const ref = useRef3(null);
+  const [origin, setOrigin] = useState5({ x: 0, y: 0 });
+  useEffect5(() => {
+    client.targets.setViewport(width, height);
+  }, [client, width, height]);
+  const measureOrigin = useCallback2(() => {
+    ref.current?.measureInWindow?.((x, y) => {
+      if (Number.isFinite(x) && Number.isFinite(y)) setOrigin((o) => o.x === x && o.y === y ? o : { x, y });
+    });
+  }, []);
+  const insets = { ...defaultInsets(width, height), ...insetsProp };
+  const geometry = { origin, viewport: { width, height }, insets };
+  const basePalette = palette(ui.theme, scheme);
+  const messenger = ui.messenger ? client.getMessenger() : null;
+  const showRcLauncher = !messenger && !!client.options.showResourceCenterLauncher && !!client.getResourceCenter();
+  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__ */ jsx9(Checklist, { view: c, client, palette: palette(client.themeFor(c.guide), scheme), geometry, showLauncher: client.options.showChecklistLauncher !== false, launcherBottom: launcherOffset }, c.guide.id)),
+    showRcLauncher ? /* @__PURE__ */ jsx9(
+      Pressable7,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: client.getResourceCenter()?.launcher.label || "Help",
+        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__ */ jsx9(Text8, { style: [styles9.rcText, { color: basePalette.onPrimary }], children: "?" })
+      }
+    ) : null,
+    messenger && client.options.showMessengerLauncher !== false ? /* @__PURE__ */ jsx9(MessengerLauncher, { store: messenger, palette: basePalette, style: [messengerLeft ? { left: insets.left + 16 } : { right: insets.right + 16 }, { bottom: insets.bottom + launcherOffset + (checklistOnSameSide ? 56 : 0) }] }) : null,
+    ui.survey ? /* @__PURE__ */ jsx9(Survey, { view: ui.survey, client, palette: palette(client.themeFor(ui.survey.guide), scheme), geometry }) : null,
+    ui.steps.map((s) => /* @__PURE__ */ jsx9(StepLayer, { view: s, client, palette: palette(client.themeFor(s.guide), scheme, s.guide.config.appearance), geometry }, s.key)),
+    messenger ? /* @__PURE__ */ jsx9(MessengerSheet, { store: messenger, client, palette: basePalette, topInset: insets.top, bottomInset: insets.bottom }) : /* @__PURE__ */ jsx9(ResourceCenter, { client, palette: basePalette, open: ui.resourceCenterOpen, topInset: insets.top, bottomInset: insets.bottom })
+  ] });
+}
+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" }
+});
+
+// src/ui/Target.tsx
+import { createContext, useCallback as useCallback3, useContext, useEffect as useEffect6, useRef as useRef4 } from "react";
+import { View as View10 } from "react-native";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var GuidelyContext = createContext(null);
+var GuidelyScreenContext = createContext(null);
+function GuidelyScreenScope({ name, children }) {
+  return /* @__PURE__ */ jsx10(GuidelyScreenContext.Provider, { value: name, children });
+}
+function guidelyScreenLayout({ route, children }) {
+  return /* @__PURE__ */ jsx10(GuidelyScreenScope, { name: route.name, children });
+}
+var TAP_SLOP = 10;
+function useGuidelyTarget(id) {
+  const client = useContext(GuidelyContext);
+  const screen = useContext(GuidelyScreenContext);
+  const ref = useRef4(null);
+  const start = useRef4(null);
+  useEffect6(() => {
+    if (!client || !id) return;
+    return client.targets.register(id, {
+      screen,
+      measure: () => new Promise((resolve) => {
+        const node = ref.current;
+        if (!node || typeof node.measureInWindow !== "function") return resolve(null);
+        node.measureInWindow((x, y, width, height) => resolve(Number.isFinite(x) ? { x, y, width, height } : null));
+      })
+    });
+  }, [client, id, screen]);
+  const onLayout = useCallback3(() => client?.targets.changed(), [client]);
+  const onTouchStart = useCallback3((e) => {
+    start.current = { x: e.nativeEvent.pageX, y: e.nativeEvent.pageY };
+  }, []);
+  const onTouchEnd = useCallback3(
+    (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);
+    },
+    [client, id]
+  );
+  return { ref, collapsable: false, onLayout, onTouchStart, onTouchEnd };
+}
+function GuidelyTarget({ id, children, onLayout, onTouchStart, onTouchEnd, ...rest }) {
+  const t = useGuidelyTarget(id);
+  return /* @__PURE__ */ jsx10(
+    View10,
+    {
+      ...rest,
+      ref: t.ref,
+      collapsable: false,
+      onLayout: (e) => {
+        t.onLayout();
+        onLayout?.(e);
+      },
+      onTouchStart: (e) => {
+        t.onTouchStart(e);
+        onTouchStart?.(e);
+      },
+      onTouchEnd: (e) => {
+        t.onTouchEnd(e);
+        onTouchEnd?.(e);
+      },
+      children
+    }
+  );
+}
+
+// src/index.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function deviceLocale() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale;
+  } catch {
+    return void 0;
+  }
+}
+function defaultBridge(appVersion) {
+  const { width, height } = Dimensions.get("window");
+  return {
+    device: {
+      platform: Platform6.OS === "android" ? "android" : "ios",
+      deviceType: Platform6.OS === "ios" && Platform6.isPad || Math.min(width, height) >= 600 ? "tablet" : "mobile",
+      locale: deviceLocale(),
+      appVersion
+    },
+    openExternal: (url) => void Linking.openURL(url).catch(() => {
+    })
+  };
+}
+function GuidelyProvider({ children, user, insets, launcherOffset = 72, ...options }) {
+  const [client, setClient] = useState6(null);
+  const optionsRef = useRef5(options);
+  optionsRef.current = options;
+  const { projectId, environment, apiUrl, storage } = options;
+  useEffect7(() => {
+    if (!projectId) return;
+    let c;
+    try {
+      const latest = optionsRef.current;
+      c = new GuidelyClient(
+        { ...latest, projectId, environment, apiUrl, storage, onNavigate: (url) => optionsRef.current.onNavigate?.(url), onError: (err) => optionsRef.current.onError?.(err) },
+        defaultBridge(latest.appVersion)
+      );
+    } catch (err) {
+      optionsRef.current.onError?.(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    setClient(c);
+    void c.init();
+    const sub = AppState.addEventListener("change", (s) => c.setAppState(s));
+    return () => {
+      sub.remove();
+      c.destroy();
+      setClient((cur) => cur === c ? null : cur);
+    };
+  }, [projectId, environment, apiUrl, storage]);
+  const userKey = user ? JSON.stringify([user.id, user.traits ?? null, user.account ?? null]) : "";
+  const hadUser = useRef5(false);
+  useEffect7(() => {
+    if (!client) return;
+    if (user && user.id) {
+      hadUser.current = true;
+      void client.identify(user.id, user.traits, user.account);
+    } else if (hadUser.current) {
+      hadUser.current = false;
+      client.reset();
+    }
+  }, [client, userKey]);
+  return /* @__PURE__ */ jsxs9(GuidelyContext.Provider, { value: client, children: [
+    children,
+    client ? /* @__PURE__ */ jsx11(GuidelyOverlay, { client, insets, launcherOffset }) : null
+  ] });
+}
+var NOOP_RESULTS = {
+  init: Promise.resolve(),
+  ready: Promise.resolve(),
+  identify: Promise.resolve(),
+  setAccount: Promise.resolve(),
+  updateTraits: Promise.resolve(),
+  refresh: Promise.resolve(),
+  startGuide: false,
+  getActiveGuide: null,
+  getGuides: [],
+  getChecklistProgress: { completedTaskIds: [], completedAt: null, dismissedAt: null },
+  getGuideState: { impressions: 0 },
+  getMessenger: null,
+  isGuideCompleted: false,
+  isClientReady: false,
+  getScreen: "",
+  on: () => {
+  },
+  subscribeUi: () => () => {
+  },
+  getState: { ready: false, destroyed: false }
+};
+var noopClient = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "options") return { projectId: "" };
+    if (typeof prop !== "string") return void 0;
+    return () => NOOP_RESULTS[prop];
+  }
+});
+function useGuidely() {
+  return useContext2(GuidelyContext) ?? noopClient;
+}
+function useGuidelyReady() {
+  const client = useContext2(GuidelyContext);
+  const [ready, setReady] = useState6(() => !!client?.isClientReady());
+  useEffect7(() => {
+    if (!client) return setReady(false);
+    setReady(client.isClientReady());
+    const off = client.on("ready", () => setReady(true));
+    void client.ready().then(() => setReady(client.isClientReady()));
+    return off;
+  }, [client]);
+  return ready;
+}
+function useGuidelyIdentify(userId, traits, account) {
+  const client = useContext2(GuidelyContext);
+  const key = JSON.stringify([userId ?? null, traits ?? null, account ?? null]);
+  useEffect7(() => {
+    if (client && userId) void client.identify(userId, traits, account);
+  }, [client, key]);
+}
+function useGuidelyEvent(event, handler) {
+  const client = useContext2(GuidelyContext);
+  const ref = useRef5(handler);
+  ref.current = handler;
+  useEffect7(() => {
+    if (!client) return;
+    return client.on(event, ((...args) => ref.current(...args)));
+  }, [client, event]);
+}
+function useGuidelyScreen(name, properties) {
+  const client = useContext2(GuidelyContext);
+  useEffect7(() => {
+    if (client && name) client.screen(name, properties);
+  }, [client, name]);
+}
+function useGuidelyNavigation(navigationRef, options = {}) {
+  const client = useContext2(GuidelyContext);
+  const nameRef = useRef5(options.screenName);
+  nameRef.current = options.screenName;
+  const report = () => {
+    const route = navigationRef.getCurrentRoute?.();
+    if (client && route?.name) client.screen(nameRef.current ? nameRef.current(route) : route.name);
+  };
+  useEffect7(report, [client]);
+  return { onReady: report, onStateChange: report };
+}
+function useUiSelector(select, fallback) {
+  const client = useContext2(GuidelyContext);
+  const selectRef = useRef5(select);
+  selectRef.current = select;
+  const [value, setValue] = useState6(() => client ? select(client) : fallback);
+  useEffect7(() => {
+    if (!client) return;
+    let last = JSON.stringify(selectRef.current(client));
+    setValue(selectRef.current(client));
+    const update = () => {
+      const next = selectRef.current(client);
+      const key = JSON.stringify(next);
+      if (key !== last) {
+        last = key;
+        setValue(next);
+      }
+    };
+    const offs = [client.subscribeUi(update), client.on("checklist:task", update), client.on("identify", update), client.on("guide:complete", update), client.on("guide:dismiss", update), client.on("ready", update)];
+    return () => offs.forEach((off) => off());
+  }, [client]);
+  return value;
+}
+function useChecklistProgress(idOrKey) {
+  return useUiSelector((c) => c.getChecklistProgress(idOrKey), { completedTaskIds: [], completedAt: null, dismissedAt: null });
+}
+function useGuideState(idOrKey) {
+  return useUiSelector(
+    (c) => {
+      const s = c.getGuideState(idOrKey);
+      return { impressions: s.impressions, completed: !!s.completedAt, dismissed: !!s.dismissedAt };
+    },
+    { impressions: 0, completed: false, dismissed: false }
+  );
+}
+function useActiveGuide() {
+  return useUiSelector((c) => c.getActiveGuide(), null);
+}
+export {
+  DEFAULT_API_URL,
+  GuidelyClient,
+  GuidelyOverlay,
+  GuidelyProvider,
+  GuidelyScreenScope,
+  GuidelyTarget,
+  Messenger,
+  SDK_NAME,
+  SDK_VERSION,
+  TargetRegistry,
+  createSseParser,
+  guidelyScreenLayout,
+  htmlToText,
+  noopClient,
+  parseHtml,
+  positionCard,
+  targetIdsFor,
+  useActiveGuide,
+  useChecklistProgress,
+  useGuideState,
+  useGuidely,
+  useGuidelyEvent,
+  useGuidelyIdentify,
+  useGuidelyNavigation,
+  useGuidelyReady,
+  useGuidelyScreen,
+  useGuidelyTarget
+};
+//# sourceMappingURL=index.js.map