@sightspool/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,813 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/privacy.ts
+function redactText(input) {
+  if (!input) return "";
+  try {
+    return String(input).replace(EMAIL_RE, "\u2039email\u203A").replace(LONG_DIGITS_RE, "\u2039num\u203A").replace(/\s+/g, " ").trim().slice(0, MAX_LABEL_LEN);
+  } catch (e) {
+    return "";
+  }
+}
+function safeClosest(el, selector) {
+  try {
+    return typeof el.closest === "function" && el.closest(selector) != null;
+  } catch (e) {
+    return false;
+  }
+}
+function isIgnoredElement(el, blockSelectors = []) {
+  if (!el || typeof el.closest !== "function") return false;
+  if (safeClosest(el, `[${IGNORE_ATTR}]`)) return true;
+  for (const sel of blockSelectors) {
+    if (sel && safeClosest(el, sel)) return true;
+  }
+  return false;
+}
+function matchesRedactSelector(el, redactSelectors = []) {
+  if (!el || typeof el.closest !== "function") return false;
+  for (const sel of redactSelectors) {
+    if (sel && safeClosest(el, sel)) return true;
+  }
+  return false;
+}
+var EMAIL_RE, LONG_DIGITS_RE, MAX_LABEL_LEN, ATTACH_DISCLOSURE, REDACTED, IGNORE_ATTR;
+var init_privacy = __esm({
+  "src/privacy.ts"() {
+    EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+    LONG_DIGITS_RE = /\d{6,}/g;
+    MAX_LABEL_LEN = 280;
+    ATTACH_DISCLOSURE = "Session and account attached automatically.";
+    REDACTED = "\u2039redacted\u203A";
+    IGNORE_ATTR = "data-sightspool-ignore";
+  }
+});
+
+// src/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  showPrompt: () => showPrompt
+});
+function showPrompt(opts) {
+  return new Promise((resolve) => {
+    if (typeof document === "undefined") {
+      resolve({ answer: "dismissed" });
+      return;
+    }
+    let settled = false;
+    const host = document.createElement("div");
+    const shadow = host.attachShadow({ mode: "open" });
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      try {
+        host.remove();
+      } catch (e) {
+      }
+      resolve(result);
+    }
+    const style = document.createElement("style");
+    style.textContent = STYLE;
+    shadow.appendChild(style);
+    const wrap = document.createElement("div");
+    wrap.className = "wrap";
+    shadow.appendChild(wrap);
+    function render(node) {
+      wrap.innerHTML = "";
+      const card = document.createElement("div");
+      card.className = "card";
+      card.style.position = "relative";
+      const x = document.createElement("button");
+      x.className = "x";
+      x.textContent = "\xD7";
+      x.setAttribute("aria-label", "Dismiss");
+      x.onclick = () => finish({ answer: "dismissed" });
+      card.appendChild(x);
+      card.appendChild(node);
+      const disc = document.createElement("p");
+      disc.className = "disc";
+      disc.textContent = ATTACH_DISCLOSURE;
+      card.appendChild(disc);
+      wrap.appendChild(card);
+    }
+    function stateA() {
+      const node = document.createElement("div");
+      const q = document.createElement("p");
+      q.className = "q";
+      q.textContent = "Were you able to do what you came here to do today?";
+      node.appendChild(q);
+      const row = document.createElement("div");
+      row.className = "row";
+      const yes = document.createElement("button");
+      yes.className = "primary";
+      yes.textContent = "Yes";
+      yes.onclick = () => finish({ answer: "yes" });
+      const no = document.createElement("button");
+      no.textContent = "Not really";
+      no.onclick = () => stateB();
+      row.append(yes, no);
+      node.appendChild(row);
+      render(node);
+    }
+    function stateB() {
+      const node = document.createElement("div");
+      const q = document.createElement("p");
+      q.className = "q";
+      q.textContent = "What were you trying to do?";
+      node.appendChild(q);
+      for (const c of opts.candidates.slice(0, 4)) {
+        const b = document.createElement("button");
+        b.className = "cand";
+        b.textContent = c;
+        b.onclick = () => finish({ answer: "not_really", intent: c });
+        node.appendChild(b);
+      }
+      const se = document.createElement("button");
+      se.className = "cand";
+      se.textContent = "Something else\u2026";
+      se.onclick = () => stateText();
+      node.appendChild(se);
+      render(node);
+    }
+    function stateText() {
+      const node = document.createElement("div");
+      const q = document.createElement("p");
+      q.className = "q";
+      q.textContent = "What were you trying to do?";
+      node.appendChild(q);
+      const input = document.createElement("input");
+      input.type = "text";
+      input.placeholder = "In your own words\u2026";
+      node.appendChild(input);
+      const row = document.createElement("div");
+      row.className = "row";
+      const submit = document.createElement("button");
+      submit.className = "primary";
+      submit.textContent = "Send";
+      submit.onclick = () => finish({ answer: "not_really", verbatim: input.value.trim() || void 0 });
+      row.appendChild(submit);
+      node.appendChild(row);
+      render(node);
+      try {
+        input.focus();
+      } catch (e) {
+      }
+    }
+    try {
+      document.body.appendChild(host);
+      stateA();
+    } catch (e) {
+      finish({ answer: "dismissed" });
+    }
+  });
+}
+var STYLE;
+var init_prompt = __esm({
+  "src/prompt.ts"() {
+    init_privacy();
+    STYLE = `
+:host { all: initial; }
+.wrap { position: fixed; bottom: 20px; right: 20px; z-index: 2147483000;
+  width: 320px; max-width: calc(100vw - 32px); font-family: system-ui, -apple-system, sans-serif; }
+.card { background: #fff; color: #18181b; border: 1px solid #e4e4e7; border-radius: 12px;
+  box-shadow: 0 10px 30px rgba(0,0,0,.12); padding: 16px; }
+.q { font-size: 14px; font-weight: 600; margin: 0 0 12px; line-height: 1.35; }
+.row { display: flex; gap: 8px; flex-wrap: wrap; }
+button { font: inherit; font-size: 13px; cursor: pointer; border-radius: 8px; padding: 8px 12px;
+  border: 1px solid #e4e4e7; background: #fafafa; color: #18181b; }
+button:hover { background: #f4f4f5; }
+button.primary { background: #18181b; color: #fff; border-color: #18181b; }
+.cand { display: block; width: 100%; text-align: left; margin-bottom: 6px; }
+.disc { font-size: 11px; color: #71717a; margin: 12px 0 0; }
+.x { position: absolute; top: 8px; right: 10px; border: none; background: none; font-size: 16px;
+  color: #a1a1aa; padding: 2px 6px; }
+input { font: inherit; font-size: 13px; width: 100%; box-sizing: border-box; padding: 8px 10px;
+  border: 1px solid #e4e4e7; border-radius: 8px; margin-bottom: 8px; }
+`;
+  }
+});
+
+// src/capture.ts
+init_privacy();
+var TRAIL_MAX = 30;
+var DEAD_CLICK_MS = 700;
+var RAGE_WINDOW_MS = 1e3;
+var RAGE_COUNT = 3;
+function hasDom() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function createCapture(opts) {
+  var _a2, _b;
+  const redactSelectors = (_a2 = opts.redact) != null ? _a2 : [];
+  const blockSelectors = (_b = opts.block) != null ? _b : [];
+  let buf = [];
+  let lastError;
+  let started = false;
+  const subs = [];
+  const cleanups = [];
+  let recentClicks = [];
+  function notify() {
+    for (const cb of subs) {
+      try {
+        cb();
+      } catch (e) {
+      }
+    }
+  }
+  function push(type, label) {
+    try {
+      buf.push({ t: Date.now(), type, label: label ? redactText(label) : void 0 });
+      if (buf.length > TRAIL_MAX) buf = buf.slice(-TRAIL_MAX);
+      if (opts.debug) console.debug("[sightspool] event", type, label);
+      notify();
+    } catch (e) {
+    }
+  }
+  function currentRoute() {
+    try {
+      return location.pathname + location.search;
+    } catch (e) {
+      return "";
+    }
+  }
+  function currentLabel() {
+    try {
+      return document.title || "";
+    } catch (e) {
+      return "";
+    }
+  }
+  function onClick(ev) {
+    var _a3;
+    try {
+      const target = ev.target;
+      if (isIgnoredElement(target, blockSelectors)) return;
+      const text = target && (((_a3 = target.getAttribute) == null ? void 0 : _a3.call(target, "aria-label")) || target.textContent) || "";
+      const label = matchesRedactSelector(target, redactSelectors) ? REDACTED : text.trim().slice(0, 60);
+      const t = Date.now();
+      recentClicks = recentClicks.filter((ts) => t - ts <= RAGE_WINDOW_MS);
+      recentClicks.push(t);
+      const isRage = recentClicks.length >= RAGE_COUNT;
+      push(isRage ? "rage_click" : "click", label);
+      const routeBefore = currentRoute();
+      let mutated = false;
+      let observer = null;
+      try {
+        observer = new MutationObserver(() => {
+          mutated = true;
+        });
+        observer.observe(document.body, { childList: true, subtree: true, attributes: true });
+      } catch (e) {
+      }
+      window.setTimeout(() => {
+        try {
+          observer == null ? void 0 : observer.disconnect();
+          if (!mutated && currentRoute() === routeBefore && label) {
+            push("dead_click", label);
+          }
+        } catch (e) {
+        }
+      }, DEAD_CLICK_MS);
+    } catch (e) {
+    }
+  }
+  function onError(ev) {
+    try {
+      lastError = String(ev.message || "error");
+      push("error", lastError);
+    } catch (e) {
+    }
+  }
+  function onRejection(ev) {
+    try {
+      const reason = ev.reason;
+      lastError = reason instanceof Error ? reason.message : String(reason);
+      push("error", lastError);
+    } catch (e) {
+    }
+  }
+  function installRouteTracking() {
+    try {
+      const fire = () => push("route", currentRoute());
+      const origPush = history.pushState;
+      const origReplace = history.replaceState;
+      history.pushState = function(...args) {
+        const r = origPush.apply(this, args);
+        fire();
+        return r;
+      };
+      history.replaceState = function(...args) {
+        const r = origReplace.apply(this, args);
+        fire();
+        return r;
+      };
+      window.addEventListener("popstate", fire);
+      cleanups.push(() => {
+        history.pushState = origPush;
+        history.replaceState = origReplace;
+        window.removeEventListener("popstate", fire);
+      });
+      push("route", currentRoute());
+    } catch (e) {
+    }
+  }
+  function installFetchTracking() {
+    try {
+      if (typeof window.fetch !== "function") return;
+      const orig = window.fetch.bind(window);
+      window.fetch = async (...args) => {
+        try {
+          const res = await orig(...args);
+          if (!res.ok) push("request_error", `HTTP ${res.status}`);
+          return res;
+        } catch (err) {
+          push("request_error", err instanceof Error ? err.message : "network error");
+          throw err;
+        }
+      };
+      cleanups.push(() => {
+        window.fetch = orig;
+      });
+    } catch (e) {
+    }
+  }
+  return {
+    start() {
+      if (started || !hasDom()) return;
+      started = true;
+      try {
+        document.addEventListener("click", onClick, true);
+        window.addEventListener("error", onError);
+        window.addEventListener("unhandledrejection", onRejection);
+        cleanups.push(() => {
+          document.removeEventListener("click", onClick, true);
+          window.removeEventListener("error", onError);
+          window.removeEventListener("unhandledrejection", onRejection);
+        });
+        installRouteTracking();
+        installFetchTracking();
+      } catch (e) {
+      }
+    },
+    stop() {
+      started = false;
+      for (const c of cleanups.splice(0)) {
+        try {
+          c();
+        } catch (e) {
+        }
+      }
+    },
+    trail() {
+      return buf.slice();
+    },
+    route: currentRoute,
+    label: currentLabel,
+    error() {
+      return lastError;
+    },
+    onEvent(cb) {
+      subs.push(cb);
+    },
+    recordSearch(query, zeroResult) {
+      const q = query.trim();
+      if (!q) return;
+      push(zeroResult ? "zero_result" : "search", q);
+    }
+  };
+}
+
+// src/harvest.ts
+init_privacy();
+var SEARCH_HINT_RE = /search|filter|find|query|command|lookup/i;
+var DEBOUNCE_MS = 800;
+function looksLikeSearch(el) {
+  try {
+    const input = el;
+    if (input.type === "search") return true;
+    const role = el.getAttribute("role") || "";
+    if (role === "searchbox" || role === "combobox") return true;
+    const hay = [
+      input.name,
+      input.placeholder,
+      el.getAttribute("aria-label"),
+      el.id,
+      el.className
+    ].filter(Boolean).join(" ");
+    return SEARCH_HINT_RE.test(hay);
+  } catch (e) {
+    return false;
+  }
+}
+function createHarvest(capture, opts) {
+  var _a2, _b;
+  let hint;
+  let timer = null;
+  let started = false;
+  const redactSelectors = (_a2 = opts.redact) != null ? _a2 : [];
+  const blockSelectors = (_b = opts.block) != null ? _b : [];
+  function onInput(ev) {
+    try {
+      const target = ev.target;
+      if (!target || target.tagName !== "INPUT" && target.tagName !== "TEXTAREA") return;
+      if (!looksLikeSearch(target)) return;
+      if (isIgnoredElement(target, blockSelectors) || matchesRedactSelector(target, redactSelectors))
+        return;
+      const value = (target.value || "").trim();
+      if (value.length < 2) return;
+      if (timer !== null) window.clearTimeout(timer);
+      timer = window.setTimeout(() => {
+        hint = value;
+        capture.recordSearch(value);
+        if (opts.debug) console.debug("[sightspool] harvested intent", value);
+      }, DEBOUNCE_MS);
+    } catch (e) {
+    }
+  }
+  return {
+    start() {
+      if (started || typeof document === "undefined") return;
+      started = true;
+      try {
+        document.addEventListener("input", onInput, true);
+      } catch (e) {
+      }
+    },
+    stop() {
+      started = false;
+      try {
+        document.removeEventListener("input", onInput, true);
+        if (timer !== null) window.clearTimeout(timer);
+      } catch (e) {
+      }
+    },
+    lastIntentHint() {
+      return hint;
+    }
+  };
+}
+
+// src/egress.ts
+var FLUSH_BATCH = 10;
+var FLUSH_INTERVAL_MS = 15e3;
+function createEgress(opts) {
+  let queue = [];
+  let identity;
+  let interval = null;
+  let started = false;
+  const url = `${opts.endpoint.replace(/\/+$/, "")}/api/sdk/ingest`;
+  function send(signals) {
+    if (signals.length === 0) return;
+    const body = { key: opts.key, identity, signals };
+    const json = JSON.stringify(body);
+    try {
+      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+        const blob = new Blob([json], { type: "text/plain" });
+        const ok = navigator.sendBeacon(url, blob);
+        if (ok) {
+          if (opts.debug) console.debug("[sightspool] beacon", signals.length);
+          return;
+        }
+      }
+      void fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body: json,
+        keepalive: true,
+        mode: "cors",
+        credentials: "omit"
+      }).catch(() => {
+      });
+    } catch (e) {
+    }
+  }
+  function onVisibility() {
+    try {
+      if (document.visibilityState === "hidden") flush();
+    } catch (e) {
+    }
+  }
+  function flush() {
+    if (queue.length === 0) return;
+    const batch = queue;
+    queue = [];
+    send(batch);
+  }
+  return {
+    start() {
+      if (started || typeof window === "undefined") return;
+      started = true;
+      try {
+        document.addEventListener("visibilitychange", onVisibility);
+        window.addEventListener("pagehide", flush);
+        interval = window.setInterval(flush, FLUSH_INTERVAL_MS);
+      } catch (e) {
+      }
+    },
+    stop() {
+      started = false;
+      try {
+        document.removeEventListener("visibilitychange", onVisibility);
+        window.removeEventListener("pagehide", flush);
+        if (interval !== null) window.clearInterval(interval);
+      } catch (e) {
+      }
+      flush();
+    },
+    enqueue(signal) {
+      queue.push(signal);
+      if (queue.length >= FLUSH_BATCH) flush();
+    },
+    flush,
+    setIdentity(next) {
+      identity = next;
+    }
+  };
+}
+
+// src/triggers.ts
+var RAGE_CLICK_COUNT = 3;
+var RAGE_WINDOW_MS2 = 1e3;
+var FRICTION_RETRY_COUNT = 3;
+var FRICTION_WINDOW_MS = 8e3;
+function detectFriction(trail, now, windowMs = FRICTION_WINDOW_MS) {
+  var _a2;
+  const recent = trail.filter((e) => now - e.t <= windowMs);
+  if (recent.some((e) => e.type === "error" || e.type === "request_error")) return "error";
+  const clicks = recent.filter((e) => e.type === "click" || e.type === "rage_click");
+  for (let i = 0; i < clicks.length; i++) {
+    const burst = clicks.filter(
+      (e) => e.t >= clicks[i].t && e.t - clicks[i].t <= RAGE_WINDOW_MS2
+    );
+    if (burst.length >= RAGE_CLICK_COUNT) return "rage";
+  }
+  if (recent.some((e) => e.type === "dead_click")) return "dead_end";
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const e of clicks) {
+    if (!e.label) continue;
+    const n = ((_a2 = byLabel.get(e.label)) != null ? _a2 : 0) + 1;
+    byLabel.set(e.label, n);
+    if (n >= FRICTION_RETRY_COUNT) return "retry";
+  }
+  return null;
+}
+var DEFAULT_CAPS = {
+  maxPromptsPerSession: 1,
+  cooldownMs: 5 * 6e4
+};
+function canPrompt(state, now, caps = DEFAULT_CAPS) {
+  if (state.promptsShown >= caps.maxPromptsPerSession) return false;
+  if (state.lastPromptAt !== null && now - state.lastPromptAt < caps.cooldownMs) return false;
+  return true;
+}
+
+// src/env.ts
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1", ""]);
+function isLocalhost(hostname) {
+  const h = (hostname != null ? hostname : "").trim().toLowerCase();
+  if (LOCAL_HOSTS.has(h)) return true;
+  return h.endsWith(".local") || h.endsWith(".localhost");
+}
+
+// src/index.ts
+var DEFAULT_ENDPOINT = "https://app.sightspool.com";
+var FRICTION_EMIT_COOLDOWN_MS = 3e4;
+var EVENT_DEBOUNCE_MS = 600;
+function currentHostname() {
+  try {
+    return typeof location !== "undefined" ? location.hostname : "";
+  } catch (e) {
+    return "";
+  }
+}
+var ctrl = null;
+function uuid() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch (e) {
+  }
+  return "s-" + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function deriveCandidates(c) {
+  const out = [];
+  const hint = c.harvest.lastIntentHint();
+  if (hint) out.push(`Searching for \u201C${hint}\u201D`);
+  const label = c.capture.label();
+  if (label) out.push(`Something on \u201C${label.slice(0, 40)}\u201D`);
+  return out;
+}
+function buildSignal(c, trigger, extra = {}) {
+  const err = c.capture.error();
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    route: c.capture.route(),
+    client_label: c.capture.label(),
+    trail: c.capture.trail(),
+    session_ref: c.sessionRef,
+    trigger,
+    intent_hint: c.harvest.lastIntentHint(),
+    error: err,
+    outcome: err || trigger === "friction" ? "failed" : "unknown",
+    ...extra
+  };
+}
+async function maybePrompt(c, trigger) {
+  var _a2;
+  const now = Date.now();
+  if (canPrompt(c.fatigue, now, DEFAULT_CAPS)) {
+    c.fatigue.promptsShown += 1;
+    c.fatigue.lastPromptAt = now;
+    try {
+      const { showPrompt: showPrompt2 } = await Promise.resolve().then(() => (init_prompt(), prompt_exports));
+      const result = await showPrompt2({ candidates: deriveCandidates(c) });
+      c.egress.enqueue(
+        buildSignal(c, trigger, {
+          answer: result.answer,
+          verbatim: result.verbatim,
+          intent_hint: (_a2 = result.intent) != null ? _a2 : c.harvest.lastIntentHint(),
+          outcome: result.answer === "yes" ? "achieved" : "failed"
+        })
+      );
+    } catch (e) {
+      c.egress.enqueue(buildSignal(c, trigger));
+    }
+  } else {
+    c.egress.enqueue(buildSignal(c, trigger));
+  }
+}
+function onCaptureEvent() {
+  const c = ctrl;
+  if (!c || !c.running) return;
+  if (c.eventTimer !== null) return;
+  c.eventTimer = (typeof window !== "undefined" ? window.setTimeout : setTimeout)(() => {
+    c.eventTimer = null;
+    try {
+      const now = Date.now();
+      if (now - c.lastFrictionEmitAt < FRICTION_EMIT_COOLDOWN_MS) return;
+      const kind = detectFriction(c.capture.trail(), now);
+      if (!kind) return;
+      c.lastFrictionEmitAt = now;
+      void maybePrompt(c, "friction");
+    } catch (e) {
+    }
+  }, EVENT_DEBOUNCE_MS);
+}
+function onExitIntent(ev) {
+  const c = ctrl;
+  if (!c || !c.running || !c.config.boundaryAsk) return;
+  try {
+    if (ev.clientY <= 0) void maybePrompt(c, "boundary");
+  } catch (e) {
+  }
+}
+function startRuntime(c) {
+  if (c.running) return;
+  if (c.suppressed) {
+    if (c.config.debug)
+      console.debug(
+        "[sightspool] capture suppressed on localhost (set captureOnLocalhost:true to override)"
+      );
+    return;
+  }
+  c.running = true;
+  c.capture.start();
+  c.harvest.start();
+  c.egress.start();
+  c.capture.onEvent(onCaptureEvent);
+  try {
+    document.addEventListener("mouseout", onExitIntent);
+  } catch (e) {
+  }
+  if (c.config.debug) console.debug("[sightspool] started", c.sessionRef);
+}
+function init(config) {
+  try {
+    if (!config || !config.key) {
+      console.warn("[sightspool] init: a `key` is required");
+      return;
+    }
+    if (ctrl) return;
+    const endpoint = config.endpoint || DEFAULT_ENDPOINT;
+    const privacyOpts = { redact: config.redact, block: config.block };
+    const capture = createCapture({ debug: !!config.debug, ...privacyOpts });
+    const harvest = createHarvest(capture, { debug: !!config.debug, ...privacyOpts });
+    const egress = createEgress({ key: config.key, endpoint, debug: !!config.debug });
+    ctrl = {
+      config: {
+        ...config,
+        key: config.key,
+        endpoint,
+        boundaryAsk: config.boundaryAsk !== false,
+        debug: !!config.debug
+      },
+      capture,
+      harvest,
+      egress,
+      identity: {},
+      sessionRef: uuid(),
+      fatigue: { promptsShown: 0, lastPromptAt: null },
+      lastFrictionEmitAt: 0,
+      eventTimer: null,
+      running: false,
+      suppressed: isLocalhost(currentHostname()) && config.captureOnLocalhost !== true
+    };
+    if (config.consent !== false) startRuntime(ctrl);
+  } catch (err) {
+    try {
+      console.warn("[sightspool] init failed", err);
+    } catch (e) {
+    }
+  }
+}
+function identify(userId, traits) {
+  try {
+    if (!ctrl) return;
+    ctrl.identity = { userId, account: traits == null ? void 0 : traits.account, plan: traits == null ? void 0 : traits.plan };
+    ctrl.egress.setIdentity(ctrl.identity);
+  } catch (e) {
+  }
+}
+function start() {
+  try {
+    if (ctrl) startRuntime(ctrl);
+  } catch (e) {
+  }
+}
+function consent(granted) {
+  try {
+    if (!ctrl) return;
+    if (granted) startRuntime(ctrl);
+    else stop();
+  } catch (e) {
+  }
+}
+function stop() {
+  try {
+    if (!ctrl) return;
+    ctrl.running = false;
+    ctrl.capture.stop();
+    ctrl.harvest.stop();
+    ctrl.egress.stop();
+    try {
+      document.removeEventListener("mouseout", onExitIntent);
+    } catch (e) {
+    }
+  } catch (e) {
+  }
+}
+var api = { init, identify, start, stop, consent };
+var src_default = api;
+var _a;
+try {
+  if (typeof document !== "undefined") {
+    const el = (_a = document.currentScript) != null ? _a : document.querySelector("script[data-sightspool-key]");
+    const key = el == null ? void 0 : el.getAttribute("data-sightspool-key");
+    if (key) {
+      let endpoint = (el == null ? void 0 : el.getAttribute("data-sightspool-endpoint")) || void 0;
+      if (!endpoint && (el == null ? void 0 : el.src)) {
+        try {
+          endpoint = new URL(el.src).origin;
+        } catch (e) {
+        }
+      }
+      const list = (attr) => {
+        const raw = el == null ? void 0 : el.getAttribute(attr);
+        if (!raw) return void 0;
+        const out = raw.split(",").map((s) => s.trim()).filter(Boolean);
+        return out.length ? out : void 0;
+      };
+      init({
+        key,
+        endpoint,
+        redact: list("data-sightspool-redact"),
+        block: list("data-sightspool-block"),
+        captureOnLocalhost: (el == null ? void 0 : el.hasAttribute("data-sightspool-capture-localhost")) || void 0,
+        debug: (el == null ? void 0 : el.hasAttribute("data-sightspool-debug")) || void 0
+      });
+    }
+  }
+} catch (e) {
+}
+
+exports.consent = consent;
+exports.default = src_default;
+exports.identify = identify;
+exports.init = init;
+exports.start = start;
+exports.stop = stop;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map