@guidelytech/sdk-core 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,9 +1,23 @@
-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);
+import {
+  Emitter,
+  EventQueue,
+  KEYS,
+  areMutuallyExclusive,
+  createStorage,
+  isExclusiveGuide,
+  isFrequencyEligible,
+  isWithinSchedule,
+  readJson,
+  writeJson
+} from "./chunk-HLR3W63Z.js";
+import {
+  Api,
+  __publicField,
+  postWithRetry
+} from "./chunk-GJT7CFAC.js";
 
 // src/client.ts
-import { evaluateRules, randomId, sanitizeProperties } from "@guidelytech/shared/runtime";
+import { evaluateRules, randomId, rolloutBucket, sanitizeProperties, supportsPlatform } from "@guidelytech/shared/runtime";
 import {
   destroyHost,
   isChecklistComplete,
@@ -61,9 +75,9 @@ function captureSnapshot(doc, maskSelectors, maxBytes = MAX_SNAPSHOT_BYTES) {
     }
   }
   clone.querySelectorAll("*").forEach((el) => {
-    for (const attr of Array.from(el.attributes)) {
-      const name = attr.name.toLowerCase();
-      if (name.startsWith("on") || (name === "href" || name === "src" || name === "action") && /^\s*javascript:/i.test(attr.value)) el.removeAttribute(attr.name);
+    for (const attr2 of Array.from(el.attributes)) {
+      const name = attr2.name.toLowerCase();
+      if (name.startsWith("on") || (name === "href" || name === "src" || name === "action") && /^\s*javascript:/i.test(attr2.value)) el.removeAttribute(attr2.name);
     }
     if (el instanceof HTMLInputElement) {
       el.removeAttribute("value");
@@ -95,78 +109,6 @@ ${clone.outerHTML}`;
   return { html, url: win.location.href, title: doc.title, width: win.innerWidth, height: win.innerHeight, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-// src/storage.ts
-function memoryStore() {
-  const map = /* @__PURE__ */ new Map();
-  return { get: (k) => map.get(k) ?? null, set: (k, v) => void map.set(k, v), remove: (k) => void map.delete(k) };
-}
-function webStore(area) {
-  try {
-    if (typeof window === "undefined") return null;
-    const s = window[area];
-    if (!s) return null;
-    const probe = "__guidely_probe__";
-    s.setItem(probe, "1");
-    s.removeItem(probe);
-    return {
-      get: (k) => {
-        try {
-          return s.getItem(k);
-        } catch {
-          return null;
-        }
-      },
-      set: (k, v) => {
-        try {
-          s.setItem(k, v);
-        } catch {
-        }
-      },
-      remove: (k) => {
-        try {
-          s.removeItem(k);
-        } catch {
-        }
-      }
-    };
-  } catch {
-    return null;
-  }
-}
-function createStorage(kind = "local") {
-  if (kind === "memory") return memoryStore();
-  return webStore(kind === "local" ? "localStorage" : "sessionStorage") ?? memoryStore();
-}
-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}`
-};
-
 // src/authoring.ts
 async function loadSchemas() {
   const m = await import("@guidelytech/shared");
@@ -396,6 +338,134 @@ var AuthoringBridge = class {
   }
 };
 
+// src/autocapture.ts
+import { isGuidelyElement, isStableId } from "@guidelytech/guide-runtime";
+var INTERACTIVE_SELECTOR = "a,button,input[type=button],input[type=submit],input[type=reset],input[type=checkbox],input[type=radio],select,summary,label,[role=button],[role=link],[role=tab],[role=menuitem],[role=checkbox],[role=switch],[role=option],[onclick],[data-guidely-track]";
+var DEFAULT_MASK_SELECTORS = ["[data-guidely-mask]", ".guidely-mask"];
+var PREFERRED_ATTRS = ["data-testid", "data-test-id", "data-test", "data-cy", "data-qa", "data-guidely-track", "data-tour"];
+var NOISY_DATA_ATTR = /^data-(state|v-|react|radix|headlessui|svelte|orientation|highlighted|focus|key|index|side|align|disabled|selected|active|open|guidely-(mask|ignore|block))/i;
+function validSelectors(list) {
+  const out = [];
+  const probe = typeof document !== "undefined" ? document.createDocumentFragment() : null;
+  for (const raw of list) {
+    const s = (raw || "").trim();
+    if (!s || out.includes(s)) continue;
+    try {
+      probe?.querySelector(s);
+      out.push(s);
+    } catch {
+    }
+  }
+  return out;
+}
+function isIgnoredElement(el) {
+  return isGuidelyElement(el) || !!el.closest("[data-guidely-ignore]");
+}
+function interactiveElement(target) {
+  try {
+    return target.closest(INTERACTIVE_SELECTOR);
+  } catch {
+    return null;
+  }
+}
+function esc(value) {
+  const g = globalThis;
+  return g.CSS?.escape ? g.CSS.escape(value) : value.replace(/[^\w-]/g, (c) => `\\${c}`);
+}
+var attr = (tag, name, value) => value ? `${tag}[${name}="${value.replace(/["\\]/g, "\\$&")}"]` : `${tag}[${name}]`;
+function elementSelector(el) {
+  const tag = el.tagName.toLowerCase();
+  if (el.id && isStableId(el.id)) return `#${esc(el.id)}`;
+  for (const name of PREFERRED_ATTRS) if (el.hasAttribute(name)) return attr(tag, name, el.getAttribute(name) || "").slice(0, 300);
+  for (const a of Array.from(el.attributes)) {
+    if (a.name.startsWith("data-") && !NOISY_DATA_ATTR.test(a.name) && a.value && a.value.length <= 60) return attr(tag, a.name, a.value).slice(0, 300);
+  }
+  const label = el.getAttribute("aria-label");
+  if (label && label.length <= 80) return attr(tag, "aria-label", label).slice(0, 300);
+  const parts = [];
+  let cur = el;
+  while (cur && parts.length < 4) {
+    const t = cur.tagName.toLowerCase();
+    if (t === "html" || t === "body") break;
+    if (cur !== el && cur.id && isStableId(cur.id)) {
+      parts.unshift(`#${esc(cur.id)}`);
+      break;
+    }
+    const parent = cur.parentElement;
+    const node = cur;
+    const same = parent ? Array.from(parent.children).filter((c) => c.tagName === node.tagName) : [];
+    parts.unshift(same.length > 1 ? `${t}:nth-of-type(${same.indexOf(node) + 1})` : t);
+    cur = parent;
+  }
+  return (parts.join(" > ") || tag).slice(0, 300);
+}
+function matches(el, selector, deep) {
+  if (!selector) return false;
+  try {
+    return !!el.closest(selector) || deep && !!el.querySelector(selector);
+  } catch {
+    return false;
+  }
+}
+function elementText(el, mask, maskAll) {
+  if (maskAll || matches(el, mask, true)) return void 0;
+  const tag = el.tagName.toLowerCase();
+  let text = "";
+  if (tag === "input") {
+    if (!/^(button|submit|reset)$/i.test(el.type || "")) return void 0;
+    text = el.value;
+  } else if (tag === "select" || tag === "textarea") return void 0;
+  else text = el.innerText ?? el.textContent ?? "";
+  text = (text || el.getAttribute("aria-label") || el.getAttribute("title") || "").replace(/\s+/g, " ").trim();
+  return text ? text.slice(0, 100) : void 0;
+}
+function linkHref(el) {
+  const a = el.closest("a[href]");
+  if (!a) return void 0;
+  try {
+    const u = new URL(a.getAttribute("href") || "", location.href);
+    if (!/^https?:$/.test(u.protocol)) return void 0;
+    return u.origin === location.origin ? u.pathname : u.origin;
+  } catch {
+    return void 0;
+  }
+}
+function describeClick(el, e, opts) {
+  const props = { tag: el.tagName.toLowerCase(), selector: elementSelector(el), x: Math.round(e.pageX ?? 0) || 0, y: Math.round(e.pageY ?? 0) || 0 };
+  const text = elementText(el, opts.mask, opts.maskAll);
+  if (text) props.text = text;
+  const href = opts.collectUrls ? linkHref(el) : void 0;
+  if (href) props.href = href;
+  return props;
+}
+var RageClickDetector = class {
+  constructor(threshold = 3, windowMs = 1e3, radius = 30) {
+    __publicField(this, "threshold", threshold);
+    __publicField(this, "windowMs", windowMs);
+    __publicField(this, "radius", radius);
+    __publicField(this, "clicks", []);
+    __publicField(this, "fired", false);
+  }
+  /** Clicks in the current burst once it has fired (rage), otherwise 0. */
+  get burst() {
+    return this.fired ? this.clicks.length : 0;
+  }
+  /** Records a click; returns the click count when it completes a burst, otherwise 0. */
+  add(x, y, t) {
+    const first = this.clicks[0];
+    const last = this.clicks[this.clicks.length - 1];
+    if (!first || !last || t - last.t > this.windowMs || Math.hypot(x - first.x, y - first.y) > this.radius) {
+      this.clicks = [];
+      this.fired = false;
+    }
+    this.clicks = this.clicks.filter((c) => t - c.t <= this.windowMs);
+    this.clicks.push({ x, y, t });
+    if (this.fired || this.clicks.length < this.threshold) return 0;
+    this.fired = true;
+    return this.clicks.length;
+  }
+};
+
 // src/context.ts
 function detectDevice(ua, width) {
   const u = ua || "";
@@ -452,228 +522,153 @@ function buildContext(input) {
     audienceIds: new Set(input.audienceIds),
     now: input.now ?? /* @__PURE__ */ new Date(),
     environment: input.environment,
-    locale: input.locale ?? (typeof navigator !== "undefined" ? navigator.language : void 0)
+    locale: input.locale ?? (typeof navigator !== "undefined" ? navigator.language : void 0),
+    platform: input.platform ?? "web",
+    ...input.screen !== void 0 ? { screen: input.screen } : {},
+    ...input.appVersion !== void 0 ? { appVersion: input.appVersion } : {}
   };
 }
 
-// src/emitter.ts
-var Emitter = class {
-  constructor(onError) {
-    __publicField(this, "onError", onError);
-    __publicField(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);
+// src/heatmap.ts
+var HEATMAP_MAX_POINTS = 40;
+var HEATMAP_MAX_BYTES = 6e3;
+var HEATMAP_MAX_BINS = 60;
+var r2 = (n) => Math.round(Math.min(1, Math.max(0, n)) * 100) / 100;
+function heatmapPoint(el, e, rage) {
+  const p = { k: rage ? "r" : "c", x: Math.round(e.pageX ?? 0) || 0, y: Math.round(e.pageY ?? 0) || 0 };
+  const s = elementSelector(el).slice(0, 120);
+  if (s) p.s = s;
+  const rect = el.getBoundingClientRect();
+  if (rect.width > 0 && rect.height > 0) {
+    p.rx = r2((e.clientX - rect.left) / rect.width);
+    p.ry = r2((e.clientY - rect.top) / rect.height);
+  }
+  return p;
+}
+var selectors = /* @__PURE__ */ new WeakMap();
+var r1 = (n) => Math.round(Math.min(1, Math.max(0, n)) * 10) / 10;
+function movementBin(el, e) {
+  const p = { k: "m", x: Math.round(e.pageX ?? 0) || 0, y: Math.round(e.pageY ?? 0) || 0 };
+  let s = /^(HTML|BODY)$/.test(el.tagName) ? "" : selectors.get(el);
+  if (s === void 0) selectors.set(el, s = elementSelector(el).slice(0, 120));
+  const rect = s ? el.getBoundingClientRect() : null;
+  if (!rect || !(rect.width > 0 && rect.height > 0)) return [`${p.x >> 4},${p.y >> 4}`, p];
+  p.s = s;
+  p.rx = r1((e.clientX - rect.left) / rect.width);
+  p.ry = r1((e.clientY - rect.top) / rect.height);
+  return [`${s} ${p.rx},${p.ry}`, p];
+}
+var HeatmapBuffer = class {
+  constructor() {
+    /** The page the buffered points belong to. */
+    __publicField(this, "url", "");
+    __publicField(this, "points", []);
+    __publicField(this, "bins", /* @__PURE__ */ new Map());
+    __publicField(this, "bytes", 0);
+  }
+  /** Adds a click (`burst` > 0 marks it and the burst's previous clicks as rage); true when the batch is full. */
+  add(url, point, burst) {
+    this.url = url;
+    for (let i = Math.max(0, this.points.length - burst + 1); i < this.points.length; i++) this.points[i].k = "r";
+    this.points.push(point);
+    this.bytes += JSON.stringify(point).length + 1;
+    return this.full();
+  }
+  /** Adds a movement sample to its bin (weight +1); true when the batch is full. */
+  move(url, [key, point]) {
+    this.url = url;
+    const bin = this.bins.get(key);
+    if (bin) bin.w = (bin.w ?? 1) + 1;
+    else {
+      this.bins.set(key, point);
+      this.bytes += JSON.stringify(point).length + 8;
     }
-    set.add(cb);
-    return () => this.off(event, cb);
+    return this.full();
   }
-  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);
-      }
-    }
+  full() {
+    return this.points.length >= HEATMAP_MAX_POINTS || this.bins.size > HEATMAP_MAX_BINS || this.bytes >= HEATMAP_MAX_BYTES;
   }
-  clear() {
-    this.listeners.clear();
+  /** Empties the buffer, returning what was in it (clicks first, then movement bins). */
+  take() {
+    const points = [...this.points, ...this.bins.values()];
+    this.points = [];
+    this.bins = /* @__PURE__ */ new Map();
+    this.bytes = 0;
+    return points.length ? { url: this.url, points } : null;
   }
 };
 
-// src/frequency.ts
-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;
+// src/errors.ts
+import { parseStack } from "@guidelytech/shared/runtime";
+var MAX_FRAMES_BYTES = 6e3;
+function fitFrames(frames) {
+  const out = frames.slice(0, 30);
+  while (out.length > 1 && JSON.stringify(out).length > MAX_FRAMES_BYTES) out.pop();
+  return out;
+}
+function describe(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
   }
 }
-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 exceptionFromError(error, source, handled, fallbackType = "Error") {
+  const isError = error instanceof Error || !!error && typeof error === "object" && typeof error.message === "string" && typeof error.stack === "string";
+  const e = error;
+  return {
+    type: isError && e.name || fallbackType,
+    message: (isError ? e.message : describe(error)).slice(0, 1e3),
+    frames: isError ? fitFrames(parseStack(e.stack)) : [],
+    source,
+    handled
+  };
 }
-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 errorEventToException(e) {
+  const target = e.target;
+  if (target && typeof Element !== "undefined" && target instanceof Element) return null;
+  if (e.error != null) return exceptionFromError(e.error, "onerror", false);
+  const message = e.message || "";
+  if (!message || /^script error\.?$/i.test(message.trim())) return null;
+  const m = /^(?:Uncaught )?([A-Z]\w*(?:Error|Exception)):\s*([\s\S]*)$/.exec(message);
+  return {
+    type: m?.[1] ?? "Error",
+    message: (m?.[2] ?? message).slice(0, 1e3),
+    frames: e.filename ? [{ file: e.filename.slice(0, 500), line: e.lineno || void 0, col: e.colno || void 0 }] : [],
+    source: "onerror",
+    handled: false
+  };
 }
-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;
+function rejectionToException(e) {
+  return exceptionFromError(e.reason, "unhandledrejection", false, "UnhandledRejection");
 }
-
-// src/http.ts
-var Api = class {
-  constructor(baseUrl, key, fetchImpl) {
-    __publicField(this, "baseUrl", baseUrl);
-    __publicField(this, "key", key);
-    __publicField(this, "fetchImpl", fetchImpl);
-  }
-  url(path, params = {}) {
-    const u = new URL(`${this.baseUrl.replace(/\/$/, "")}/api/v1/sdk${path}`);
-    u.searchParams.set("key", this.key);
-    for (const [k, v] of Object.entries(params)) if (v != null) u.searchParams.set(k, v);
-    return u.toString();
-  }
-  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));
+var GUIDELY_SCRIPT = /\/guidely(-recorder)?(\.min)?\.js$/i;
+function isGuidelyException(props) {
+  if (props.message.startsWith("[Guidely]")) return true;
+  const file = props.frames[0]?.file;
+  if (!file) return false;
+  try {
+    return GUIDELY_SCRIPT.test(new URL(file).pathname);
+  } catch {
+    return GUIDELY_SCRIPT.test(file.replace(/[?#].*$/, ""));
   }
-  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;
+var ExceptionThrottle = class {
+  constructor(max = 5) {
+    __publicField(this, "max", max);
+    __publicField(this, "seen", /* @__PURE__ */ new Map());
+  }
+  allow(props) {
+    const top = props.frames[0];
+    const key = `${props.type}|${props.message}|${top ? `${top.file}:${top.line}:${top.col}` : ""}`;
+    const n = this.seen.get(key) ?? 0;
+    if (n >= this.max) return false;
+    if (this.seen.size > 500) this.seen.clear();
+    this.seen.set(key, n + 1);
+    return true;
   }
-  if (buffer.trim()) dispatch(buffer);
-}
+};
 
 // src/messenger-api.ts
 var MAX_STORED = 50;
@@ -834,124 +829,61 @@ function watchNavigation(listener, debounceMs = 50) {
   };
 }
 
-// src/queue.ts
-var EventQueue = class {
-  constructor(opts) {
-    __publicField(this, "opts", opts);
-    __publicField(this, "events", []);
-    __publicField(this, "timer", null);
-    __publicField(this, "retryTimer", null);
-    __publicField(this, "inflight", false);
-    __publicField(this, "inflightIds", /* @__PURE__ */ new Set());
-    __publicField(this, "attempt", 0);
-    __publicField(this, "destroyed", false);
-    __publicField(this, "flushIntervalMs");
-    __publicField(this, "maxQueue");
-    __publicField(this, "batchSize");
-    __publicField(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;
+// src/page-tracking.ts
+function scrollDepth() {
+  const de = document.documentElement;
+  const height = Math.max(de?.scrollHeight || 0, document.body?.scrollHeight || 0);
+  const view = window.innerHeight || de?.clientHeight || 0;
+  if (height <= 0 || height <= view) return 100;
+  const y = window.scrollY || de?.scrollTop || 0;
+  return Math.max(0, Math.min(100, Math.round((y + view) / height * 100)));
+}
+var PageTracker = class {
+  constructor() {
+    __publicField(this, "url", "");
+    __publicField(this, "visibleMs", 0);
+    __publicField(this, "visibleSince", null);
+    __publicField(this, "maxScroll", 0);
+  }
+  /** Starts measuring a new page. */
+  start(url, now = Date.now()) {
+    this.url = url;
+    this.visibleMs = 0;
+    this.visibleSince = typeof document !== "undefined" && document.visibilityState === "hidden" ? null : now;
+    this.maxScroll = 0;
+    this.measureScroll();
+  }
+  /** Pauses / resumes the visible-time clock. */
+  setHidden(hidden, now = Date.now()) {
+    if (hidden && this.visibleSince !== null) {
+      this.visibleMs += Math.max(0, now - this.visibleSince);
+      this.visibleSince = null;
+    } else if (!hidden && this.visibleSince === null) this.visibleSince = now;
+  }
+  measureScroll() {
     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();
+      this.maxScroll = Math.max(this.maxScroll, scrollDepth());
+    } catch {
     }
   }
-  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();
+  /** Final numbers for the current page. */
+  leave(now = Date.now()) {
+    this.measureScroll();
+    const running = this.visibleSince !== null ? Math.max(0, now - this.visibleSince) : 0;
+    return { url: this.url, durationMs: Math.round(this.visibleMs + running), scrollDepth: this.maxScroll };
   }
 };
 
+// src/load-recorder.ts
+var loadRecorder = async () => (await import("./recorder.js")).recorder;
+
 // src/client.ts
 var SDK_NAME = "@guidelytech/sdk-core";
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.4.0";
 var DEFAULT_API_URL = "https://api.guidely.app";
 var PAGE_SCOPED = /* @__PURE__ */ new Set(["page_load", "url_match", "element_click", "element_visible", "delay"]);
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var MAX_SESSION_EXCEPTIONS = 100;
 function isBrowser() {
   return typeof window !== "undefined" && typeof document !== "undefined";
 }
@@ -961,6 +893,9 @@ function nowIso() {
 function emptyState() {
   return { guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] };
 }
+function newSession(now = Date.now()) {
+  return { id: `s_${randomId(16)}`, startedAt: new Date(now).toISOString(), shownGuides: [], events: [], lastActivityAt: now };
+}
 var GuidelyClient = class _GuidelyClient {
   constructor(options) {
     __publicField(this, "options");
@@ -998,6 +933,19 @@ var GuidelyClient = class _GuidelyClient {
     __publicField(this, "lastAudiences", /* @__PURE__ */ new Set());
     /** Set once the app calls identify()/reset(); bootstrap then leaves identity alone instead of re-identifying. */
     __publicField(this, "identitySettled", false);
+    // Product analytics (autocapture, error tracking, session replay)
+    /** Created once the recorder chunk has loaded (it carries the replay controller). */
+    __publicField(this, "replay", null);
+    __publicField(this, "replayLoading", false);
+    __publicField(this, "pageTracker", new PageTracker());
+    __publicField(this, "rage", new RageClickDetector());
+    __publicField(this, "heatmap", new HeatmapBuffer());
+    __publicField(this, "exceptionThrottle", new ExceptionThrottle());
+    /** Exceptions seen before the config was loaded (reported once it is known whether the server accepts them). */
+    __publicField(this, "earlyExceptions", []);
+    __publicField(this, "initialPageViewSent", false);
+    __publicField(this, "pageViewUrl", null);
+    __publicField(this, "pageLeft", false);
     __publicField(this, "customListeners", /* @__PURE__ */ new Map());
     __publicField(this, "eventBus", {
       on: (name, cb) => {
@@ -1040,7 +988,7 @@ var GuidelyClient = class _GuidelyClient {
     this.state = { ...emptyState(), ...readJson(this.store, KEYS.state(this.options.projectId), {}) };
     this.user = readJson(this.store, KEYS.user(this.options.projectId), null);
     const session = readJson(this.sessionStore, KEYS.session, null);
-    this.session = session && session.id ? session : { id: `s_${randomId(16)}`, startedAt: nowIso(), shownGuides: [], events: [] };
+    this.session = session && session.id ? session : newSession();
     this.persistSession();
     this.lastUrl = location.href;
     this.lastAudiences = new Set(this.state.audienceIds);
@@ -1074,10 +1022,11 @@ var GuidelyClient = class _GuidelyClient {
     return this.init();
   }
   async bootstrap() {
+    this.wireErrorListeners();
     try {
       const cached = readJson(this.store, KEYS.config(this.options.projectId), null);
       this.etag = this.store.get(KEYS.etag(this.options.projectId));
-      if (cached && cached.guides) this.config = cached;
+      if (cached && cached.guides) this.config = webOnly(cached);
       await this.fetchConfig();
       if (this.destroyed) return;
       this.wireListeners();
@@ -1093,6 +1042,9 @@ var GuidelyClient = class _GuidelyClient {
       this.resumeActiveGuide();
       this.evaluate("ready");
       if (!this.options.disableAuthoring) this.maybeStartAuthoring();
+      this.pageTracker.start(location.href);
+      this.touchSession();
+      this.syncCapture();
     } catch (err) {
       this.reportError(err);
       this.isReady = true;
@@ -1101,10 +1053,10 @@ var GuidelyClient = class _GuidelyClient {
   }
   async fetchConfig() {
     try {
-      const res = await this.api.get("/config", { etag: this.etag });
+      const res = await this.api.get("/config", { etag: this.etag, params: { platform: "web" } });
       if (res.status === 304) return true;
       if (res.ok && res.data && Array.isArray(res.data.guides)) {
-        this.config = res.data;
+        this.config = webOnly(res.data);
         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);
@@ -1127,14 +1079,62 @@ var GuidelyClient = class _GuidelyClient {
     const onClick = (e) => this.handleDocumentClick(e);
     doc.addEventListener("click", onClick, true);
     this.cleanups.push(() => doc.removeEventListener("click", onClick, true));
-    const onHide = () => {
-      if (doc.visibilityState === "hidden") this.queue.flushSync();
+    const onVisibility = () => {
+      const hidden = doc.visibilityState === "hidden";
+      this.pageTracker.setHidden(hidden);
+      if (!hidden) return;
+      this.replay?.flushOnHide();
+      this.queue.flushSync();
+    };
+    const onPageHide = () => {
+      this.flushHeatmap();
+      if (!this.pageLeft) this.leavePage(null);
+      this.pageLeft = true;
+      this.replay?.flushOnHide();
+      this.queue.flushSync();
+    };
+    const onPageShow = (e) => {
+      if (!e.persisted || !this.pageLeft) return;
+      this.pageLeft = false;
+      this.pageTracker.start(location.href);
     };
-    doc.addEventListener("visibilitychange", onHide);
-    win.addEventListener("pagehide", onHide);
+    let lastScroll = 0;
+    const onScroll = () => {
+      const now = Date.now();
+      if (now - lastScroll < 250) return;
+      lastScroll = now;
+      this.pageTracker.measureScroll();
+      this.touchSession();
+    };
+    const onKey = () => this.touchSession();
+    let move = null;
+    let moveTimer = null;
+    const onMove = (e) => {
+      move = e;
+      moveTimer ?? (moveTimer = setTimeout(() => {
+        moveTimer = null;
+        if (move) this.sampleMove(move);
+        move = null;
+      }, 200));
+    };
+    if (win.matchMedia?.("(pointer: fine)").matches) {
+      doc.addEventListener("mousemove", onMove, { passive: true });
+      this.cleanups.push(() => {
+        doc.removeEventListener("mousemove", onMove);
+        if (moveTimer) clearTimeout(moveTimer);
+      });
+    }
+    doc.addEventListener("visibilitychange", onVisibility);
+    win.addEventListener("pagehide", onPageHide);
+    win.addEventListener("pageshow", onPageShow);
+    win.addEventListener("scroll", onScroll, { passive: true });
+    doc.addEventListener("keydown", onKey, true);
     this.cleanups.push(() => {
-      doc.removeEventListener("visibilitychange", onHide);
-      win.removeEventListener("pagehide", onHide);
+      doc.removeEventListener("visibilitychange", onVisibility);
+      win.removeEventListener("pagehide", onPageHide);
+      win.removeEventListener("pageshow", onPageShow);
+      win.removeEventListener("scroll", onScroll);
+      doc.removeEventListener("keydown", onKey, true);
     });
     const refresh = setInterval(() => void this.refresh(), this.options.configRefreshMs);
     this.cleanups.push(() => clearInterval(refresh));
@@ -1152,6 +1152,18 @@ var GuidelyClient = class _GuidelyClient {
     win.addEventListener("message", onMessage);
     this.cleanups.push(() => win.removeEventListener("message", onMessage));
   }
+  /** Uncaught errors + unhandled rejections; attached before the config loads so boot errors are kept. */
+  wireErrorListeners() {
+    const win = window;
+    const onError = (e) => this.captureGlobalException(errorEventToException(e));
+    const onRejection = (e) => this.captureGlobalException(rejectionToException(e));
+    win.addEventListener("error", onError);
+    win.addEventListener("unhandledrejection", onRejection);
+    this.cleanups.push(() => {
+      win.removeEventListener("error", onError);
+      win.removeEventListener("unhandledrejection", onRejection);
+    });
+  }
   /** Re-fetches the published config and re-evaluates triggers. */
   async refresh() {
     if (this.destroyed) return;
@@ -1161,6 +1173,7 @@ var GuidelyClient = class _GuidelyClient {
       this.renderPersistentWidgets();
       this.evaluate("ready");
     }
+    this.syncCapture();
   }
   /** Tears everything down: guides, widgets, listeners, timers, host element. Re-init is allowed via a new client. */
   destroy() {
@@ -1184,6 +1197,8 @@ var GuidelyClient = class _GuidelyClient {
     this.cleanups.splice(0).forEach((fn) => fn());
     this.authoring?.stop();
     this.authoring = null;
+    this.replay?.destroy();
+    this.replay = null;
     this.queue.flushSync();
     this.queue.destroy();
     this.emitter.clear();
@@ -1270,9 +1285,11 @@ var GuidelyClient = class _GuidelyClient {
     this.store.set(KEYS.anon, this.anonymousId);
     this.state = emptyState();
     this.persistState();
-    this.session = { id: `s_${randomId(16)}`, startedAt: nowIso(), shownGuides: [], events: [] };
+    this.session = newSession();
     this.persistSession();
     this.sessionStore.remove(KEYS.active);
+    this.replay?.stop();
+    this.syncCapture();
     this.lastAudiences = /* @__PURE__ */ new Set();
     this.firedDelays.clear();
     this.widgets.forEach((w) => w.destroy());
@@ -1293,6 +1310,8 @@ var GuidelyClient = class _GuidelyClient {
     this.consent = consent;
     if (consent === "denied") this.queue.clear();
     else if (consent === "granted") void this.queue.flush();
+    if (consent !== "granted") this.replay?.stop({ discard: true });
+    this.syncCapture();
   }
   analyticsEnabled() {
     return this.options.analytics && this.consent === "granted" && (this.config?.settings?.analyticsEnabled ?? true);
@@ -1302,6 +1321,7 @@ var GuidelyClient = class _GuidelyClient {
   }
   enqueue(name, extra = {}) {
     if (this.consent === "denied" || !this.options.analytics) return null;
+    if (name !== "page_leave" && name !== "heatmap") this.touchSession();
     const event = {
       eventId: randomId(24),
       name,
@@ -1315,6 +1335,7 @@ var GuidelyClient = class _GuidelyClient {
     };
     if (extra.properties) event.properties = sanitizeProperties(extra.properties);
     this.queue.enqueue(event);
+    this.replay?.addCustomEvent("guidely", { name, customName: event.customName, guideId: event.guideId });
     this.emitter.emit("track", event);
     return event;
   }
@@ -1339,14 +1360,18 @@ var GuidelyClient = class _GuidelyClient {
   /** Records a page view and re-evaluates triggers. Called automatically on SPA navigation. */
   page(url = location.href) {
     if (this.destroyed) return;
-    this.enqueue("page_view", { properties: { path: safePath(url) } });
+    this.leavePage(url);
+    this.trackPageView(url);
     this.handleNavigation(url, true);
   }
   handleNavigation(url, explicit = false) {
     if (this.destroyed) return;
     const changed = url !== this.lastUrl;
     this.lastUrl = url;
-    if (!explicit && changed) this.enqueue("page_view", { properties: { path: safePath(url) } });
+    if (!explicit && changed) {
+      this.leavePage(url);
+      this.trackPageView(url);
+    }
     this.completeChecklistTasksBy("url_visited", url);
     this.active?.controller?.resume();
     if (this.active?.controller) {
@@ -1356,6 +1381,11 @@ var GuidelyClient = class _GuidelyClient {
         if (g.config.urlPatterns.length && !g.config.urlPatterns.some((p) => urlMatches(p, url))) this.active.controller.destroy();
       }
     }
+    this.widgets.forEach((w, id) => {
+      if (!w.controller || w.manual) return;
+      const g = this.findGuide(id);
+      if (g?.config.urlPatterns.length && !g.config.urlPatterns.some((p) => urlMatches(p, url))) w.controller.destroy();
+    });
     this.firedDelays.clear();
     if (this.isReady) this.evaluate("navigation");
     if (changed) void this.queue.flush();
@@ -1363,10 +1393,255 @@ var GuidelyClient = class _GuidelyClient {
   handleDocumentClick(e) {
     const target = e.target;
     if (!target || typeof target.closest !== "function") return;
+    this.autocaptureClick(e, target);
     this.completeChecklistTasksBy("click", target);
     if (this.isReady) this.evaluate("click", { target });
   }
   // ---------------------------------------------------------------------------
+  // Product analytics: sessions, page views, clicks, errors, session replay
+  // ---------------------------------------------------------------------------
+  /** Records activity; starts a new session after `sessionTimeoutMinutes` of inactivity or 24h. */
+  touchSession() {
+    const now = Date.now();
+    const s = this.session;
+    const timeout = Math.max(1, this.config?.settings?.sessionTimeoutMinutes ?? 30) * 6e4;
+    const last = s.lastActivityAt ?? now;
+    if (now - last > timeout || now - (Date.parse(s.startedAt) || now) > DAY_MS) return this.rotateSession(now);
+    if (now - (s.lastActivityAt ?? 0) < 1e3) return;
+    s.lastActivityAt = now;
+    this.persistSession();
+  }
+  rotateSession(now) {
+    this.session = newSession(now);
+    this.persistSession();
+    this.log("session rotated", this.session.id);
+    if (this.replay?.activeSessionId) this.replay.stop();
+    this.syncReplay();
+  }
+  /** Autocapture, error tracking and replay need analytics on, consent granted and no authoring session. */
+  captureAllowed() {
+    return !this.destroyed && this.analyticsEnabled() && !this.authoring?.isActive();
+  }
+  /** A capability is on when the project enables it (absent on old servers → off) and no option turns it off. */
+  autocaptureOn(key) {
+    const o = this.options.autocapture;
+    return !!this.config?.settings?.autocapture?.[key] && o !== false && !(typeof o === "object" && o[key] === false) && this.captureAllowed();
+  }
+  /** Page views on SPA navigation predate autocapture: only an explicit opt-out stops them. */
+  pageviewsOn() {
+    const o = this.options.autocapture;
+    return this.config?.settings?.autocapture?.pageviews !== false && o !== false && !(typeof o === "object" && o.pageviews === false) && !this.authoring?.isActive();
+  }
+  trackPageView(url) {
+    if (url === this.pageViewUrl || !this.pageviewsOn()) return;
+    this.pageViewUrl = url;
+    this.touchSession();
+    const collect = this.collectUrls();
+    const device = detectDevice(navigator.userAgent, window.innerWidth);
+    const props = { deviceType: device.type, browser: device.browser, os: device.os, screenWidth: window.screen?.width, viewportWidth: window.innerWidth };
+    if (collect) {
+      props.path = pathOf(url);
+      props.title = (document.title || "").slice(0, 200);
+      const ref = !this.session.pageViews ? externalReferrer() : void 0;
+      if (ref) props.referrer = ref;
+    }
+    this.session.pageViews = (this.session.pageViews ?? 0) + 1;
+    this.persistSession();
+    this.enqueue("page_view", { url: collect ? url : void 0, properties: props });
+  }
+  /** Emits `page_leave` for the page being left and starts measuring `nextUrl` (null: page unload). */
+  leavePage(nextUrl) {
+    const t = this.pageTracker;
+    if (!t.url || t.url === nextUrl) return;
+    this.flushHeatmap();
+    if (!this.pageLeft && this.autocaptureOn("pageLeave")) {
+      const info = t.leave();
+      const collect = this.collectUrls();
+      this.enqueue("page_leave", { url: collect ? info.url : void 0, properties: { ...collect ? { path: pathOf(info.url) } : {}, durationMs: info.durationMs, scrollDepth: info.scrollDepth } });
+    }
+    if (nextUrl !== null) {
+      t.start(nextUrl);
+      this.pageLeft = false;
+    }
+  }
+  autocaptureClick(e, target) {
+    const clicks = this.autocaptureOn("clicks");
+    const rage = this.autocaptureOn("rageClicks");
+    const heat = this.autocaptureOn("heatmaps");
+    if (!clicks && !rage && !heat || isIgnoredElement(target)) return;
+    this.touchSession();
+    const el = interactiveElement(target);
+    const opts = { mask: this.maskSelector(), maskAll: this.maskAllText(), collectUrls: this.collectUrls() };
+    if (clicks && el) this.enqueue("click", { properties: { ...describeClick(el, e, opts) } });
+    const count = this.rage.add(e.pageX ?? 0, e.pageY ?? 0, Date.now());
+    if (rage && count) this.enqueue("rage_click", { properties: { ...describeClick(el ?? target, e, opts), count } });
+    if (!heat) return;
+    const url = location.href;
+    if (this.heatmap.url !== url) this.flushHeatmap();
+    if (this.heatmap.add(url, heatmapPoint(el ?? target, e, this.rage.burst > 0), this.rage.burst)) this.flushHeatmap();
+  }
+  /** Bins one pointer sample into the heatmap buffer. Not session activity. */
+  sampleMove(e) {
+    const target = e.target;
+    if (document.visibilityState === "hidden" || !target?.closest || !this.autocaptureOn("mouseMovement") || isIgnoredElement(target)) return;
+    const url = location.href;
+    if (this.heatmap.url !== url) this.flushHeatmap();
+    if (this.heatmap.move(url, movementBin(interactiveElement(target) ?? target, e))) this.flushHeatmap();
+  }
+  /** Sends the buffered heatmap clicks as one `heatmap` event attributed to the page they happened on. */
+  flushHeatmap() {
+    const batch = this.heatmap.take();
+    if (!batch || !this.captureAllowed()) return;
+    const collect = this.collectUrls();
+    const de = document.documentElement;
+    const properties = { path: collect ? pathOf(batch.url) : void 0, viewportWidth: window.innerWidth, viewportHeight: window.innerHeight, pageHeight: Math.max(de.scrollHeight, document.body?.scrollHeight || 0), points: batch.points };
+    if (!collect) delete properties.path;
+    this.enqueue("heatmap", { url: collect ? batch.url : void 0, properties });
+  }
+  captureGlobalException(props) {
+    if (!props || isGuidelyException(props) || this.options.captureErrors === false) return;
+    if (!this.config) {
+      if (this.earlyExceptions.length < 10) this.earlyExceptions.push([props, void 0]);
+      return;
+    }
+    this.sendException(props);
+  }
+  /**
+   * Reports a caught error as an `exception` event (`source: "manual"`, `handled: true`), grouped
+   * into an issue on the Errors page. Extra properties are attached to the occurrence. Needs the
+   * project's error tracking on (plus analytics + consent); `captureErrors: false` does not stop it.
+   */
+  captureException(error, properties) {
+    if (this.destroyed) return;
+    const props = exceptionFromError(error, "manual", true);
+    if (!this.config) {
+      if (this.earlyExceptions.length < 10) this.earlyExceptions.push([props, properties]);
+      return;
+    }
+    this.sendException(props, properties);
+  }
+  sendException(props, extra) {
+    if (!this.config?.settings?.errorTracking?.enabled || !this.captureAllowed() || !this.exceptionThrottle.allow(props)) return;
+    const count = this.session.exceptions ?? 0;
+    if (count >= MAX_SESSION_EXCEPTIONS) return;
+    const properties = { ...props };
+    if (this.options.release) properties.release = String(this.options.release).slice(0, 100);
+    for (const [k, v] of Object.entries(extra ?? {})) if (!(k in properties)) properties[k] = v;
+    this.enqueue("exception", { properties });
+    this.session.exceptions = count + 1;
+    this.persistSession();
+  }
+  maskSelector() {
+    return validSelectors([...DEFAULT_MASK_SELECTORS, ...this.config?.settings?.maskSelectors || [], ...this.options.maskSelectors || []]).join(",");
+  }
+  maskAllText() {
+    const o = this.options.sessionReplay;
+    return !!this.config?.settings?.replay?.maskAllText || typeof o === "object" && !!o.maskAllText;
+  }
+  /** Replay settings for this installation, or null when the project (or an option) disables replay. */
+  replayConfig() {
+    const r = this.config?.settings?.replay;
+    const o = this.options.sessionReplay;
+    if (!r?.enabled || o === false) return null;
+    const opt = typeof o === "object" ? o : {};
+    const extra = opt.blockSelectors || [];
+    return {
+      sampleRate: r.sampleRate ?? 100,
+      config: {
+        recordConsole: r.recordConsole !== false,
+        maskTextSelector: this.maskAllText() ? "*" : this.maskSelector(),
+        blockSelector: validSelectors(["[data-guidely-block]", ...r.blockSelectors || [], ...extra]).join(","),
+        network: r.recordNetwork && opt.recordNetwork !== false ? { payloads: !!r.recordNetworkPayloads && opt.recordNetworkPayloads !== false, apiUrl: this.options.apiUrl, mask: opt.maskNetworkRequest } : null
+      }
+    };
+  }
+  /** Reconciles capture with the current config / consent / authoring state. Idempotent. */
+  syncCapture() {
+    if (!this.isReady || this.destroyed) return;
+    if (this.config && !this.initialPageViewSent && this.config.settings?.autocapture) {
+      this.initialPageViewSent = true;
+      this.trackPageView(location.href);
+    }
+    if (this.config) {
+      for (const [props, extra] of this.earlyExceptions.splice(0)) {
+        if (props.handled) this.sendException(props, extra);
+        else this.captureGlobalException(props);
+      }
+    }
+    this.syncReplay();
+  }
+  syncReplay() {
+    const cfg = this.isReady && this.captureAllowed() ? this.replayConfig() : null;
+    if (cfg && this.session.replay === void 0) {
+      this.session.replay = rolloutBucket(this.session.id, "replay") < cfg.sampleRate;
+      this.persistSession();
+    }
+    if (!cfg || !this.session.replay) {
+      if (this.replay?.activeSessionId) this.replay.stop({ discard: !this.analyticsEnabled() });
+      return;
+    }
+    if (this.replay) return this.replay.start(this.session.id, cfg.config);
+    if (this.replayLoading) return;
+    this.replayLoading = true;
+    loadRecorder().then(
+      (api) => {
+        this.replayLoading = false;
+        if (this.destroyed || this.replay) return;
+        this.replay = api.createReplay({
+          url: (params) => this.api.url("/replay", params),
+          fetch: () => this.options.fetch ?? (typeof fetch === "function" ? fetch.bind(globalThis) : null),
+          meta: () => {
+            const device = detectDevice(navigator.userAgent, window.innerWidth);
+            return {
+              anonymousId: this.anonymousId,
+              userId: this.user?.id || null,
+              url: this.collectUrls() ? location.href : void 0,
+              device: { type: device.type, browser: device.browser, os: device.os },
+              viewport: { width: window.innerWidth, height: window.innerHeight },
+              sdk: { name: SDK_NAME, version: SDK_VERSION }
+            };
+          },
+          onDisabled: (sessionId) => {
+            if (sessionId !== this.session.id) return;
+            this.session.replay = false;
+            this.persistSession();
+            this.replay?.stop({ discard: true });
+          },
+          onError: (err) => this.reportError(err)
+        });
+        this.syncReplay();
+      },
+      (err) => {
+        this.replayLoading = false;
+        this.reportError(err);
+      }
+    );
+  }
+  /**
+   * Records this session even when it was not sampled, provided the project has session replay
+   * enabled (and analytics + consent allow it). The decision sticks for the rest of the session.
+   */
+  startSessionRecording() {
+    if (this.destroyed) return;
+    this.session.replay = true;
+    this.persistSession();
+    this.syncReplay();
+  }
+  /** Stops recording for the rest of this session (what was recorded so far is uploaded). */
+  stopSessionRecording() {
+    this.session.replay = false;
+    this.persistSession();
+    this.replay?.stop();
+  }
+  /** True while the session is being recorded. */
+  isRecording() {
+    return !!this.replay?.isRecording();
+  }
+  /** The current analytics session id (rotates after inactivity; also the replay id). */
+  getSessionId() {
+    return this.session.id;
+  }
+  // ---------------------------------------------------------------------------
   // Targeting + triggers
   // ---------------------------------------------------------------------------
   /** Builds the targeting context for the current moment. */
@@ -1387,7 +1662,8 @@ var GuidelyClient = class _GuidelyClient {
       seenGuides: keysOf(Object.keys(guides).filter((id) => (guides[id]?.impressions ?? 0) > 0)),
       completedChecklists: keysOf(completedChecklists),
       audienceIds: this.state.audienceIds,
-      environment: this.options.environment
+      environment: this.options.environment,
+      platform: "web"
     });
   }
   isTargeted(guide, ctx, url) {
@@ -1412,6 +1688,7 @@ var GuidelyClient = class _GuidelyClient {
     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") && urlMatches(t.value, location.href);
@@ -1632,7 +1909,7 @@ var GuidelyClient = class _GuidelyClient {
     });
     entry.controller = controller;
     if (exclusive) this.active = entry;
-    else this.widgets.set(guide.id, { destroy: () => controller.destroy(), controller });
+    else this.widgets.set(guide.id, { destroy: () => controller.destroy(), controller, manual });
     controller.start();
     if (controller.getState().status === "ended") {
       if (exclusive && this.active === entry) this.active = null;
@@ -2026,6 +2303,8 @@ var GuidelyClient = class _GuidelyClient {
         onError: (err) => this.reportError(err),
         onActive: (active) => {
           this.emitter.emit("authoring", { active });
+          if (active) this.replay?.stop({ discard: true });
+          else this.syncCapture();
           if (active) {
             this.stopGuide();
             this.widgets.forEach((w) => w.destroy());
@@ -2076,12 +2355,23 @@ var GuidelyClient = class _GuidelyClient {
   }
 };
 var current = null;
-function safePath(url) {
+function webOnly(config) {
+  return config.guides.every((g) => supportsPlatform(g.config, "web")) ? config : { ...config, guides: config.guides.filter((g) => supportsPlatform(g.config, "web")) };
+}
+function pathOf(url) {
+  try {
+    return new URL(url, "http://localhost").pathname;
+  } catch {
+    return url.replace(/[?#].*$/, "");
+  }
+}
+function externalReferrer() {
   try {
-    const u = new URL(url, "http://localhost");
-    return u.pathname + u.search;
+    if (!document.referrer) return void 0;
+    const u = new URL(document.referrer);
+    return u.origin === location.origin ? void 0 : u.origin + u.pathname;
   } catch {
-    return url;
+    return void 0;
   }
 }
 function createGuidely(options) {