@guidelytech/sdk-core 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -33,37 +33,559 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var index_exports = {};
 __export(index_exports, {
   AUTHORING_PARAM: () => AUTHORING_PARAM,
-  CAPTURE_PARAM: () => import_runtime2.CAPTURE_PARAM,
+  CAPTURE_PARAM: () => import_runtime9.CAPTURE_PARAM,
   DEFAULT_API_URL: () => DEFAULT_API_URL,
   EventQueue: () => EventQueue,
   Guidely: () => Guidely,
   GuidelyClient: () => GuidelyClient,
   HEARTBEAT_MS: () => HEARTBEAT_MS,
   KEYS: () => KEYS,
+  PROTOTYPE_CLOSE_MESSAGE: () => PROTOTYPE_CLOSE_MESSAGE,
   SDK_NAME: () => SDK_NAME,
   SDK_VERSION: () => SDK_VERSION,
   areMutuallyExclusive: () => areMutuallyExclusive,
   buildContext: () => buildContext,
   captureSnapshot: () => captureSnapshot,
+  countsTowardThrottle: () => countsTowardThrottle,
   createGuidely: () => createGuidely,
   createStorage: () => createStorage,
   default: () => index_default,
   detectDevice: () => detectDevice,
+  isAppUrl: () => isAppUrl,
   isExclusiveGuide: () => isExclusiveGuide,
   isFrequencyEligible: () => isFrequencyEligible,
+  isThrottleEligible: () => isThrottleEligible,
   isWithinSchedule: () => isWithinSchedule,
+  matchPrototypeTestUrl: () => matchPrototypeTestUrl,
+  normalizeAppUrl: () => normalizeAppUrl,
+  pruneLaunches: () => pruneLaunches,
   watchNavigation: () => watchNavigation
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_runtime13 = require("@guidelytech/shared/runtime");
-var import_guide_runtime4 = require("@guidelytech/guide-runtime");
+var import_runtime18 = require("@guidelytech/shared/runtime");
 var import_guide_runtime5 = require("@guidelytech/guide-runtime");
+var import_guide_runtime6 = require("@guidelytech/guide-runtime");
 var import_flags = require("@guidelytech/flags");
 
+// src/agent-turns.ts
+var import_runtime4 = require("@guidelytech/shared/runtime");
+
+// src/health.ts
+var MAX_RETRY_AFTER_MS = 60 * 60 * 1e3;
+var OFFLINE_WAIT_MS = 3e4;
+var ServerHealth = class {
+  constructor(opts = {}) {
+    __publicField(this, "failures", 0);
+    __publicField(this, "openUntil", 0);
+    __publicField(this, "lastOkAt", 0);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "threshold");
+    __publicField(this, "baseMs");
+    __publicField(this, "maxMs");
+    __publicField(this, "now");
+    __publicField(this, "random");
+    this.threshold = opts.threshold ?? 3;
+    this.baseMs = opts.baseMs ?? 5e3;
+    this.maxMs = opts.maxMs ?? 5 * 60 * 1e3;
+    this.now = opts.now ?? Date.now;
+    this.random = opts.random ?? Math.random;
+  }
+  /** The server answered (2xx, 3xx, or a 4xx other than 429): it is up. */
+  success() {
+    const wasDown = this.failures > 0 || this.openUntil > 0;
+    this.failures = 0;
+    this.openUntil = 0;
+    this.lastOkAt = this.now();
+    if (wasDown) this.notify();
+  }
+  /** The request failed or the server is overloaded. `retryAfterMs` comes from a `Retry-After` header. */
+  failure(retryAfterMs) {
+    this.failures += 1;
+    const now = this.now();
+    if (retryAfterMs != null && retryAfterMs > 0) {
+      this.openUntil = Math.max(this.openUntil, now + Math.min(retryAfterMs, MAX_RETRY_AFTER_MS));
+      return;
+    }
+    if (this.failures < this.threshold) return;
+    const cooldown = Math.min(this.maxMs, this.baseMs * 2 ** (this.failures - this.threshold));
+    this.openUntil = Math.max(this.openUntil, now + cooldown * (0.8 + this.random() * 0.4));
+  }
+  /** Milliseconds background traffic should wait before trying again (0: send now). */
+  waitMs() {
+    if (typeof navigator !== "undefined" && navigator.onLine === false) return OFFLINE_WAIT_MS;
+    return Math.max(0, this.openUntil - this.now());
+  }
+  canSend() {
+    return this.waitMs() === 0;
+  }
+  /**
+   * The last request got an answer. Unload beacons can't report back, so what they carry is only
+   * forgotten while this holds; otherwise it stays queued and is sent again (the server drops duplicates).
+   */
+  get reachable() {
+    return this.failures === 0 && this.lastOkAt > 0;
+  }
+  /** The browser came back online: end the cooldown and let queued traffic try straight away. */
+  online() {
+    this.openUntil = 0;
+    this.notify();
+  }
+  /** Called when the server answers again after failures, or the browser comes back online. */
+  onRecover(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  notify() {
+    for (const cb of Array.from(this.listeners)) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+};
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+function isServerFailure(status) {
+  return status === 429 || status >= 500;
+}
+
+// src/http.ts
+var STREAM_RESPONSE_TIMEOUT_MS = 3e4;
+var STREAM_IDLE_TIMEOUT_MS = 6e4;
+var Api = class {
+  constructor(baseUrl, key, fetchImpl, health) {
+    __publicField(this, "baseUrl", baseUrl);
+    __publicField(this, "key", key);
+    __publicField(this, "fetchImpl", fetchImpl);
+    /** Reachability of the API, fed by every answer (see {@link ServerHealth}). */
+    __publicField(this, "health");
+    this.health = health ?? new ServerHealth();
+  }
+  /** Feeds an answer (or a failed request, `null`) into {@link health}. */
+  observe(res) {
+    if (!res) this.health.failure();
+    else if (isServerFailure(res.status)) this.health.failure(parseRetryAfter(res.headers?.get?.("retry-after")));
+    else this.health.success();
+  }
+  url(path, params = {}) {
+    const query = Object.entries({ key: this.key, ...params }).filter((e) => e[1] != null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+    return `${this.baseUrl.replace(/\/$/, "")}/api/v1/sdk${path}?${query}`;
+  }
+  get fetcher() {
+    if (this.fetchImpl) return this.fetchImpl;
+    return typeof fetch === "function" ? fetch.bind(globalThis) : null;
+  }
+  async request(method, path, options = {}) {
+    const f = this.fetcher;
+    if (!f) throw new Error("fetch is not available");
+    const headers = { ...options.headers, "X-Guidely-Key": this.key, Accept: "application/json" };
+    const form = typeof FormData !== "undefined" && options.body instanceof FormData;
+    if (options.body !== void 0 && !form) 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 {
+      let res;
+      try {
+        res = await f(this.url(path, options.params), {
+          method,
+          headers,
+          body: options.body === void 0 ? void 0 : form ? options.body : JSON.stringify(options.body),
+          keepalive: options.keepalive,
+          signal: ac?.signal,
+          credentials: "omit",
+          mode: "cors"
+        });
+      } catch (err) {
+        this.observe(null);
+        throw err;
+      }
+      this.observe(res);
+      let data = null;
+      if (res.status !== 304 && res.status !== 204) {
+        try {
+          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 });
+  }
+  /** Multipart POST (file uploads). No Content-Type header: the browser adds it with the boundary. */
+  postForm(path, form, options) {
+    return this.request("POST", path, { body: form, ...options });
+  }
+  /**
+   * POST that may answer with server-sent events. Each event is passed to `onEvent`; a JSON answer is
+   * returned instead. Scout replies can take a while, so there is no overall timeout: the response
+   * must start within 30 s and then never go quiet for more than 60 s (the server sends keepalives),
+   * otherwise the request is aborted and rejects.
+   */
+  async stream(path, body, onEvent, headers = {}) {
+    const f = this.fetcher;
+    if (!f) throw new Error("fetch is not available");
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    let timer = null;
+    const arm = (ms) => {
+      if (!ac) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => ac.abort(), ms);
+    };
+    arm(STREAM_RESPONSE_TIMEOUT_MS);
+    try {
+      let res;
+      try {
+        res = await f(this.url(path), {
+          method: "POST",
+          headers: { ...headers, "X-Guidely-Key": this.key, Accept: "text/event-stream, application/json", "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: ac?.signal,
+          credentials: "omit",
+          mode: "cors"
+        });
+      } catch (err) {
+        this.observe(null);
+        throw err;
+      }
+      this.observe(res);
+      const type = res.headers?.get?.("content-type") ?? "";
+      if (!type.includes("text/event-stream") || !res.body) {
+        let data = null;
+        try {
+          data = await res.json();
+        } catch {
+          data = null;
+        }
+        return { status: res.status, ok: res.ok, data, etag: null };
+      }
+      arm(STREAM_IDLE_TIMEOUT_MS);
+      await readEventStream(res.body, onEvent, () => arm(STREAM_IDLE_TIMEOUT_MS));
+      return { status: res.status, ok: res.ok, data: null, etag: null };
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  /** `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 withRetry(send, attempts = 3, baseMs = 500) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await send();
+      if (res.ok || res.status >= 400 && res.status < 500 && res.status !== 429) return res;
+    } catch {
+    }
+    if (i < attempts - 1) await sleep(backoffMs(i, baseMs, 8e3));
+  }
+  return null;
+}
+function postWithRetry(api, path, body, attempts = 3, baseMs = 500) {
+  return withRetry(() => api.post(path, body), attempts, baseMs);
+}
+async function readEventStream(body, onEvent, onChunk) {
+  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) onChunk?.();
+    if (value) buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
+    let sep;
+    while ((sep = buffer.indexOf("\n\n")) >= 0) {
+      dispatch(buffer.slice(0, sep));
+      buffer = buffer.slice(sep + 2);
+    }
+    if (done) break;
+  }
+  if (buffer.trim()) dispatch(buffer);
+}
+
+// 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}`,
+  /** Survey answers and guide/checklist progress not yet accepted by the server. */
+  outbox: (key) => `guidely:outbox:${key}`,
+  /** Agent Analytics turns not yet accepted by the server. */
+  agentOutbox: (key) => `guidely:agents:${key}`,
+  session: "guidely:session",
+  active: "guidely:active",
+  authoring: "guidely:authoring",
+  /** How-to capture session marker ({ token, … }) and its not-yet-uploaded steps. */
+  capture: "guidely:capture",
+  capturePending: "guidely:capture:pending",
+  /** Messenger conversations this browser can read: [{ id, token }]. */
+  conversations: (key) => `guidely:conversations:${key}`,
+  /** Announcement ids opened in the messenger's News tab. */
+  newsSeen: (key) => `guidely:news:${key}`
+};
+
+// src/outbox.ts
+var Outbox = class {
+  constructor(opts) {
+    __publicField(this, "opts", opts);
+    __publicField(this, "items");
+    __publicField(this, "sending", false);
+    __publicField(this, "attempt", 0);
+    __publicField(this, "timer", null);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "offRecover");
+    __publicField(this, "maxItems");
+    __publicField(this, "maxAgeMs");
+    this.maxItems = opts.maxItems ?? 50;
+    this.maxAgeMs = opts.maxAgeMs ?? 7 * 24 * 60 * 60 * 1e3;
+    const stored = readJson(opts.store, opts.storageKey, []);
+    const cutoff = Date.now() - this.maxAgeMs;
+    this.items = Array.isArray(stored) ? stored.filter((i) => i && typeof i.path === "string" && typeof i.key === "string" && i.createdAt > cutoff).slice(-this.maxItems) : [];
+    this.offRecover = opts.health?.onRecover(() => {
+      this.attempt = 0;
+      this.retryIn(0);
+    }) ?? null;
+    if (this.items.length) this.retryIn(0);
+  }
+  get size() {
+    return this.items.length;
+  }
+  /** Queues `POST path` and sends it now (or as soon as the API is reachable). */
+  add(key, path, body) {
+    if (this.destroyed) return;
+    this.items = this.items.filter((i) => i.key !== key);
+    this.items.push({ key, path, body, createdAt: Date.now() });
+    if (this.items.length > this.maxItems) this.items.splice(0, this.items.length - this.maxItems);
+    this.persist();
+    void this.flush();
+  }
+  persist() {
+    writeJson(this.opts.store, this.opts.storageKey, this.items);
+  }
+  retryIn(ms) {
+    if (this.destroyed) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, ms);
+  }
+  /** Sends queued requests in order, one at a time. */
+  async flush() {
+    if (this.destroyed || this.sending || !this.items.length) return;
+    const wait = this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.retryIn(wait);
+    this.sending = true;
+    try {
+      while (this.items.length && !this.destroyed) {
+        const item = this.items[0];
+        let retry = false;
+        try {
+          const res = await this.opts.api.post(item.path, item.body);
+          retry = !res.ok && (res.status === 429 || res.status >= 500);
+        } catch (err) {
+          retry = true;
+          this.opts.onError?.(err);
+        }
+        if (retry) {
+          this.attempt += 1;
+          this.retryIn(Math.max(backoffMs(this.attempt - 1, 1e3, 6e4), this.opts.health?.waitMs() ?? 0));
+          return;
+        }
+        this.attempt = 0;
+        this.items = this.items.filter((i) => i !== item);
+        this.persist();
+      }
+    } finally {
+      this.sending = false;
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    this.offRecover?.();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+};
+
+// src/agent-turns.ts
+var PENDING_MAX = 500;
+function toolCalls(calls) {
+  if (!Array.isArray(calls)) return void 0;
+  return calls.filter((c) => !!c && typeof c.name === "string" && !!c.name).slice(0, import_runtime4.AGENT_TOOL_CALLS_PER_TURN).map((c) => ({
+    name: c.name.slice(0, 100),
+    ...c.status === "ok" || c.status === "error" ? { status: c.status } : {},
+    ...typeof c.latencyMs === "number" && Number.isFinite(c.latencyMs) && c.latencyMs >= 0 ? { latencyMs: Math.round(c.latencyMs) } : {}
+  }));
+}
+function prepareAgentTurn(turn, identity, redact, onError) {
+  if (!turn || typeof turn !== "object" || !turn.conversationId || !turn.agentId || !turn.role) return null;
+  let out = {
+    ...turn,
+    type: "agent.conversation",
+    turnId: turn.turnId || `t_${(0, import_runtime4.randomId)(20)}`,
+    occurredAt: turn.occurredAt || (/* @__PURE__ */ new Date()).toISOString(),
+    anonymousId: turn.anonymousId ?? identity.anonymousId,
+    userId: turn.userId !== void 0 ? turn.userId : identity.userId,
+    accountId: turn.accountId !== void 0 ? turn.accountId : identity.accountId,
+    sessionId: turn.sessionId ?? identity.sessionId
+  };
+  if (redact) {
+    try {
+      const r = redact({ ...out, toolCalls: out.toolCalls ? out.toolCalls.map((c) => ({ ...c })) : void 0, metadata: out.metadata ? { ...out.metadata } : void 0 });
+      if (!r) return null;
+      out = { ...r, type: "agent.conversation", conversationId: out.conversationId, agentId: out.agentId, turnId: out.turnId, role: out.role };
+    } catch (err) {
+      onError?.(err);
+      return null;
+    }
+  }
+  if (typeof out.text === "string" && out.text.length > import_runtime4.AGENT_TURN_MAX_TEXT) out.text = out.text.slice(0, import_runtime4.AGENT_TURN_MAX_TEXT);
+  if (out.text !== void 0 && typeof out.text !== "string") out.text = String(out.text);
+  const calls = toolCalls(out.toolCalls);
+  if (calls) out.toolCalls = calls;
+  else delete out.toolCalls;
+  return out;
+}
+var AgentTurns = class {
+  constructor(opts) {
+    __publicField(this, "opts", opts);
+    __publicField(this, "outbox");
+    __publicField(this, "pending", []);
+    this.outbox = new Outbox({ api: opts.api, store: opts.store, storageKey: opts.storageKey, health: opts.health, maxItems: 20, maxAgeMs: 24 * 60 * 60 * 1e3 });
+  }
+  get queued() {
+    return this.outbox.size + this.pending.length;
+  }
+  /** Queues turns to send now, or (`hold`) until consent is granted. */
+  add(turns, hold = false) {
+    if (!turns.length) return;
+    if (hold) {
+      this.pending.push(...turns);
+      if (this.pending.length > PENDING_MAX) this.pending.splice(0, this.pending.length - PENDING_MAX);
+      return;
+    }
+    for (let i = 0; i < turns.length; i += import_runtime4.AGENT_TURNS_PER_BATCH) {
+      const batch = turns.slice(i, i + import_runtime4.AGENT_TURNS_PER_BATCH);
+      this.outbox.add(`agent:${batch[0].turnId}`, "/agent-events", { turns: batch, sdk: this.opts.sdk });
+    }
+  }
+  /** Consent changed: granted sends what was held, anything else drops it. */
+  consentChanged(granted) {
+    const held = this.pending.splice(0);
+    if (granted) this.add(held);
+  }
+  destroy() {
+    this.pending = [];
+    this.outbox.destroy();
+  }
+};
+
 // src/authoring.ts
-var import_guide_runtime = require("@guidelytech/guide-runtime");
+var import_guide_runtime3 = require("@guidelytech/guide-runtime");
 
 // src/snapshot.ts
 var MAX_SNAPSHOT_BYTES = 6 * 1024 * 1024;
@@ -125,98 +647,291 @@ function captureSnapshot(doc, maskSelectors, maxBytes = MAX_SNAPSHOT_BYTES) {
     head = doc.createElement("head");
     clone.prepend(head);
   }
-  if (adopted) {
-    const style = doc.createElement("style");
-    style.textContent = adopted;
-    head.append(style);
+  if (adopted) {
+    const style = doc.createElement("style");
+    style.textContent = adopted;
+    head.append(style);
+  }
+  clone.querySelectorAll("base").forEach((el) => el.remove());
+  const base = doc.createElement("base");
+  base.setAttribute("href", doc.baseURI || win.location.href);
+  base.setAttribute("target", "_blank");
+  head.prepend(base);
+  const html = `<!DOCTYPE html>
+${clone.outerHTML}`;
+  if (html.length > maxBytes) return null;
+  return { html, url: win.location.href, title: doc.title, width: win.innerWidth, height: win.innerHeight, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+// src/tagging.ts
+var import_runtime7 = require("@guidelytech/shared/runtime");
+var import_guide_runtime2 = require("@guidelytech/guide-runtime");
+
+// src/autocapture.ts
+var import_guide_runtime = 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_runtime.isGuidelyElement)(el) || !!(0, import_guide_runtime.closestComposed)(el, "[data-guidely-ignore]");
+}
+function interactiveElement(target) {
+  try {
+    return (0, import_guide_runtime.closestComposed)(target, 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 own = ownSelector(el);
+  const chain = (0, import_guide_runtime.shadowHostChain)(el);
+  return (chain ? chain + import_guide_runtime.SHADOW_SEPARATOR + own : own).slice(0, 300);
+}
+function ownSelector(el) {
+  const tag = el.tagName.toLowerCase();
+  if (el.id && (0, import_guide_runtime.isStableId)(el.id)) return `#${esc(el.id)}`;
+  for (const name of PREFERRED_ATTRS) if (el.hasAttribute(name)) return attr(tag, name, el.getAttribute(name) || "");
+  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);
+  }
+  const label = el.getAttribute("aria-label");
+  if (label && label.length <= 80) return attr(tag, "aria-label", label);
+  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_runtime.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;
+}
+function matches(el, selector, deep) {
+  if (!selector) return false;
+  try {
+    return !!(0, import_guide_runtime.closestComposed)(el, 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 = (0, import_guide_runtime.closestComposed)(el, "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;
   }
-  clone.querySelectorAll("base").forEach((el) => el.remove());
-  const base = doc.createElement("base");
-  base.setAttribute("href", doc.baseURI || win.location.href);
-  base.setAttribute("target", "_blank");
-  head.prepend(base);
-  const html = `<!DOCTYPE html>
-${clone.outerHTML}`;
-  if (html.length > maxBytes) return null;
-  return { html, url: win.location.href, title: doc.title, width: win.innerWidth, height: win.innerHeight, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
-}
+  /** 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/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) };
+// src/tagging.ts
+var TEXT_ATTRS = /* @__PURE__ */ new Set(["aria-label", "title", "alt"]);
+var SAFE_ATTRS = ["role", "name", "type", "aria-label", "title", "alt", "for"];
+var STATE_CLASS = /^(is-|has-)?(active|hover|hovered|focus|focused|focus-visible|selected|open|opened|closed|disabled|visible|hidden|show|shown|collapsed|expanded|checked|pressed|loading|current)$/i;
+function nthOfType(el) {
+  const parent = el.parentElement;
+  if (!parent) return void 0;
+  let n = 0;
+  for (const c of Array.from(parent.children)) {
+    if (c.tagName === el.tagName) n++;
+    if (c === el) return n;
+  }
+  return void 0;
 }
-function webStore(area) {
+function nodeOf(el, masked, featureAttribute) {
+  const node = { t: el.tagName.toLowerCase().slice(0, import_runtime7.SNAPSHOT_LIMITS.tag) };
+  if (el.id && (0, import_guide_runtime2.isStableId)(el.id) && el.id.length <= import_runtime7.SNAPSHOT_LIMITS.id) node.id = el.id;
+  const classes = Array.from(el.classList).filter((c) => (0, import_guide_runtime2.isStableClass)(c) && !STATE_CLASS.test(c) && c.length <= import_runtime7.SNAPSHOT_LIMITS.className);
+  if (classes.length) node.c = classes.slice(0, import_runtime7.SNAPSHOT_LIMITS.classes);
+  const a = {};
+  const put = (name, value) => {
+    if (value === null || Object.keys(a).length >= import_runtime7.SNAPSHOT_LIMITS.attrs || name in a) return;
+    if (masked && TEXT_ATTRS.has(name)) return;
+    a[name] = value.slice(0, import_runtime7.SNAPSHOT_LIMITS.attrValue);
+  };
+  if (featureAttribute && el.hasAttribute(featureAttribute)) put(featureAttribute, el.getAttribute(featureAttribute));
+  for (const attr2 of Array.from(el.attributes)) {
+    if (attr2.name.startsWith("data-") && !import_runtime7.NOISY_DATA_ATTR.test(attr2.name) && attr2.value.length <= import_runtime7.SNAPSHOT_LIMITS.attrValue) put(attr2.name, attr2.value);
+  }
+  for (const name of SAFE_ATTRS) if (el.hasAttribute(name)) put(name, el.getAttribute(name));
+  if (Object.keys(a).length) node.a = a;
+  const n = nthOfType(el);
+  if (n) node.n = n;
+  return node;
+}
+function elementSnapshot(el, opts) {
+  const masked = opts.maskAll || isMasked(el, opts.mask);
+  const snap = nodeOf(el, masked, opts.featureAttribute);
+  const p = [];
+  for (let cur = el.parentElement; cur && p.length < import_runtime7.SNAPSHOT_LIMITS.ancestors; cur = cur.parentElement) {
+    if (cur.tagName === "BODY" || cur.tagName === "HTML") break;
+    p.push(nodeOf(cur, masked, opts.featureAttribute));
+  }
+  if (p.length) snap.p = p;
+  const h = [];
+  let root = el.getRootNode?.();
+  while (root && root.nodeType === 11 && root.host && h.length < import_runtime7.SNAPSHOT_LIMITS.hosts) {
+    h.push(nodeOf(root.host, masked, opts.featureAttribute));
+    root = root.host.getRootNode?.();
+  }
+  if (h.length) snap.h = h;
+  return snap;
+}
+function isMasked(el, mask) {
+  if (!mask) return false;
   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 {
-        }
-      }
-    };
+    return !!(0, import_guide_runtime2.closestComposed)(el, mask);
   } catch {
-    return null;
+    return false;
   }
 }
-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;
+function featureAttributeOf(target, attribute) {
+  if (!attribute) return null;
   try {
-    return JSON.parse(raw);
+    const el = (0, import_guide_runtime2.closestComposed)(target, `[${attribute}]`);
+    const value = el?.getAttribute(attribute)?.replace(/\s+/g, " ").trim();
+    return el && value ? { el, value: value.slice(0, 100) } : null;
   } catch {
-    return fallback;
+    return null;
   }
 }
-function writeJson(store, key, value) {
+function readProperty(def, base, opts) {
+  let el = base;
+  if (def.selector) {
+    try {
+      el = (0, import_guide_runtime2.querySelectorStrategy)({ kind: "css", value: def.selector }, document)[0] ?? null;
+    } catch {
+      el = null;
+    }
+  }
+  if (!el) return void 0;
+  if (def.source === "attribute") {
+    const name = (def.attribute ?? "").toLowerCase();
+    if (!name || name === "value" || name.startsWith("on")) return void 0;
+    if (opts.maskAll || isMasked(el, opts.mask)) return void 0;
+    const v = el.getAttribute(name);
+    return v ? v.replace(/\s+/g, " ").trim().slice(0, import_runtime7.TAG_PROPERTY_LIMITS.value) || void 0 : void 0;
+  }
+  return elementText(el, opts.mask, opts.maskAll);
+}
+function clickPropertyValues(config, el, click, opts) {
+  if (!config?.properties.length) return void 0;
+  const out = {};
+  const css = (selector) => {
+    try {
+      return !!(0, import_guide_runtime2.closestComposed)(el, selector);
+    } catch {
+      return false;
+    }
+  };
+  const here = { url: location.href, path: location.pathname, title: document.title };
+  for (const tag of config.properties) {
+    if (tag.kind !== "feature" || !tag.featureRules) continue;
+    const rules = tag.featureRules;
+    const matches2 = (r) => (0, import_runtime7.featureRuleMatchesClick)(r, click, css) && (!r.page?.pattern || (0, import_runtime7.pageRuleMatches)({ type: "url", value: r.page.pattern }, here));
+    if (!rules.some((r) => !r.exclude && matches2(r)) || rules.some((r) => r.exclude && matches2(r))) continue;
+    for (const def of tag.properties) {
+      const v = readProperty(def, el, opts);
+      if (v) out[def.id] = v;
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function pagePropertyValues(config, url, opts) {
+  if (!config?.properties.length) return void 0;
+  const out = {};
+  let path = "/";
   try {
-    store.set(key, JSON.stringify(value));
+    path = new URL(url, location.href).pathname;
   } catch {
   }
+  const ctx = { url, path, title: document.title };
+  for (const tag of config.properties) {
+    if (tag.kind !== "page" || !tag.pageRules || !(0, import_runtime7.pageRulesMatch)(tag.pageRules, ctx)) continue;
+    for (const def of tag.properties) {
+      if (!def.selector) continue;
+      const v = readProperty(def, null, opts);
+      if (v) out[def.id] = v;
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
 }
-var KEYS = {
-  anon: "guidely:anon",
-  seen: "guidely:seen",
-  config: (key) => `guidely:config:${key}`,
-  etag: (key) => `guidely:etag:${key}`,
-  state: (key) => `guidely:state:${key}`,
-  user: (key) => `guidely:user:${key}`,
-  queue: (key) => `guidely:queue:${key}`,
-  session: "guidely:session",
-  active: "guidely:active",
-  authoring: "guidely:authoring",
-  /** How-to capture session marker ({ token, … }) and its not-yet-uploaded steps. */
-  capture: "guidely:capture",
-  capturePending: "guidely:capture:pending",
-  /** Messenger conversations this browser can read: [{ id, token }]. */
-  conversations: (key) => `guidely:conversations:${key}`,
-  /** Announcement ids opened in the messenger's News tab. */
-  newsSeen: (key) => `guidely:news:${key}`
-};
 
 // src/authoring.ts
 async function loadSchemas() {
@@ -286,8 +1001,10 @@ var AuthoringBridge = class {
       }
       this.active = true;
       this.opts.onActive(true);
-      this.session = (0, import_guide_runtime.startAuthoring)({
+      this.session = (0, import_guide_runtime3.startAuthoring)({
         dashboardOrigin: this.info.dashboardOrigin,
+        // Tag mode (Pages & Features): picks become feature rules; the page itself is tagged from the dashboard.
+        message: this.info.purpose === "tag" ? "Guidely tagging \u2014 click an element to tag it as a feature \xB7 tag the page from the dashboard \xB7 Esc to finish" : void 0,
         onPick: (pick) => this.sendPick(pick),
         onExit: () => this.stop()
       });
@@ -304,7 +1021,7 @@ var AuthoringBridge = class {
   masked(el) {
     return this.opts.maskSelectors.some((sel) => {
       try {
-        return !!el.closest(sel);
+        return !!(0, import_guide_runtime3.closestComposed)(el, sel);
       } catch {
         return false;
       }
@@ -315,6 +1032,7 @@ var AuthoringBridge = class {
     const { element, ...rest } = raw;
     const pick = this.masked(element) ? { ...rest, textSnapshot: "", selectors: rest.selectors.filter((s) => s.kind !== "text") } : rest;
     pick.url = window.location.href;
+    if (this.info.purpose === "tag") pick.elementSnapshot = elementSnapshot(element, { mask: this.opts.maskSelectors.join(","), maskAll: false, featureAttribute: null });
     this.post({ type: "guidely:pick", sessionId: this.info.id, pick });
     void this.opts.api.post("/authoring/session/picks", pick, { params: { token: this.token } }).catch((err) => this.opts.onError(err));
   }
@@ -373,7 +1091,7 @@ var AuthoringBridge = class {
           const appearance = msg.appearance ? GuideConfigSchema.shape.appearance.parse(msg.appearance) : void 0;
           this.session?.setPicking(false);
           this.session?.setStatus(`Previewing step \u201C${step.title || step.id}\u201D \u2014 close it to continue picking`);
-          this.preview = (0, import_guide_runtime.previewStep)(step, { ...this.opts.theme(), ...msg.theme || {} }, {
+          this.preview = (0, import_guide_runtime3.previewStep)(step, { ...this.opts.theme(), ...msg.theme || {} }, {
             appearance,
             onEnd: () => {
               this.preview = null;
@@ -390,7 +1108,7 @@ var AuthoringBridge = class {
           const guide = { id: g.id || "preview", key: g.key || "preview", name: g.name || "Preview", kind: g.kind || "flow", version: g.version ?? 0, config: (await loadSchemas()).GuideConfigSchema.parse(g.config) };
           this.session?.setPicking(false);
           this.session?.setStatus(`Previewing \u201C${guide.name}\u201D`);
-          this.previewGuide = (0, import_guide_runtime.runGuide)(guide, {
+          this.previewGuide = (0, import_guide_runtime3.runGuide)(guide, {
             theme: this.opts.theme(),
             ctx: this.opts.ctx,
             onNavigate: (url, newTab) => newTab ? window.open(url, "_blank", "noopener") : window.location.assign(url),
@@ -404,7 +1122,7 @@ var AuthoringBridge = class {
           break;
         }
         case "guidely:highlight": {
-          const result = (0, import_guide_runtime.highlightSelectors)(Array.isArray(msg.selectors) ? msg.selectors : [], { durationMs: 3e3 });
+          const result = (0, import_guide_runtime3.highlightSelectors)(Array.isArray(msg.selectors) ? msg.selectors : [], { durationMs: 3e3 });
           this.post({ type: "guidely:highlight-result", sessionId: this.info.id, counts: result.counts, resolved: !!result.resolved });
           break;
         }
@@ -448,169 +1166,41 @@ var AuthoringBridge = class {
 };
 
 // src/capture-token.ts
-var import_runtime2 = require("@guidelytech/shared/runtime");
+var import_runtime9 = require("@guidelytech/shared/runtime");
 function takeCaptureToken(sessionStore) {
   if (typeof window === "undefined") return null;
   let token = null;
   let authoringLink = false;
   try {
     const url = new URL(window.location.href);
-    token = url.searchParams.get(import_runtime2.CAPTURE_PARAM);
+    token = url.searchParams.get(import_runtime9.CAPTURE_PARAM);
     authoringLink = url.searchParams.has(AUTHORING_PARAM);
     if (token) {
-      url.searchParams.delete(import_runtime2.CAPTURE_PARAM);
+      url.searchParams.delete(import_runtime9.CAPTURE_PARAM);
       window.history.replaceState(window.history.state, "", url.toString());
     }
-  } catch {
-    token = null;
-  }
-  const saved = readJson(sessionStore, KEYS.capture, null);
-  let marker = null;
-  if (token) marker = saved?.token === token ? saved : { token };
-  else if (saved?.token && !authoringLink) marker = saved;
-  if (!marker) {
-    if (saved) {
-      sessionStore.remove(KEYS.capture);
-      sessionStore.remove(KEYS.capturePending);
-    }
-    return null;
-  }
-  if (token && saved?.token !== token) sessionStore.remove(KEYS.capturePending);
-  writeJson(sessionStore, KEYS.capture, marker);
-  sessionStore.remove(KEYS.authoring);
-  return marker;
-}
-
-// src/load-capture.ts
-var loadCapture = async () => (await import("./capture.cjs")).capture;
-
-// 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;
+  } catch {
+    token = null;
+  }
+  const saved = readJson(sessionStore, KEYS.capture, null);
+  let marker = null;
+  if (token) marker = saved?.token === token ? saved : { token };
+  else if (saved?.token && !authoringLink) marker = saved;
+  if (!marker) {
+    if (saved) {
+      sessionStore.remove(KEYS.capture);
+      sessionStore.remove(KEYS.capturePending);
     }
-    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;
+    return null;
   }
-};
+  if (token && saved?.token !== token) sessionStore.remove(KEYS.capturePending);
+  writeJson(sessionStore, KEYS.capture, marker);
+  sessionStore.remove(KEYS.authoring);
+  return marker;
+}
+
+// src/load-capture.ts
+var loadCapture = async () => (await import("./capture.cjs")).capture;
 
 // src/context.ts
 function detectDevice(ua, width) {
@@ -621,7 +1211,8 @@ function detectDevice(ua, width) {
   else if (width > 0 && width < 768) type = "mobile";
   else if (width > 0 && width < 1024) type = "tablet";
   let browser;
-  if (/Edg\//i.test(u)) browser = "edge";
+  if (/Electron\//i.test(u)) browser = "electron";
+  else if (/Edg\//i.test(u)) browser = "edge";
   else if (/OPR\/|Opera/i.test(u)) browser = "opera";
   else if (/SamsungBrowser/i.test(u)) browser = "samsung";
   else if (/Chrome\/|CriOS/i.test(u)) browser = "chrome";
@@ -745,7 +1336,7 @@ var HeatmapBuffer = class {
 };
 
 // src/errors.ts
-var import_runtime5 = require("@guidelytech/shared/runtime");
+var import_runtime11 = require("@guidelytech/shared/runtime");
 var MAX_FRAMES_BYTES = 6e3;
 function fitFrames(frames) {
   const out = frames.slice(0, 30);
@@ -766,7 +1357,7 @@ function exceptionFromError(error, source, handled, fallbackType = "Error") {
   return {
     type: isError && e.name || fallbackType,
     message: (isError ? e.message : describe(error)).slice(0, 1e3),
-    frames: isError ? fitFrames((0, import_runtime5.parseStack)(e.stack)) : [],
+    frames: isError ? fitFrames((0, import_runtime11.parseStack)(e.stack)) : [],
     source,
     handled
   };
@@ -887,162 +1478,35 @@ function areMutuallyExclusive(a, b) {
   return la.includes(b.id) || la.includes(b.key) || lb.includes(a.id) || lb.includes(a.key);
 }
 function isWithinSchedule(guide, now = Date.now()) {
-  const s = guide.config.survey;
-  if (!s) return true;
-  if (s.startAt && now < Date.parse(s.startAt)) return false;
-  if (s.endAt && now > Date.parse(s.endAt)) return false;
+  for (const w of [guide.config.schedule, guide.config.survey]) {
+    if (!w) continue;
+    if (w.startAt && now < Date.parse(w.startAt)) return false;
+    if (w.endAt && now > Date.parse(w.endAt)) return false;
+  }
   return true;
 }
-function dismissedAfterMerge(local, server) {
-  if (server.dismissResetAt && server.dismissResetAt !== local?.dismissResetAt) return server.dismissedAt ?? null;
-  return local?.dismissedAt ?? server.dismissedAt ?? null;
-}
-
-// 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 query = Object.entries({ key: this.key, ...params }).filter((e) => e[1] != null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
-    return `${this.baseUrl.replace(/\/$/, "")}/api/v1/sdk${path}?${query}`;
-  }
-  get fetcher() {
-    if (this.fetchImpl) return this.fetchImpl;
-    return typeof fetch === "function" ? fetch.bind(globalThis) : null;
-  }
-  async request(method, path, options = {}) {
-    const f = this.fetcher;
-    if (!f) throw new Error("fetch is not available");
-    const headers = { ...options.headers, "X-Guidely-Key": this.key, Accept: "application/json" };
-    const form = typeof FormData !== "undefined" && options.body instanceof FormData;
-    if (options.body !== void 0 && !form) 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 : form ? options.body : 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 });
-  }
-  /** Multipart POST (file uploads). No Content-Type header: the browser adds it with the boundary. */
-  postForm(path, form, options) {
-    return this.request("POST", path, { body: form, ...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));
+var MINUTE = 60 * 1e3;
+function countsTowardThrottle(guide) {
+  return isExclusiveGuide(guide) && !guide.config.frequency.ignoreThrottling;
 }
-async function withRetry(send, attempts = 3, baseMs = 500) {
-  for (let i = 0; i < attempts; i++) {
-    try {
-      const res = await send();
-      if (res.ok || res.status >= 400 && res.status < 500 && res.status !== 429) return res;
-    } catch {
-    }
-    if (i < attempts - 1) await sleep(backoffMs(i, baseMs, 8e3));
-  }
-  return null;
+function isThrottleEligible(settings, launches, now = Date.now()) {
+  if (!settings || !settings.enabled) return true;
+  const times = launches.map((l) => Date.parse(l)).filter((t) => !Number.isNaN(t));
+  const windowMs = Math.max(1, settings.windowHours) * HOUR;
+  if (times.filter((t) => now - t < windowMs).length >= Math.max(1, settings.maxGuides)) return false;
+  if (settings.minGapMinutes > 0 && times.some((t) => now - t < settings.minGapMinutes * MINUTE)) return false;
+  return true;
 }
-function postWithRetry(api, path, body, attempts = 3, baseMs = 500) {
-  return withRetry(() => api.post(path, body), attempts, baseMs);
+function pruneLaunches(launches, settings, now = Date.now()) {
+  const keepMs = Math.max(settings?.windowHours ?? 24, 1) * HOUR + (settings?.minGapMinutes ?? 0) * MINUTE;
+  return launches.filter((l) => {
+    const t = Date.parse(l);
+    return !Number.isNaN(t) && now - t < keepMs;
+  }).slice(-100);
 }
-async function readEventStream(body, onEvent) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const dispatch = (raw) => {
-    let event = "message";
-    const data = [];
-    for (const line of raw.split("\n")) {
-      if (!line || line.startsWith(":")) continue;
-      const i = line.indexOf(":");
-      const field = i < 0 ? line : line.slice(0, i);
-      const value = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
-      if (field === "event") event = value;
-      else if (field === "data") data.push(value);
-    }
-    if (!data.length) return;
-    try {
-      onEvent(event, JSON.parse(data.join("\n")));
-    } catch {
-    }
-  };
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (value) buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
-    let sep;
-    while ((sep = buffer.indexOf("\n\n")) >= 0) {
-      dispatch(buffer.slice(0, sep));
-      buffer = buffer.slice(sep + 2);
-    }
-    if (done) break;
-  }
-  if (buffer.trim()) dispatch(buffer);
+function dismissedAfterMerge(local, server) {
+  if (server.dismissResetAt && server.dismissResetAt !== local?.dismissResetAt) return server.dismissedAt ?? null;
+  return local?.dismissedAt ?? server.dismissedAt ?? null;
 }
 
 // src/messenger-api.ts
@@ -1116,6 +1580,14 @@ function createMessengerTransport(opts) {
       h.onDone(d.messages.at(-1) ?? null, d.conversation);
     } else if (!finished) h.onError("The reply was interrupted");
   }
+  async function feedback(path, body, fallback) {
+    const res = await api.post(`/feedback${path}`, { ...body, anonymousId: opts.anonymousId(), userId: opts.userId() });
+    if (!res.ok || !res.data) {
+      if (res.status === 429) throw new HttpError(429, "You're doing that a lot. Please try again in a minute.");
+      throw new HttpError(res.status, serverMessage(res.data) ?? fallback);
+    }
+    return res.data;
+  }
   return {
     async listConversations() {
       const tokens = storedConversations(store, projectId).map((c) => c.token);
@@ -1152,7 +1624,8 @@ function createMessengerTransport(opts) {
       return res.data;
     },
     async getArticle(id) {
-      const res = await api.get(`/articles/${encodeURIComponent(id)}`);
+      const locale = opts.locale?.();
+      const res = await api.get(`/articles/${encodeURIComponent(id)}`, locale ? { params: { locale } } : void 0);
       return res.ok && res.data ? res.data.article : null;
     },
     async fileComplaint(input) {
@@ -1182,13 +1655,25 @@ function createMessengerTransport(opts) {
     async getHowTo(id) {
       const res = await api.get(`/how-tos/${encodeURIComponent(id)}`);
       return res.ok && res.data ? res.data.howTo : null;
-    }
+    },
+    // Ideas (feature requests). The visitor's ids go in every body; the server decides what they may do.
+    listIdeas: (query) => feedback("/requests/query", query, "Ideas couldn't be loaded."),
+    getIdea: (id) => feedback(`/requests/${encodeURIComponent(id)}/view`, {}, "This idea couldn't be loaded."),
+    submitIdea: (input) => feedback("/requests", { ...input, pageUrl: opts.pageUrl() }, "Your idea couldn't be sent. Please try again."),
+    voteIdea: (id, vote) => feedback(`/requests/${encodeURIComponent(id)}/vote`, vote, "Your vote couldn't be saved."),
+    unvoteIdea: (id) => feedback(`/requests/${encodeURIComponent(id)}/unvote`, {}, "Your vote couldn't be removed."),
+    followIdea: (id, follow) => feedback(`/requests/${encodeURIComponent(id)}/follow`, { follow }, "That didn't work. Please try again."),
+    commentIdea: (id, body) => feedback(`/requests/${encodeURIComponent(id)}/comments`, { body }, "Your comment couldn't be posted."),
+    similarIdeas: async (title) => (await feedback("/similar", { title }, "Similar ideas couldn't be loaded.")).requests ?? [],
+    ideaUpdates: () => feedback("/updates", {}, "Updates couldn't be loaded."),
+    markIdeaUpdatesRead: (ids) => feedback("/updates/read", ids ? { ids } : {}, "Updates couldn't be marked read."),
+    ideaPortalLink: async () => (await feedback("/portal-link", {}, "The feedback portal couldn't be opened.")).url
   };
 }
 
 // src/messenger-visitor.ts
-var import_runtime10 = require("@guidelytech/shared/runtime");
-var import_guide_runtime3 = require("@guidelytech/guide-runtime");
+var import_runtime15 = require("@guidelytech/shared/runtime");
+var import_guide_runtime4 = require("@guidelytech/guide-runtime");
 var PAGE_GUIDE_KINDS = /* @__PURE__ */ new Set(["flow", "tooltip", "modal"]);
 var CATCH_ALL = /* @__PURE__ */ new Set(["", "*", "**", "/*", "/**", "/"]);
 var RESUME_WITHIN_MS = 14 * 864e5;
@@ -1205,7 +1690,7 @@ function targetsPage(guide, url) {
   const c = guide.config;
   const checks = [...c.urlPatterns, ...c.trigger.urlPattern ? [c.trigger.urlPattern] : [], ...c.trigger.type === "url_match" && c.trigger.value ? [c.trigger.value] : [], ...c.steps[0]?.url ? [c.steps[0].url] : []];
   const specific = checks.filter((p) => !CATCH_ALL.has(p.trim()));
-  return specific.length > 0 && checks.every((p) => (0, import_guide_runtime3.urlMatches)(p, url));
+  return specific.length > 0 && checks.every((p) => (0, import_guide_runtime4.urlMatches)(p, url));
 }
 function plainText(html, max = 280) {
   const text = html.replace(/<(br|\/p|\/div|\/li|\/h[1-6])\s*\/?>/gi, " ").replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
@@ -1254,7 +1739,7 @@ function buildMessengerVisitor(input) {
       unread: !seen.has(g.id) && !(state.guides[g.id]?.impressions ?? 0)
     };
   });
-  return { firstName: (0, import_runtime10.firstNameFromTraits)(input.traits), path: pathOf(input.url), pageGuides, resumeGuide, checklist, news };
+  return { firstName: (0, import_runtime15.firstNameFromTraits)(input.traits), path: pathOf(input.url), pageGuides, resumeGuide, checklist, news };
 }
 
 // src/navigation.ts
@@ -1312,6 +1797,48 @@ function watchNavigation(listener, debounceMs = 50) {
   };
 }
 
+// src/page-url.ts
+var WEB_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "about", "data", "blob", "javascript"]);
+function appScheme(href) {
+  let u;
+  try {
+    u = new URL(href);
+  } catch {
+    return null;
+  }
+  const scheme = u.protocol.replace(/:$/, "").toLowerCase();
+  return WEB_SCHEMES.has(scheme) ? null : { u, scheme };
+}
+function normalizeAppUrl(href) {
+  const app = appScheme(href);
+  if (!app) return href;
+  const { u, scheme } = app;
+  const host = scheme === "file" ? "app" : u.host || "app";
+  const hash = /^#!?(\/.*)$/.exec(u.hash);
+  if (hash) {
+    const route = hash[1];
+    return `${scheme}://${host}${route.startsWith("/") ? route : `/${route}`}`;
+  }
+  let path = safeDecode(u.pathname);
+  if (scheme === "file" || /\.html?$/i.test(path)) {
+    const file = path.split("/").filter(Boolean).pop() ?? "";
+    const name = file.replace(/\.html?$/i, "");
+    path = !name || name.toLowerCase() === "index" ? "/" : `/${name}`;
+  }
+  if (!path.startsWith("/")) path = `/${path}`;
+  return `${scheme}://${host}${path}${u.search}`;
+}
+function safeDecode(s) {
+  try {
+    return decodeURI(s);
+  } catch {
+    return s;
+  }
+}
+function isAppUrl(href) {
+  return appScheme(href) !== null;
+}
+
 // src/page-tracking.ts
 function scrollDepth() {
   const de = document.documentElement;
@@ -1357,6 +1884,106 @@ var PageTracker = class {
   }
 };
 
+// src/prototype-overlay.ts
+var PROTOTYPE_CLOSE_MESSAGE = "guidely:prototype:close";
+var TOKEN = /^[A-Za-z0-9_-]{16,64}$/;
+var OVERLAY_ATTR = "data-guidely-prototype-overlay";
+function matchPrototypeTestUrl(urlOrToken, apiUrl) {
+  const value = (urlOrToken || "").trim();
+  let api;
+  try {
+    api = new URL(apiUrl);
+  } catch {
+    return null;
+  }
+  if (TOKEN.test(value)) return new URL(`/validate/${value}`, api.origin);
+  let url;
+  try {
+    url = new URL(value, typeof location !== "undefined" ? location.href : api.origin);
+  } catch {
+    return null;
+  }
+  if (url.origin !== api.origin) return null;
+  const m = /^\/validate\/([^/]+)\/?$/.exec(url.pathname);
+  if (!m || !TOKEN.test(m[1])) return null;
+  return new URL(`/validate/${m[1]}`, api.origin);
+}
+var current = null;
+function openPrototypeOverlay(testUrl, opts) {
+  current?.close();
+  const doc = document;
+  const previous = doc.activeElement;
+  const src = new URL(testUrl.href);
+  const hash = new URLSearchParams();
+  hash.set("key", opts.key);
+  if (opts.anonymousId) hash.set("anon", opts.anonymousId);
+  if (opts.userId) hash.set("uid", opts.userId);
+  src.hash = hash.toString();
+  const root = doc.createElement("div");
+  root.setAttribute(OVERLAY_ATTR, "");
+  root.setAttribute("role", "dialog");
+  root.setAttribute("aria-modal", "true");
+  root.setAttribute("aria-label", "Prototype test");
+  root.style.cssText = `position:fixed;inset:0;z-index:${opts.zIndex ?? 2147483646};background:rgba(15,23,42,.55);display:flex;align-items:stretch;justify-content:center;padding:0;margin:0;`;
+  const frame = doc.createElement("iframe");
+  frame.src = src.toString();
+  frame.title = "Prototype test";
+  frame.setAttribute("allow", "fullscreen");
+  frame.setAttribute("referrerpolicy", "no-referrer");
+  frame.style.cssText = "border:0;width:100%;height:100%;background:#fff;display:block;";
+  const close = doc.createElement("button");
+  close.type = "button";
+  close.setAttribute("aria-label", "Close prototype test");
+  close.textContent = "\xD7";
+  close.style.cssText = "position:absolute;top:10px;right:10px;width:36px;height:36px;border-radius:999px;border:0;background:rgba(15,23,42,.75);color:#fff;font:600 22px/36px system-ui,sans-serif;text-align:center;cursor:pointer;padding:0;z-index:1;";
+  root.append(frame, close);
+  const overflow = doc.documentElement.style.overflow;
+  doc.documentElement.style.overflow = "hidden";
+  let closed = false;
+  const shut = () => {
+    if (closed) return;
+    closed = true;
+    window.removeEventListener("message", onMessage);
+    doc.removeEventListener("keydown", onKey, true);
+    doc.removeEventListener("focusin", onFocus, true);
+    root.remove();
+    doc.documentElement.style.overflow = overflow;
+    if (current === overlay) current = null;
+    try {
+      previous?.focus?.();
+    } catch {
+    }
+    opts.onClose?.();
+  };
+  const onMessage = (e) => {
+    if (e.origin !== testUrl.origin || e.source !== frame.contentWindow) return;
+    const data = e.data;
+    if (data && typeof data === "object" && data.type === PROTOTYPE_CLOSE_MESSAGE) shut();
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      shut();
+    } else if (e.key === "Tab") {
+      e.preventDefault();
+      (doc.activeElement === close ? frame : close).focus();
+    }
+  };
+  const onFocus = (e) => {
+    if (!root.contains(e.target)) close.focus();
+  };
+  close.addEventListener("click", shut);
+  window.addEventListener("message", onMessage);
+  doc.addEventListener("keydown", onKey, true);
+  doc.addEventListener("focusin", onFocus, true);
+  doc.body.appendChild(root);
+  frame.focus();
+  const overlay = { element: root, close: shut };
+  current = overlay;
+  return overlay;
+}
+
 // src/queue.ts
 var EventQueue = class {
   constructor(opts) {
@@ -1368,17 +1995,34 @@ var EventQueue = class {
     __publicField(this, "inflightIds", /* @__PURE__ */ new Set());
     __publicField(this, "attempt", 0);
     __publicField(this, "destroyed", false);
+    __publicField(this, "offRecover", null);
     __publicField(this, "flushIntervalMs");
     __publicField(this, "maxQueue");
     __publicField(this, "batchSize");
     __publicField(this, "maxAttempts");
     this.flushIntervalMs = opts.flushIntervalMs ?? 2e3;
-    this.maxQueue = opts.maxQueue ?? 200;
+    this.maxQueue = opts.maxQueue ?? 500;
     this.batchSize = opts.batchSize ?? 50;
     this.maxAttempts = opts.maxAttempts ?? 5;
     const persisted = readJson(opts.store, opts.storageKey, []);
     if (Array.isArray(persisted)) this.events = persisted.filter((e) => e && typeof e.eventId === "string").slice(-this.maxQueue);
     if (this.events.length) this.schedule();
+    this.offRecover = opts.health?.onRecover(() => this.retryNow()) ?? null;
+  }
+  /** The API is back: drop any pending backoff and send what is queued. */
+  retryNow() {
+    if (this.destroyed) return;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    this.attempt = 0;
+    void this.flush();
+  }
+  retryIn(ms) {
+    if (this.retryTimer || this.destroyed) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.flush();
+    }, ms);
   }
   get size() {
     return this.events.length;
@@ -1412,6 +2056,8 @@ var EventQueue = class {
       clearTimeout(this.timer);
       this.timer = null;
     }
+    const wait = this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.retryIn(wait);
     this.inflight = true;
     const batch = this.events.slice(0, this.batchSize);
     this.inflightIds = new Set(batch.map((e) => e.eventId));
@@ -1435,26 +2081,20 @@ var EventQueue = class {
       if (this.events.length) this.schedule();
       return;
     }
-    this.attempt += 1;
-    if (this.attempt >= this.maxAttempts) {
-      this.attempt = 0;
-      return;
-    }
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      void this.flush();
-    }, backoffMs(this.attempt - 1));
+    this.attempt = Math.min(this.attempt + 1, this.maxAttempts);
+    const delay = this.attempt >= this.maxAttempts ? 6e4 : backoffMs(this.attempt - 1);
+    this.retryIn(Math.max(delay, this.opts.health?.waitMs() ?? 0));
   }
   /** Best-effort synchronous flush on unload using `sendBeacon`. */
   flushSync() {
     if (this.destroyed || !this.opts.enabled() || !this.opts.beacon) return;
     const batch = this.events.filter((e) => !this.inflightIds.has(e.eventId)).slice(0, this.batchSize);
     if (!batch.length) return;
-    if (this.opts.beacon(batch)) {
+    if (this.opts.beacon(batch) && (this.opts.health?.reachable ?? true)) {
       const ids = new Set(batch.map((e) => e.eventId));
       this.events = this.events.filter((e) => !ids.has(e.eventId));
-      this.persist();
     }
+    this.persist();
   }
   clear() {
     this.events = [];
@@ -1462,6 +2102,7 @@ var EventQueue = class {
   }
   destroy() {
     this.destroyed = true;
+    this.offRecover?.();
     if (this.timer) clearTimeout(this.timer);
     if (this.retryTimer) clearTimeout(this.retryTimer);
     this.timer = null;
@@ -1475,11 +2116,22 @@ var loadRecorder = async () => (await import("./recorder.cjs")).recorder;
 
 // src/client.ts
 var SDK_NAME = "@guidelytech/sdk-core";
-var SDK_VERSION = "0.9.0";
+var SDK_VERSION = "0.11.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;
+var CACHED_START_MS = 1500;
+function settlesWithin(promise, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), ms);
+    const done = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    promise.then(done, done);
+  });
+}
 function isBrowser() {
   return typeof window !== "undefined" && typeof document !== "undefined";
 }
@@ -1490,7 +2142,7 @@ function emptyState() {
   return { guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] };
 }
 function newSession(now = Date.now()) {
-  return { id: `s_${(0, import_runtime13.randomId)(16)}`, startedAt: new Date(now).toISOString(), shownGuides: [], events: [], lastActivityAt: now };
+  return { id: `s_${(0, import_runtime18.randomId)(16)}`, startedAt: new Date(now).toISOString(), shownGuides: [], events: [], lastActivityAt: now };
 }
 var GuidelyClient = class _GuidelyClient {
   constructor(options) {
@@ -1500,6 +2152,10 @@ var GuidelyClient = class _GuidelyClient {
     __publicField(this, "sessionStore");
     __publicField(this, "emitter");
     __publicField(this, "queue");
+    /** Survey answers and guide/checklist progress, kept until the server accepts them. */
+    __publicField(this, "outbox");
+    /** Agent Analytics turns (agentConversation), in their own outbox. */
+    __publicField(this, "agentTurns");
     __publicField(this, "config", null);
     __publicField(this, "etag", null);
     __publicField(this, "anonymousId");
@@ -1549,6 +2205,10 @@ var GuidelyClient = class _GuidelyClient {
     __publicField(this, "flags");
     /** Experiments already reported this session (`experiment_viewed` is sent once per session). */
     __publicField(this, "exposures", /* @__PURE__ */ new Set());
+    /** Language set with `setLocale()`. */
+    __publicField(this, "locale", null);
+    /** Language each shown guide was rendered in; added to its events as `locale`. */
+    __publicField(this, "guideLocales", /* @__PURE__ */ new Map());
     __publicField(this, "customListeners", /* @__PURE__ */ new Map());
     __publicField(this, "eventBus", {
       on: (name, cb) => {
@@ -1583,7 +2243,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_runtime13.randomId)(20)}`;
+      this.anonymousId = `anon_${(0, import_runtime18.randomId)(20)}`;
       this.store.set(KEYS.anon, this.anonymousId);
     }
     this.firstVisit = !this.store.get(KEYS.seen);
@@ -1593,12 +2253,13 @@ var GuidelyClient = class _GuidelyClient {
     const session = readJson(this.sessionStore, KEYS.session, null);
     this.session = session && session.id ? session : newSession();
     this.persistSession();
-    this.lastUrl = location.href;
+    this.lastUrl = this.pageHref();
     this.lastAudiences = new Set(this.state.audienceIds);
     this.queue = new EventQueue({
       store: this.store,
       storageKey: KEYS.queue(this.options.projectId),
       enabled: () => this.analyticsEnabled(),
+      health: this.api.health,
       send: async (events) => {
         const res = await this.api.post("/events", { events, sentAt: nowIso(), sdk: { name: SDK_NAME, version: SDK_VERSION } }, { keepalive: true });
         return { ok: res.ok, retry: !(res.status >= 400 && res.status < 500 && res.status !== 429) };
@@ -1606,6 +2267,8 @@ var GuidelyClient = class _GuidelyClient {
       beacon: (events) => this.api.beacon("/events", { events, sentAt: nowIso(), sdk: { name: SDK_NAME, version: SDK_VERSION } }),
       onError: (err) => this.reportError(err)
     });
+    this.outbox = new Outbox({ api: this.api, store: this.store, storageKey: KEYS.outbox(this.options.projectId), health: this.api.health });
+    this.agentTurns = new AgentTurns({ api: this.api, store: this.store, storageKey: KEYS.agentOutbox(this.options.projectId), health: this.api.health, sdk: { name: SDK_NAME, version: SDK_VERSION } });
     if (options.user) this.user = { ...options.user };
     this.flags = this.createFlags(options.flags);
   }
@@ -1663,12 +2326,15 @@ var GuidelyClient = class _GuidelyClient {
       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 = webOnly(cached);
-      await this.fetchConfig();
+      const before = this.config?.configVersion;
+      const fresh = this.fetchConfig();
+      if (!this.config) await fresh;
+      else if (!await settlesWithin(fresh, CACHED_START_MS)) void fresh.then(() => this.applyConfigChange(before));
       if (this.destroyed) return;
       this.wireListeners();
       if (!this.identitySettled) {
-        if (this.options.user) await this.identify(this.options.user.id, this.options.user.traits, this.options.user.account);
-        else if (this.user?.id) await this.identify(this.user.id, this.user.traits, this.user.account);
+        const known = this.options.user ?? (this.user?.id ? this.user : null);
+        if (known) await settlesWithin(this.identify(known.id, known.traits, known.account), CACHED_START_MS);
       }
       if (this.destroyed) return;
       this.isReady = true;
@@ -1679,7 +2345,7 @@ var GuidelyClient = class _GuidelyClient {
       this.resumeActiveGuide();
       this.evaluate("ready");
       if (!this.options.disableAuthoring && !capturing) this.maybeStartAuthoring();
-      this.pageTracker.start(location.href);
+      this.pageTracker.start(this.pageHref());
       this.touchSession();
       this.syncCapture();
     } catch (err) {
@@ -1712,7 +2378,7 @@ var GuidelyClient = class _GuidelyClient {
   wireListeners() {
     const doc = document;
     const win = window;
-    this.cleanups.push(watchNavigation((url) => this.handleNavigation(url)));
+    this.cleanups.push(watchNavigation((url) => this.handleNavigation(this.pageHref(url))));
     const onClick = (e) => this.handleDocumentClick(e);
     doc.addEventListener("click", onClick, true);
     this.cleanups.push(() => doc.removeEventListener("click", onClick, true));
@@ -1733,7 +2399,7 @@ var GuidelyClient = class _GuidelyClient {
     const onPageShow = (e) => {
       if (!e.persisted || !this.pageLeft) return;
       this.pageLeft = false;
-      this.pageTracker.start(location.href);
+      this.pageTracker.start(this.pageHref());
     };
     let lastScroll = 0;
     const onScroll = () => {
@@ -1773,11 +2439,16 @@ var GuidelyClient = class _GuidelyClient {
       win.removeEventListener("scroll", onScroll);
       doc.removeEventListener("keydown", onKey, true);
     });
-    const refresh = setInterval(() => void this.refresh(), this.options.configRefreshMs);
+    const refresh = setInterval(() => {
+      if (this.api.health.canSend()) void this.refresh();
+    }, this.options.configRefreshMs);
+    const onOnline = () => this.api.health.online();
+    win.addEventListener("online", onOnline);
+    this.cleanups.push(() => win.removeEventListener("online", onOnline));
     this.cleanups.push(() => clearInterval(refresh));
     const poll = setInterval(() => {
       if (!this.isReady || !this.config || this.editing() || doc.visibilityState === "hidden") return;
-      const url = location.href;
+      const url = this.pageHref();
       const ctx = this.getContext();
       for (const guide of this.config.guides) {
         if (guide.config.trigger.type === "element_visible" && guide.config.trigger.value) this.armVisibility(guide, ctx, url);
@@ -1806,6 +2477,11 @@ var GuidelyClient = class _GuidelyClient {
     if (this.destroyed) return;
     const before = this.config?.configVersion;
     await this.fetchConfig();
+    this.applyConfigChange(before);
+  }
+  /** Re-renders after a config change (refresh, or a config that arrived after start). */
+  applyConfigChange(before) {
+    if (this.destroyed || !this.isReady) return;
     if (this.config && this.config.configVersion !== before) {
       this.renderPersistentWidgets();
       this.evaluate("ready");
@@ -1840,10 +2516,12 @@ var GuidelyClient = class _GuidelyClient {
     this.replay = null;
     this.queue.flushSync();
     this.queue.destroy();
+    this.outbox.destroy();
+    this.agentTurns.destroy();
     this.flags.destroy();
     this.emitter.clear();
-    (0, import_guide_runtime4.destroyHost)();
-    if (current === this) current = null;
+    (0, import_guide_runtime5.destroyHost)();
+    if (current2 === this) current2 = null;
   }
   // ---------------------------------------------------------------------------
   // Identity
@@ -1855,13 +2533,13 @@ var GuidelyClient = class _GuidelyClient {
     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.syncFlagAttributes();
-    this.enqueue("identify", { properties: { traits: (0, import_runtime13.sanitizeProperties)(this.user.traits) } });
+    this.enqueue("identify", { properties: { traits: (0, import_runtime18.sanitizeProperties)(this.user.traits) } });
     await this.syncIdentify();
     this.emitter.emit("identify", { userId: this.user.id, anonymousId: this.anonymousId });
     if (this.isReady) this.evaluate("identify");
   }
   async syncIdentify() {
-    const body = { anonymousId: this.anonymousId, userId: this.user?.id ?? null, traits: this.user?.traits, account: this.user?.account ? { id: this.user.account.id, traits: this.user.account.traits } : null, sessionId: this.session.id, url: this.collectUrls() ? location.href : void 0 };
+    const body = { anonymousId: this.anonymousId, userId: this.user?.id ?? null, traits: this.user?.traits, account: this.user?.account ? { id: this.user.account.id, traits: this.user.account.traits } : null, sessionId: this.session.id, url: this.collectUrls() ? this.pageHref() : void 0 };
     const res = await postWithRetry(this.api, "/identify", body, 2);
     if (res?.ok && res.data) this.mergeServerState(res.data);
   }
@@ -1892,7 +2570,10 @@ var GuidelyClient = class _GuidelyClient {
       checklists,
       surveysSubmitted: Array.from(/* @__PURE__ */ new Set([...this.state.surveysSubmitted, ...data.surveysSubmitted || []])),
       audienceIds: data.audienceIds || [],
-      firstSeenAt: this.state.firstSeenAt ?? data.firstSeenAt
+      firstSeenAt: this.state.firstSeenAt ?? data.firstSeenAt,
+      // Device-local only (the server doesn't hold them).
+      ...this.state.throttle ? { throttle: this.state.throttle } : {},
+      ...this.state.announcementsSeenAt ? { announcementsSeenAt: this.state.announcementsSeenAt } : {}
     };
     if (data.firstSeenAt && Date.now() - Date.parse(data.firstSeenAt) > 6e4) this.firstVisit = false;
     this.persistState();
@@ -1928,7 +2609,7 @@ var GuidelyClient = class _GuidelyClient {
     this.stopGuide();
     this.user = null;
     this.store.remove(KEYS.user(this.options.projectId));
-    this.anonymousId = `anon_${(0, import_runtime13.randomId)(20)}`;
+    this.anonymousId = `anon_${(0, import_runtime18.randomId)(20)}`;
     this.store.set(KEYS.anon, this.anonymousId);
     this.state = emptyState();
     this.persistState();
@@ -1960,6 +2641,7 @@ var GuidelyClient = class _GuidelyClient {
     if (consent === "denied") this.queue.clear();
     else if (consent === "granted") void this.queue.flush();
     if (consent !== "granted") this.replay?.stop({ discard: true });
+    if (consent !== "pending") this.agentTurns.consentChanged(consent === "granted");
     this.syncCapture();
   }
   analyticsEnabled() {
@@ -1972,17 +2654,19 @@ var GuidelyClient = class _GuidelyClient {
     if (this.consent === "denied" || !this.options.analytics) return null;
     if (name !== "page_leave" && name !== "heatmap") this.touchSession();
     const event = {
-      eventId: (0, import_runtime13.randomId)(24),
+      eventId: (0, import_runtime18.randomId)(24),
       name,
       occurredAt: nowIso(),
       anonymousId: this.anonymousId,
       userId: this.user?.id || null,
       accountId: this.user?.account?.id || null,
       sessionId: this.session.id,
-      url: this.collectUrls() ? location.href : void 0,
+      url: this.collectUrls() ? this.pageHref() : void 0,
       ...extra
     };
-    if (extra.properties) event.properties = (0, import_runtime13.sanitizeProperties)(extra.properties);
+    if (extra.properties) event.properties = (0, import_runtime18.sanitizeProperties)(extra.properties);
+    const locale = extra.guideId ? this.guideLocales.get(extra.guideId) : void 0;
+    if (locale) event.properties = { ...event.properties ?? {}, locale };
     this.queue.enqueue(event);
     this.replay?.addCustomEvent("guidely", { name, customName: event.customName, guideId: event.guideId });
     this.emitter.emit("track", event);
@@ -2006,9 +2690,30 @@ var GuidelyClient = class _GuidelyClient {
     this.completeChecklistTasksBy("event", name);
     if (this.isReady) this.evaluate("event", { eventName: name });
   }
+  /**
+   * Agent Analytics: records one or more turns of a conversation with your own AI agent or chatbot
+   * (`{ conversationId, agentId, role, text, toolCalls?, latencyMs?, outcome?, … }`). The visitor's
+   * anonymous id, user id, account id and session id are filled in, `agents.redact` from the init
+   * options runs on each turn, and turns are retried until Guidely accepts them. Returns false when
+   * nothing was queued (analytics off or consent denied, or every turn was invalid or dropped).
+   */
+  agentConversation(turns) {
+    if (this.destroyed || !this.options.analytics || this.consent === "denied" || this.config?.settings?.analyticsEnabled === false) return false;
+    const identity = { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, sessionId: this.session.id };
+    const prepared = (Array.isArray(turns) ? turns : [turns]).map((t) => prepareAgentTurn(t, identity, this.options.agents?.redact, (err) => this.reportError(err))).filter((t) => !!t);
+    if (!prepared.length) return false;
+    this.touchSession();
+    this.agentTurns.add(prepared, this.consent === "pending");
+    return true;
+  }
+  /** Alias of {@link agentConversation}. */
+  trackAgentTurn(turns) {
+    return this.agentConversation(turns);
+  }
   /** Records a page view and re-evaluates triggers. Called automatically on SPA navigation. */
-  page(url = location.href) {
+  page(href) {
     if (this.destroyed) return;
+    const url = this.pageHref(href);
     this.leavePage(url);
     this.trackPageView(url);
     this.handleNavigation(url, true);
@@ -2028,13 +2733,13 @@ var GuidelyClient = class _GuidelyClient {
       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_runtime4.urlMatches)(p, url))) this.active.controller.destroy();
+        if (g.config.urlPatterns.length && !g.config.urlPatterns.some((p) => (0, import_guide_runtime5.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_runtime4.urlMatches)(p, url))) w.controller.destroy();
+      if (g?.config.urlPatterns.length && !g.config.urlPatterns.some((p) => (0, import_guide_runtime5.urlMatches)(p, url))) w.controller.destroy();
     });
     this.firedDelays.clear();
     if (this.isReady) this.evaluate("navigation");
@@ -2042,7 +2747,7 @@ var GuidelyClient = class _GuidelyClient {
     if (changed) void this.queue.flush();
   }
   handleDocumentClick(e) {
-    const target = e.target;
+    const target = (0, import_guide_runtime5.composedTarget)(e);
     if (!target || typeof target.closest !== "function") return;
     this.autocaptureClick(e, target);
     this.completeChecklistTasksBy("click", target);
@@ -2100,6 +2805,8 @@ var GuidelyClient = class _GuidelyClient {
       const ref = !this.session.pageViews ? externalReferrer() : void 0;
       if (ref) props.referrer = ref;
     }
+    const ep = this.captureAllowed() ? pagePropertyValues(this.config?.tagging, url, { mask: this.maskSelector(), maskAll: this.maskAllText() }) : void 0;
+    if (ep) props.ep = ep;
     this.session.pageViews = (this.session.pageViews ?? 0) + 1;
     this.persistSession();
     this.enqueue("page_view", { url: collect ? url : void 0, properties: props });
@@ -2125,21 +2832,28 @@ var GuidelyClient = class _GuidelyClient {
     const heat = this.autocaptureOn("heatmaps");
     if (!clicks && !rage && !heat || isIgnoredElement(target)) return;
     this.touchSession();
-    const el = interactiveElement(target);
+    const featureAttribute = this.config?.tagging?.featureAttribute ?? null;
+    const feature = featureAttributeOf(target, featureAttribute);
+    const el = interactiveElement(target) ?? feature?.el ?? null;
     const opts = { mask: this.maskSelector(), maskAll: this.maskAllText(), collectUrls: this.collectUrls() };
-    if (clicks && el) this.enqueue("click", { properties: { ...describeClick(el, e, opts) } });
+    const clickProps = (on) => {
+      const p = describeClick(on, e, opts);
+      const ep = clickPropertyValues(this.config?.tagging, on, p, opts);
+      return { ...p, el: elementSnapshot(on, { ...opts, featureAttribute }), ...feature ? { fa: feature.value } : {}, ...ep ? { ep } : {} };
+    };
+    if (clicks && el) this.enqueue("click", { properties: clickProps(el) });
     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 (rage && count) this.enqueue("rage_click", { properties: { ...clickProps(el ?? target), count } });
     if (!heat) return;
-    const url = location.href;
+    const url = this.pageHref();
     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;
+    const target = (0, import_guide_runtime5.composedTarget)(e);
     if (document.visibilityState === "hidden" || !target?.closest || !this.autocaptureOn("mouseMovement") || isIgnoredElement(target)) return;
-    const url = location.href;
+    const url = this.pageHref();
     if (this.heatmap.url !== url) this.flushHeatmap();
     if (this.heatmap.move(url, movementBin(interactiveElement(target) ?? target, e))) this.flushHeatmap();
   }
@@ -2215,7 +2929,7 @@ var GuidelyClient = class _GuidelyClient {
     if (!this.isReady || this.destroyed) return;
     if (this.config && !this.initialPageViewSent && this.config.settings?.autocapture) {
       this.initialPageViewSent = true;
-      this.trackPageView(location.href);
+      this.trackPageView(this.pageHref());
     }
     if (this.config) {
       for (const [props, extra] of this.earlyExceptions.splice(0)) {
@@ -2228,7 +2942,7 @@ var GuidelyClient = class _GuidelyClient {
   syncReplay() {
     const cfg = this.isReady && this.captureAllowed() ? this.replayConfig() : null;
     if (cfg && this.session.replay === void 0) {
-      this.session.replay = (0, import_runtime13.rolloutBucket)(this.session.id, "replay") < cfg.sampleRate;
+      this.session.replay = (0, import_runtime18.rolloutBucket)(this.session.id, "replay") < cfg.sampleRate;
       this.persistSession();
     }
     if (!cfg || !this.session.replay) {
@@ -2250,7 +2964,7 @@ var GuidelyClient = class _GuidelyClient {
             return {
               anonymousId: this.anonymousId,
               userId: this.user?.id || null,
-              url: this.collectUrls() ? location.href : void 0,
+              url: this.collectUrls() ? this.pageHref() : 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 }
@@ -2262,7 +2976,9 @@ var GuidelyClient = class _GuidelyClient {
             this.persistSession();
             this.replay?.stop({ discard: true });
           },
-          onError: (err) => this.reportError(err)
+          onError: (err) => this.reportError(err),
+          health: this.api.health,
+          stash: this.sessionStore
         });
         this.syncReplay();
       },
@@ -2299,6 +3015,14 @@ var GuidelyClient = class _GuidelyClient {
   // ---------------------------------------------------------------------------
   // Targeting + triggers
   // ---------------------------------------------------------------------------
+  /** The page URL Guidely works with: `options.pageUrl`, else app-relative for `file:` / custom protocols (`normalizeAppUrl`). */
+  pageHref(href = location.href) {
+    try {
+      return this.options.pageUrl ? this.options.pageUrl(href) || href : normalizeAppUrl(href);
+    } catch {
+      return href;
+    }
+  }
   /** Builds the targeting context for the current moment. */
   getContext() {
     const guides = this.state.guides;
@@ -2309,7 +3033,7 @@ var GuidelyClient = class _GuidelyClient {
       userId: this.user?.id || null,
       userAttributes: this.user?.traits ?? {},
       accountAttributes: this.user?.account?.traits ?? {},
-      url: location.href,
+      url: this.pageHref(),
       firstVisit: this.firstVisit,
       eventsSeen: this.session.events,
       completedGuides: keysOf(Object.keys(guides).filter((id) => guides[id]?.completedAt)),
@@ -2318,17 +3042,64 @@ var GuidelyClient = class _GuidelyClient {
       completedChecklists: keysOf(completedChecklists),
       audienceIds: this.state.audienceIds,
       environment: this.options.environment,
-      platform: "web"
+      platform: "web",
+      ...this.options.appVersion ? { appVersion: this.options.appVersion } : {}
     });
   }
   isTargeted(guide, ctx, url) {
     const c = guide.config;
-    if (c.urlPatterns.length && !c.urlPatterns.some((p) => (0, import_guide_runtime4.urlMatches)(p, url))) return false;
-    if (c.trigger.urlPattern && !(0, import_guide_runtime4.urlMatches)(c.trigger.urlPattern, url)) return false;
+    if (c.urlPatterns.length && !c.urlPatterns.some((p) => (0, import_guide_runtime5.urlMatches)(p, url))) return false;
+    if (c.trigger.urlPattern && !(0, import_guide_runtime5.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_runtime13.evaluateRules)(c.targeting, ctx);
+    return (0, import_runtime18.evaluateRules)(c.targeting, ctx);
+  }
+  /** Guide throttling: may this guide launch automatically now? */
+  throttleAllows(guide) {
+    if (!countsTowardThrottle(guide)) return true;
+    return isThrottleEligible(this.config?.settings.throttling, this.state.throttle ?? []);
+  }
+  recordLaunch(guide, manual) {
+    if (manual || !countsTowardThrottle(guide) || !this.config?.settings.throttling?.enabled) return;
+    this.state.throttle = pruneLaunches([...this.state.throttle ?? [], nowIso()], this.config.settings.throttling);
+    this.persistState();
+  }
+  /** Guides and A/B test control groups, which are evaluated the same way but never render. */
+  candidates() {
+    const guides = this.config?.guides ?? [];
+    const holdouts = this.config?.guideHoldouts ?? [];
+    return holdouts.length ? [...guides, ...holdouts.map((h) => h.guide)] : guides;
+  }
+  holdoutFor(guide) {
+    return this.config?.guideHoldouts?.find((h) => h.guide.id === guide.id) ?? null;
+  }
+  /** The visitor's language candidates, most preferred first. */
+  locales() {
+    const nav = typeof navigator !== "undefined" ? [...navigator.languages ?? [], navigator.language] : [];
+    return (0, import_runtime18.visitorLocales)(this.locale ?? this.options.locale, this.user?.traits, nav);
+  }
+  defaultLocale() {
+    return this.config?.settings.localization?.defaultLocale || "en";
+  }
+  /** The guide in the visitor's language (remembered so its events carry `locale`). */
+  localize(guide) {
+    const localized = (0, import_runtime18.localizeGuide)(guide, this.locales(), this.defaultLocale());
+    this.guideLocales.set(guide.id, localized.locale);
+    return localized;
+  }
+  /**
+   * Sets the language for guides and the resource center (`null` = back to the traits / browser).
+   * Guides already on screen keep their language; the resource center re-renders.
+   */
+  setLocale(locale) {
+    this.locale = locale ? (0, import_runtime18.normalizeLocale)(locale) || null : null;
+    if (this.resourceCenter) {
+      this.resourceCenter.destroy();
+      this.resourceCenterScope?.destroy();
+      this.resourceCenter = null;
+      this.renderPersistentWidgets();
+    }
   }
   isEligible(guide, ctx, url) {
     if (!this.isTargeted(guide, ctx, url)) return false;
@@ -2346,13 +3117,13 @@ var GuidelyClient = class _GuidelyClient {
         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_runtime4.urlMatches)(t.value, location.href);
+        return (reason === "ready" || reason === "navigation" || reason === "identify") && (0, import_guide_runtime5.urlMatches)(t.value, this.pageHref());
       case "event":
         return reason === "event" && !!t.value && detail.eventName === t.value;
       case "element_click":
         if (reason !== "click" || !t.value || !detail.target) return false;
         try {
-          return !!detail.target.closest(t.value);
+          return !!(0, import_guide_runtime5.closestComposed)(detail.target, t.value);
         } catch {
           return false;
         }
@@ -2371,15 +3142,15 @@ var GuidelyClient = class _GuidelyClient {
   }
   evaluate(reason, detail = {}) {
     if (!this.config || this.destroyed || this.editing()) return;
-    const url = location.href;
+    const url = this.pageHref();
     const ctx = this.getContext();
     if (reason === "identify") {
-      const current2 = new Set(this.state.audienceIds);
-      detail.newAudiences = new Set(Array.from(current2).filter((a) => !this.lastAudiences.has(a)));
-      this.lastAudiences = current2;
+      const current3 = new Set(this.state.audienceIds);
+      detail.newAudiences = new Set(Array.from(current3).filter((a) => !this.lastAudiences.has(a)));
+      this.lastAudiences = current3;
     }
     const candidates = [];
-    for (const guide of this.config.guides) {
+    for (const guide of this.candidates()) {
       const t = guide.config.trigger;
       if (detail.endedGuide && detail.endedGuide.id === guide.id) continue;
       if (reason === "ready" || reason === "navigation") {
@@ -2395,6 +3166,10 @@ var GuidelyClient = class _GuidelyClient {
       if (t.type === "page_load" && t.delayMs > 0 && reason === "timer" && detail.guideId !== guide.id) continue;
       if (!this.triggerFires(guide, reason, detail)) continue;
       if (!this.isEligible(guide, ctx, url)) continue;
+      if (!this.throttleAllows(guide)) {
+        this.log("throttled", guide.key);
+        continue;
+      }
       candidates.push(guide);
     }
     if (reason === "after_guide" || reason === "navigation") this.drainQueue(url, ctx);
@@ -2422,7 +3197,7 @@ var GuidelyClient = class _GuidelyClient {
       this.visibilityObservers.delete(guide.id);
     };
     this.visibilityObservers.set(guide.id, stop);
-    (0, import_guide_runtime4.waitForTarget)([{ kind: "css", value: selector }], { timeoutMs: 0, signal: ac.signal }).then((el) => {
+    (0, import_guide_runtime5.waitForTarget)([{ kind: "css", value: selector }], { timeoutMs: 0, signal: ac.signal }).then((el) => {
       if (ac.signal.aborted) return;
       const fire = () => {
         stop();
@@ -2445,6 +3220,13 @@ var GuidelyClient = class _GuidelyClient {
   /** Decides whether a guide can show now, otherwise queues it. */
   tryShow(guide, url, manual) {
     if (this.destroyed) return false;
+    if (!manual && !this.throttleAllows(guide)) return false;
+    const holdout = this.holdoutFor(guide);
+    if (holdout) {
+      if (this.active && !manual) return false;
+      this.recordImpression(guide, manual);
+      return true;
+    }
     if (!isExclusiveGuide(guide)) {
       if (this.widgets.has(guide.id)) return false;
       this.show(guide, manual);
@@ -2485,14 +3267,18 @@ var GuidelyClient = class _GuidelyClient {
   guideState(id) {
     return this.state.guides[id] ?? (this.state.guides[id] = { impressions: 0 });
   }
-  recordImpression(guide) {
+  recordImpression(guide, manual = false) {
     const s = this.guideState(guide.id);
     s.impressions += 1;
     s.lastShownAt = nowIso();
     if (!this.session.shownGuides.includes(guide.id)) this.session.shownGuides.push(guide.id);
+    this.recordLaunch(guide, manual);
     this.persistState();
     this.persistSession();
-    this.syncGuideState(guide.id, { impression: true });
+    const holdout = this.holdoutFor(guide);
+    const experiment = holdout ? { id: holdout.experimentId, variantId: holdout.variantId } : guide.experiment;
+    if (experiment) this.enqueue("experiment_viewed", { properties: { guideExperimentId: experiment.id, variantId: experiment.variantId, ...holdout ? {} : { guideId: guide.id } } });
+    if (!holdout) this.syncGuideState(guide.id, { impression: true });
   }
   recordEnd(guide, reason) {
     const s = this.guideState(guide.id);
@@ -2503,7 +3289,9 @@ var GuidelyClient = class _GuidelyClient {
     if (reason === "completed") this.completeChecklistTasksBy("guide_completed", guide);
   }
   syncGuideState(guideId, update) {
-    void postWithRetry(this.api, "/guide-state", { anonymousId: this.anonymousId, userId: this.user?.id || null, updates: [{ guideId, ...update }] });
+    const body = { anonymousId: this.anonymousId, userId: this.user?.id || null, updates: [{ guideId, ...update }] };
+    if (update.impression) void postWithRetry(this.api, "/guide-state", body);
+    else this.outbox.add(`guide:${guideId}:${update.completed ? "completed" : "dismissed"}:${this.anonymousId}`, "/guide-state", body);
   }
   show(guide, manual, stepId) {
     try {
@@ -2514,13 +3302,17 @@ var GuidelyClient = class _GuidelyClient {
       this.reportError(err);
     }
   }
-  showFlow(guide, manual, stepId) {
+  showFlow(raw, manual, stepId) {
     if (this.editing()) return;
+    const guide = this.localize(raw);
     const exclusive = isExclusiveGuide(guide);
-    const entry = { guide, manual, startUrl: location.href };
-    const controller = (0, import_guide_runtime4.runGuide)(guide, {
+    const entry = { guide, manual, startUrl: this.pageHref() };
+    const controller = (0, import_guide_runtime5.runGuide)(guide, {
       theme: this.theme(),
+      // Code blocks only arrive when a workspace admin allowed them (the server strips them otherwise).
+      runCode: true,
       ctx: () => this.getContext(),
+      currentUrl: () => this.pageHref(),
       startAtStep: stepId,
       eventBus: this.eventBus,
       // Started from Help, Scout or startGuide(): steps on other pages offer to take the user there.
@@ -2534,7 +3326,7 @@ var GuidelyClient = class _GuidelyClient {
         const step = e.stepId ? guide.config.steps.find((s) => s.id === e.stepId) : void 0;
         this.enqueue(e.name, { guideId: guide.id, guideVersion: guide.version, stepId: e.stepId, stepIndex: e.stepIndex, properties: e.properties });
         if (e.name === "guide_started") {
-          this.recordImpression(guide);
+          this.recordImpression(guide, manual);
           this.emitter.emit("guide:start", guide);
         }
         if (e.name === "step_viewed" && step) {
@@ -2581,14 +3373,15 @@ var GuidelyClient = class _GuidelyClient {
       this.widgets.delete(guide.id);
     }
   }
-  showChecklist(guide) {
+  showChecklist(raw) {
     if (this.editing()) return;
+    const guide = this.localize(raw);
     const config = guide.config.checklist;
     if (!config || this.widgets.has(guide.id)) return;
-    const scope = (0, import_guide_runtime5.createScope)(this.theme(), guide.config.appearance);
+    const scope = (0, import_guide_runtime6.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_runtime4.renderChecklist)({
+    const widget = (0, import_guide_runtime5.renderChecklist)({
       scope: scope.el,
       config,
       progress,
@@ -2603,12 +3396,13 @@ var GuidelyClient = class _GuidelyClient {
     }, checklist: widget, scope });
     if (first) this.recordImpression(guide);
   }
-  showSurvey(guide, manual) {
+  showSurvey(raw, manual) {
     if (this.editing()) return;
+    const guide = this.localize(raw);
     const config = guide.config.survey;
     if (!config) return;
-    const scope = (0, import_guide_runtime5.createScope)(this.theme(), guide.config.appearance);
-    const entry = { guide, manual, startUrl: location.href, scope };
+    const scope = (0, import_guide_runtime6.createScope)(this.theme(), guide.config.appearance);
+    const entry = { guide, manual, startUrl: this.pageHref(), scope };
     const finish = (reason) => {
       widget.destroy();
       scope.destroy();
@@ -2620,18 +3414,18 @@ var GuidelyClient = class _GuidelyClient {
       }
       this.setTimer(() => this.evaluate("after_guide", { endedGuide: guide }), 0);
     };
-    const widget = (0, import_guide_runtime4.renderSurvey)({
+    const widget = (0, import_guide_runtime5.renderSurvey)({
       scope: scope.el,
       config,
       title: guide.name,
       onDismiss: () => finish(this.state.surveysSubmitted.includes(guide.id) ? "submitted" : "dismissed"),
       onSubmit: (answers) => {
-        const responseId = (0, import_runtime13.randomId)(24);
+        const responseId = (0, import_runtime18.randomId)(24);
         this.state.surveysSubmitted.push(guide.id);
         this.persistState();
         this.recordEnd(guide, "completed");
         this.enqueue("survey_submitted", { guideId: guide.id, guideVersion: guide.version, properties: { responseId } });
-        void postWithRetry(this.api, `/surveys/${encodeURIComponent(guide.id)}/responses`, { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, guideVersion: guide.version, answers, responseId });
+        this.outbox.add(`survey:${responseId}`, `/surveys/${encodeURIComponent(guide.id)}/responses`, { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, guideVersion: guide.version, answers, responseId });
         this.emitter.emit("survey:submit", { guide, answers, responseId });
         this.emitter.emit("guide:complete", guide);
         widget.showThankYou();
@@ -2639,7 +3433,7 @@ var GuidelyClient = class _GuidelyClient {
     });
     entry.survey = widget;
     this.active = entry;
-    this.recordImpression(guide);
+    this.recordImpression(guide, manual);
     this.enqueue("survey_displayed", { guideId: guide.id, guideVersion: guide.version });
     this.emitter.emit("guide:start", guide);
   }
@@ -2648,6 +3442,7 @@ var GuidelyClient = class _GuidelyClient {
   }
   navigate(url, newTab) {
     try {
+      if (this.openPrototypeTest(url)) return;
       if (newTab) window.open(url, "_blank", "noopener");
       else location.assign(url);
     } catch (err) {
@@ -2668,11 +3463,17 @@ var GuidelyClient = class _GuidelyClient {
     }
     this.destroyMessenger();
     if (rc && rc.enabled && !this.resourceCenter) {
-      const scope = (0, import_guide_runtime5.createScope)(this.theme());
+      const scope = (0, import_guide_runtime6.createScope)(this.theme());
       this.resourceCenterScope = scope;
-      this.resourceCenter = (0, import_guide_runtime4.renderResourceCenter)({
+      this.resourceCenter = (0, import_guide_runtime5.renderResourceCenter)({
         scope: scope.el,
-        config: rc,
+        config: (0, import_runtime18.localizeResourceCenter)(rc, this.locales(), this.defaultLocale()),
+        evaluate: (rules) => (0, import_runtime18.evaluateRules)(rules, this.getContext()),
+        announcementsSeenAt: () => this.state.announcementsSeenAt ?? null,
+        onAnnouncementsSeen: () => {
+          this.state.announcementsSeenAt = nowIso();
+          this.persistState();
+        },
         guides: this.config.guides.map((g) => ({ id: g.id, key: g.key, name: g.name, kind: g.kind })),
         search: (q) => this.searchResourceCenter(q),
         audienceIds: () => this.state.audienceIds,
@@ -2706,7 +3507,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_runtime5.createScope)(this.theme());
+      const scope = (0, import_guide_runtime6.createScope)(this.theme());
       this.messengerScope = scope;
       this.messenger = renderMessenger({
         scope: scope.el,
@@ -2717,7 +3518,8 @@ var GuidelyClient = class _GuidelyClient {
           projectId: this.options.projectId,
           anonymousId: () => this.anonymousId,
           userId: () => this.user?.id || null,
-          pageUrl: () => this.collectUrls() ? location.href : void 0
+          pageUrl: () => this.collectUrls() ? this.pageHref() : void 0,
+          locale: () => this.rcLocale()
         }),
         visitor: () => this.messengerVisitor(),
         brand: { logoUrl: this.theme().logoUrl ?? null, name: this.theme().brandName ?? null },
@@ -2726,7 +3528,8 @@ var GuidelyClient = class _GuidelyClient {
           const seen = readJson(this.store, KEYS.newsSeen(this.options.projectId), []);
           writeJson(this.store, KEYS.newsSeen(this.options.projectId), Array.from(/* @__PURE__ */ new Set([...ids, ...Array.isArray(seen) ? seen : []])).slice(0, 200));
         },
-        resourceCenter: this.config.resourceCenter,
+        resourceCenter: this.config.resourceCenter ? (0, import_runtime18.localizeResourceCenter)(this.config.resourceCenter, this.locales(), this.defaultLocale()) : null,
+        evaluate: (rules) => (0, import_runtime18.evaluateRules)(rules, this.getContext()),
         audienceIds: () => this.state.audienceIds,
         guides: this.config.guides.map((g) => ({ id: g.id, key: g.key, name: g.name, kind: g.kind })),
         onStartGuide: (idOrKey) => this.startGuide(idOrKey),
@@ -2750,7 +3553,7 @@ var GuidelyClient = class _GuidelyClient {
   /** What the messenger personalises from, computed fresh on every render. */
   messengerVisitor() {
     const ctx = this.getContext();
-    const url = location.href;
+    const url = this.pageHref();
     const seen = readJson(this.store, KEYS.newsSeen(this.options.projectId), []);
     const visitor = buildMessengerVisitor({
       guides: this.config?.guides ?? [],
@@ -2761,11 +3564,24 @@ var GuidelyClient = class _GuidelyClient {
       isAudienceTargeted: (g) => {
         if (!isWithinSchedule(g)) return false;
         ctx.rolloutSalt = g.id;
-        return (0, import_runtime13.evaluateRules)(g.config.targeting, ctx);
+        return (0, import_runtime18.evaluateRules)(g.config.targeting, ctx);
       },
       newsSeen: Array.isArray(seen) ? seen : []
     });
-    return { ...visitor, identified: !!this.user?.id };
+    const rc = this.config?.resourceCenter;
+    const rcNews = rc?.announcements?.length ? (0, import_runtime18.visibleAnnouncements)((0, import_runtime18.localizeResourceCenter)(rc, this.locales(), this.defaultLocale()).announcements, this.state.audienceIds).map((a) => ({
+      id: `rc_${a.id}`,
+      key: a.guideId ?? "",
+      title: a.title,
+      body: plainText(a.body),
+      imageUrl: null,
+      publishedAt: a.publishedAt,
+      unread: !(Array.isArray(seen) && seen.includes(`rc_${a.id}`)),
+      articleId: a.articleId ?? null,
+      url: a.url ?? null
+    })) : [];
+    const news = rcNews.length ? [...visitor.news, ...rcNews].sort((a, b) => b.publishedAt.localeCompare(a.publishedAt)).slice(0, 10) : visitor.news;
+    return { ...visitor, news, identified: !!this.user?.id };
   }
   destroyMessenger() {
     this.messenger?.destroy();
@@ -2773,9 +3589,17 @@ var GuidelyClient = class _GuidelyClient {
     this.messenger = null;
     this.messengerScope = null;
   }
+  /** The resource center's language for this visitor, or null for the default language. */
+  rcLocale() {
+    const rc = this.config?.resourceCenter;
+    if (!rc) return null;
+    const locale = (0, import_runtime18.localizeResourceCenter)(rc, this.locales(), this.defaultLocale()).locale;
+    return locale.toLowerCase() === this.defaultLocale().toLowerCase() ? null : locale;
+  }
   async loadArticle(id) {
     try {
-      const res = await this.api.get(`/articles/${encodeURIComponent(id)}`);
+      const locale = this.rcLocale();
+      const res = await this.api.get(`/articles/${encodeURIComponent(id)}`, locale ? { params: { locale } } : void 0);
       return res.ok && res.data ? res.data.article : null;
     } catch {
       return null;
@@ -2813,14 +3637,14 @@ 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_runtime4.isChecklistComplete)(config, progress) && !progress.completedAt;
+    const complete = (0, import_guide_runtime5.isChecklistComplete)(config, progress) && !progress.completedAt;
     if (complete) {
       progress.completedAt = nowIso();
       this.enqueue("checklist_completed", { guideId: guide.id, guideVersion: guide.version });
     }
     this.persistState();
     this.widgets.get(guide.id)?.checklist?.setProgress(this.getChecklistProgress(guide.id));
-    void postWithRetry(this.api, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, completed: !!progress.completedAt });
+    this.outbox.add(`checklist:${guide.id}:progress:${this.anonymousId}`, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, completed: !!progress.completedAt });
     this.emitter.emit("checklist:task", { guide, task, progress: this.getChecklistProgress(guide.id) });
     if (complete) {
       this.emitter.emit("checklist:complete", guide);
@@ -2836,11 +3660,11 @@ 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_runtime4.urlMatches)(task.completionValue, value);
+        else if (kind === "url_visited") hit = (0, import_guide_runtime5.urlMatches)(task.completionValue, value);
         else if (kind === "guide_completed") hit = value.id === task.completionValue || value.key === task.completionValue;
         else if (kind === "click") {
           try {
-            hit = !!value.closest(task.completionValue);
+            hit = !!(0, import_guide_runtime5.closestComposed)(value, task.completionValue);
           } catch {
             hit = false;
           }
@@ -2860,7 +3684,7 @@ var GuidelyClient = class _GuidelyClient {
     progress.dismissedAt = nowIso();
     this.persistState();
     this.enqueue("checklist_dismissed", { guideId: guide.id, guideVersion: guide.version });
-    void postWithRetry(this.api, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, dismissed: true });
+    this.outbox.add(`checklist:${guide.id}:dismissed:${this.anonymousId}`, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, dismissed: true });
     this.widgets.get(guide.id)?.destroy();
     this.widgets.delete(guide.id);
   }
@@ -2951,6 +3775,18 @@ var GuidelyClient = class _GuidelyClient {
   closeMessenger() {
     this.messenger?.close();
   }
+  /**
+   * Opens a Guidely prototype test (its `/validate/<token>` URL on this SDK's API origin, or the bare
+   * token) in a full-screen overlay, attributed to the current user. Returns false, doing nothing, for
+   * any other URL. Guide buttons that open a test URL use this automatically.
+   */
+  openPrototypeTest(urlOrToken) {
+    if (typeof document === "undefined") return false;
+    const url = matchPrototypeTestUrl(urlOrToken, this.options.apiUrl);
+    if (!url) return false;
+    openPrototypeOverlay(url, { key: this.options.projectId, anonymousId: this.anonymousId, userId: this.user?.id ?? null });
+    return true;
+  }
   /**
    * Opens the complaint form in the messenger, optionally with a category picked (its id from
    * Complaints → Categories). Does nothing when the project doesn't take complaints.
@@ -2959,6 +3795,14 @@ var GuidelyClient = class _GuidelyClient {
     if (!this.config?.messenger?.enabled || !this.config.messenger.complaints?.categories.length) return;
     void this.loadMessenger().then((m) => m?.openComplaint(categoryId));
   }
+  /**
+   * Opens the Ideas tab in the messenger (feature requests and voting), or one idea by its id.
+   * Does nothing when the project hasn't turned on Ideas.
+   */
+  openIdeas(requestId) {
+    if (!this.config?.messenger?.enabled || !this.config.messenger.ideas) return;
+    void this.loadMessenger().then((m) => m?.openIdeas(requestId));
+  }
   /** Opens a new messenger conversation, optionally pre-filling the message. */
   showNewMessage(text) {
     if (!this.config?.messenger?.enabled) return;
@@ -2988,14 +3832,15 @@ var GuidelyClient = class _GuidelyClient {
     const device = detectDevice(navigator.userAgent, window.innerWidth);
     const account = this.user?.account;
     return {
-      url: location.href,
-      path: location.pathname,
+      url: this.pageHref(),
+      path: pathOf2(this.pageHref()),
       deviceType: device.type,
       browser: device.browser,
       os: device.os,
       locale: navigator.language || void 0,
       environment: this.options.environment,
       platform: "web",
+      ...this.options.appVersion ? { appVersion: this.options.appVersion } : {},
       ...this.user?.traits ?? {},
       id: this.user?.id || this.anonymousId,
       anonymousId: this.anonymousId,
@@ -3155,20 +4000,20 @@ var GuidelyClient = class _GuidelyClient {
   // ---------------------------------------------------------------------------
   /** Creates (or returns the existing) client and starts initialisation. */
   static init(options) {
-    if (current && !current.destroyed && current.options.projectId === options.projectId) return current;
-    current?.destroy();
-    current = new _GuidelyClient(options);
-    void current.init();
-    return current;
+    if (current2 && !current2.destroyed && current2.options.projectId === options.projectId) return current2;
+    current2?.destroy();
+    current2 = new _GuidelyClient(options);
+    void current2.init();
+    return current2;
   }
   /** The most recently created client, if any. */
   static get() {
-    return current && !current.destroyed ? current : null;
+    return current2 && !current2.destroyed ? current2 : null;
   }
 };
-var current = null;
+var current2 = null;
 function webOnly(config) {
-  return config.guides.every((g) => (0, import_runtime13.supportsPlatform)(g.config, "web")) ? config : { ...config, guides: config.guides.filter((g) => (0, import_runtime13.supportsPlatform)(g.config, "web")) };
+  return config.guides.every((g) => (0, import_runtime18.supportsPlatform)(g.config, "web")) ? config : { ...config, guides: config.guides.filter((g) => (0, import_runtime18.supportsPlatform)(g.config, "web")) };
 }
 function pathOf2(url) {
   try {
@@ -3188,7 +4033,7 @@ function externalReferrer() {
 }
 function createGuidely(options) {
   const client = new GuidelyClient(options);
-  current = client;
+  current2 = client;
   void client.init();
   return client;
 }
@@ -3211,17 +4056,24 @@ var index_default = Guidely;
   GuidelyClient,
   HEARTBEAT_MS,
   KEYS,
+  PROTOTYPE_CLOSE_MESSAGE,
   SDK_NAME,
   SDK_VERSION,
   areMutuallyExclusive,
   buildContext,
   captureSnapshot,
+  countsTowardThrottle,
   createGuidely,
   createStorage,
   detectDevice,
+  isAppUrl,
   isExclusiveGuide,
   isFrequencyEligible,
+  isThrottleEligible,
   isWithinSchedule,
+  matchPrototypeTestUrl,
+  normalizeAppUrl,
+  pruneLaunches,
   watchNavigation
 });
 //# sourceMappingURL=index.cjs.map