@guidelytech/sdk-core 0.2.1 → 0.4.1

package/dist/index.cjs

@@ -56,9 +56,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_runtime6 = require("@guidelytech/shared/runtime");
-var import_guide_runtime2 = require("@guidelytech/guide-runtime");
+var import_runtime11 = require("@guidelytech/shared/runtime");
 var import_guide_runtime3 = require("@guidelytech/guide-runtime");
+var import_guide_runtime4 = require("@guidelytech/guide-runtime");
 
 // src/authoring.ts
 var import_guide_runtime = require("@guidelytech/guide-runtime");
@@ -105,9 +105,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");
@@ -440,6 +440,134 @@ var AuthoringBridge = class {
   }
 };
 
+// src/autocapture.ts
+var import_guide_runtime2 = require("@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 (0, import_guide_runtime2.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 && (0, import_guide_runtime2.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 && (0, import_guide_runtime2.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 || "";
@@ -496,9 +624,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/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;
+    }
+    return this.full();
+  }
+  full() {
+    return this.points.length >= HEATMAP_MAX_POINTS || this.bins.size > HEATMAP_MAX_BINS || this.bytes >= HEATMAP_MAX_BYTES;
+  }
+  /** 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/errors.ts
+var import_runtime4 = require("@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 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((0, import_runtime4.parseStack)(e.stack)) : [],
+    source,
+    handled
   };
 }
+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 rejectionToException(e) {
+  return exceptionFromError(e.reason, "unhandledrejection", false, "UnhandledRejection");
+}
+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(/[?#].*$/, ""));
+  }
+}
+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;
+  }
+};
 
 // src/emitter.ts
 var Emitter = class {
@@ -586,10 +858,8 @@ var Api = class {
     __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();
+    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;
@@ -878,6 +1148,51 @@ function watchNavigation(listener, debounceMs = 50) {
   };
 }
 
+// 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 {
+      this.maxScroll = Math.max(this.maxScroll, scrollDepth());
+    } catch {
+    }
+  }
+  /** 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/queue.ts
 var EventQueue = class {
   constructor(opts) {
@@ -991,11 +1306,16 @@ var EventQueue = class {
   }
 };
 
+// src/load-recorder.ts
+var loadRecorder = async () => (await import("./recorder.cjs")).recorder;
+
 // src/client.ts
 var SDK_NAME = "@guidelytech/sdk-core";
-var SDK_VERSION = "0.2.1";
+var SDK_VERSION = "0.4.1";
 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";
 }
@@ -1005,6 +1325,9 @@ function nowIso() {
 function emptyState() {
   return { guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] };
 }
+function newSession(now = Date.now()) {
+  return { id: `s_${(0, import_runtime11.randomId)(16)}`, startedAt: new Date(now).toISOString(), shownGuides: [], events: [], lastActivityAt: now };
+}
 var GuidelyClient = class _GuidelyClient {
   constructor(options) {
     __publicField(this, "options");
@@ -1042,6 +1365,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) => {
@@ -1076,7 +1412,7 @@ var GuidelyClient = class _GuidelyClient {
     this.sessionStore = this.options.storage === "memory" ? this.store : createStorage("session");
     this.anonymousId = this.store.get(KEYS.anon) || "";
     if (!this.anonymousId) {
-      this.anonymousId = `anon_${(0, import_runtime6.randomId)(20)}`;
+      this.anonymousId = `anon_${(0, import_runtime11.randomId)(20)}`;
       this.store.set(KEYS.anon, this.anonymousId);
     }
     this.firstVisit = !this.store.get(KEYS.seen);
@@ -1084,7 +1420,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_${(0, import_runtime6.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);
@@ -1118,10 +1454,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();
@@ -1137,6 +1474,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;
@@ -1145,10 +1485,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);
@@ -1171,14 +1511,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));
@@ -1196,6 +1584,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;
@@ -1205,6 +1605,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() {
@@ -1228,10 +1629,12 @@ 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();
-    (0, import_guide_runtime2.destroyHost)();
+    (0, import_guide_runtime3.destroyHost)();
     if (current === this) current = null;
   }
   // ---------------------------------------------------------------------------
@@ -1243,7 +1646,7 @@ var GuidelyClient = class _GuidelyClient {
     this.identitySettled = true;
     this.user = { id: String(userId), traits: { ...this.user?.id === String(userId) ? this.user.traits : {}, ...traits || {} }, account: account ?? (this.user?.id === String(userId) ? this.user.account : void 0) };
     writeJson(this.store, KEYS.user(this.options.projectId), this.user);
-    this.enqueue("identify", { properties: { traits: (0, import_runtime6.sanitizeProperties)(this.user.traits) } });
+    this.enqueue("identify", { properties: { traits: (0, import_runtime11.sanitizeProperties)(this.user.traits) } });
     await this.syncIdentify();
     this.emitter.emit("identify", { userId: this.user.id, anonymousId: this.anonymousId });
     if (this.isReady) this.evaluate("identify");
@@ -1310,13 +1713,15 @@ var GuidelyClient = class _GuidelyClient {
     this.stopGuide();
     this.user = null;
     this.store.remove(KEYS.user(this.options.projectId));
-    this.anonymousId = `anon_${(0, import_runtime6.randomId)(20)}`;
+    this.anonymousId = `anon_${(0, import_runtime11.randomId)(20)}`;
     this.store.set(KEYS.anon, this.anonymousId);
     this.state = emptyState();
     this.persistState();
-    this.session = { id: `s_${(0, import_runtime6.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());
@@ -1337,6 +1742,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);
@@ -1346,8 +1753,9 @@ 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: (0, import_runtime6.randomId)(24),
+      eventId: (0, import_runtime11.randomId)(24),
       name,
       occurredAt: nowIso(),
       anonymousId: this.anonymousId,
@@ -1357,8 +1765,9 @@ var GuidelyClient = class _GuidelyClient {
       url: this.collectUrls() ? location.href : void 0,
       ...extra
     };
-    if (extra.properties) event.properties = (0, import_runtime6.sanitizeProperties)(extra.properties);
+    if (extra.properties) event.properties = (0, import_runtime11.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;
   }
@@ -1383,23 +1792,32 @@ 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) {
       const st = this.active.controller.getState();
       if (st.status === "running" && !this.active.manual) {
         const g = this.active.guide;
-        if (g.config.urlPatterns.length && !g.config.urlPatterns.some((p) => (0, import_guide_runtime2.urlMatches)(p, url))) this.active.controller.destroy();
+        if (g.config.urlPatterns.length && !g.config.urlPatterns.some((p) => (0, import_guide_runtime3.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) => (0, import_guide_runtime3.urlMatches)(p, url))) w.controller.destroy();
+    });
     this.firedDelays.clear();
     if (this.isReady) this.evaluate("navigation");
     if (changed) void this.queue.flush();
@@ -1407,10 +1825,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 = (0, import_runtime11.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. */
@@ -1431,17 +2094,18 @@ 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) {
     const c = guide.config;
-    if (c.urlPatterns.length && !c.urlPatterns.some((p) => (0, import_guide_runtime2.urlMatches)(p, url))) return false;
-    if (c.trigger.urlPattern && !(0, import_guide_runtime2.urlMatches)(c.trigger.urlPattern, url)) return false;
+    if (c.urlPatterns.length && !c.urlPatterns.some((p) => (0, import_guide_runtime3.urlMatches)(p, url))) return false;
+    if (c.trigger.urlPattern && !(0, import_guide_runtime3.urlMatches)(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 (0, import_runtime6.evaluateRules)(c.targeting, ctx);
+    return (0, import_runtime11.evaluateRules)(c.targeting, ctx);
   }
   isEligible(guide, ctx, url) {
     if (!this.isTargeted(guide, ctx, url)) return false;
@@ -1456,9 +2120,10 @@ 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") && (0, import_guide_runtime2.urlMatches)(t.value, location.href);
+        return (reason === "ready" || reason === "navigation" || reason === "identify") && (0, import_guide_runtime3.urlMatches)(t.value, location.href);
       case "event":
         return reason === "event" && !!t.value && detail.eventName === t.value;
       case "element_click":
@@ -1534,7 +2199,7 @@ var GuidelyClient = class _GuidelyClient {
       this.visibilityObservers.delete(guide.id);
     };
     this.visibilityObservers.set(guide.id, stop);
-    (0, import_guide_runtime2.waitForTarget)([{ kind: "css", value: selector }], { timeoutMs: 0, signal: ac.signal }).then((el) => {
+    (0, import_guide_runtime3.waitForTarget)([{ kind: "css", value: selector }], { timeoutMs: 0, signal: ac.signal }).then((el) => {
       if (ac.signal.aborted) return;
       const fire = () => {
         stop();
@@ -1630,7 +2295,7 @@ var GuidelyClient = class _GuidelyClient {
     if (this.authoring?.isActive()) return;
     const exclusive = isExclusiveGuide(guide);
     const entry = { guide, manual, startUrl: location.href };
-    const controller = (0, import_guide_runtime2.runGuide)(guide, {
+    const controller = (0, import_guide_runtime3.runGuide)(guide, {
       theme: this.theme(),
       ctx: () => this.getContext(),
       startAtStep: stepId,
@@ -1676,7 +2341,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;
@@ -1687,10 +2352,10 @@ var GuidelyClient = class _GuidelyClient {
     if (this.authoring?.isActive()) return;
     const config = guide.config.checklist;
     if (!config || this.widgets.has(guide.id)) return;
-    const scope = (0, import_guide_runtime3.createScope)(this.theme(), guide.config.appearance);
+    const scope = (0, import_guide_runtime4.createScope)(this.theme(), guide.config.appearance);
     const progress = this.getChecklistProgress(guide.id);
     const first = !this.state.guides[guide.id]?.impressions;
-    const widget = (0, import_guide_runtime2.renderChecklist)({
+    const widget = (0, import_guide_runtime3.renderChecklist)({
       scope: scope.el,
       config,
       progress,
@@ -1709,7 +2374,7 @@ var GuidelyClient = class _GuidelyClient {
     if (this.authoring?.isActive()) return;
     const config = guide.config.survey;
     if (!config) return;
-    const scope = (0, import_guide_runtime3.createScope)(this.theme(), guide.config.appearance);
+    const scope = (0, import_guide_runtime4.createScope)(this.theme(), guide.config.appearance);
     const entry = { guide, manual, startUrl: location.href, scope };
     const finish = (reason) => {
       widget.destroy();
@@ -1722,13 +2387,13 @@ var GuidelyClient = class _GuidelyClient {
       }
       this.setTimer(() => this.evaluate("after_guide", { endedGuide: guide }), 0);
     };
-    const widget = (0, import_guide_runtime2.renderSurvey)({
+    const widget = (0, import_guide_runtime3.renderSurvey)({
       scope: scope.el,
       config,
       title: guide.name,
       onDismiss: () => finish(this.state.surveysSubmitted.includes(guide.id) ? "submitted" : "dismissed"),
       onSubmit: (answers) => {
-        const responseId = (0, import_runtime6.randomId)(24);
+        const responseId = (0, import_runtime11.randomId)(24);
         this.state.surveysSubmitted.push(guide.id);
         this.persistState();
         this.recordEnd(guide, "completed");
@@ -1770,9 +2435,9 @@ var GuidelyClient = class _GuidelyClient {
     }
     this.destroyMessenger();
     if (rc && rc.enabled && !this.resourceCenter) {
-      const scope = (0, import_guide_runtime3.createScope)(this.theme());
+      const scope = (0, import_guide_runtime4.createScope)(this.theme());
       this.resourceCenterScope = scope;
-      this.resourceCenter = (0, import_guide_runtime2.renderResourceCenter)({
+      this.resourceCenter = (0, import_guide_runtime3.renderResourceCenter)({
         scope: scope.el,
         config: rc,
         guides: this.config.guides.map((g) => ({ id: g.id, key: g.key, name: g.name, kind: g.kind })),
@@ -1807,7 +2472,7 @@ var GuidelyClient = class _GuidelyClient {
     this.messengerLoading = import("@guidelytech/guide-runtime/messenger").then(({ renderMessenger }) => {
       const cfg = this.config?.messenger;
       if (this.destroyed || !this.config || !cfg?.enabled || this.messenger) return this.messenger;
-      const scope = (0, import_guide_runtime3.createScope)(this.theme());
+      const scope = (0, import_guide_runtime4.createScope)(this.theme());
       this.messengerScope = scope;
       this.messenger = renderMessenger({
         scope: scope.el,
@@ -1886,7 +2551,7 @@ var GuidelyClient = class _GuidelyClient {
     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 = (0, import_guide_runtime2.isChecklistComplete)(config, progress) && !progress.completedAt;
+    const complete = (0, import_guide_runtime3.isChecklistComplete)(config, progress) && !progress.completedAt;
     if (complete) {
       progress.completedAt = nowIso();
       this.enqueue("checklist_completed", { guideId: guide.id, guideVersion: guide.version });
@@ -1909,7 +2574,7 @@ var GuidelyClient = class _GuidelyClient {
         if (task.completion !== kind || !task.completionValue) continue;
         let hit = false;
         if (kind === "event") hit = value === task.completionValue;
-        else if (kind === "url_visited") hit = (0, import_guide_runtime2.urlMatches)(task.completionValue, value);
+        else if (kind === "url_visited") hit = (0, import_guide_runtime3.urlMatches)(task.completionValue, value);
         else if (kind === "guide_completed") hit = value.id === task.completionValue || value.key === task.completionValue;
         else if (kind === "click") {
           try {
@@ -2070,6 +2735,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());
@@ -2120,12 +2787,23 @@ var GuidelyClient = class _GuidelyClient {
   }
 };
 var current = null;
-function safePath(url) {
+function webOnly(config) {
+  return config.guides.every((g) => (0, import_runtime11.supportsPlatform)(g.config, "web")) ? config : { ...config, guides: config.guides.filter((g) => (0, import_runtime11.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) {