@obsrviq/tracker 0.3.0

package/dist/index.js

@@ -0,0 +1,1827 @@
+import { gzipSync } from 'fflate';
+import { record } from 'rrweb';
+
+// src/transport.ts
+var MAX_BUFFER_EVENTS = 5e3;
+var Transport = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.buffer = [];
+    this.sending = false;
+    this.retryDelay = 1e3;
+    this.stopped = false;
+    this.onVisibility = () => {
+      if (document.visibilityState === "hidden") void this.flush("hidden");
+    };
+    this.onPageHide = () => {
+      void this.flush("pagehide");
+    };
+    this.seq = opts.startSeq ?? 0;
+  }
+  start() {
+    this.timer = setInterval(() => void this.flush("timer"), this.opts.flushIntervalMs);
+    document.addEventListener("visibilitychange", this.onVisibility, { capture: true });
+    window.addEventListener("pagehide", this.onPageHide, { capture: true });
+  }
+  enqueue(event) {
+    if (this.stopped) return;
+    this.buffer.push(event);
+    if (this.buffer.length >= MAX_BUFFER_EVENTS) {
+      void this.flush("backpressure");
+      if (this.buffer.length >= MAX_BUFFER_EVENTS) {
+        this.buffer = this.buffer.filter((e, i) => e.type !== "dom" || i % 2 === 0);
+      }
+    }
+  }
+  /** Build, compress, and send the current buffer. Returns true on success. */
+  async flush(reason) {
+    if (this.sending || this.buffer.length === 0) return true;
+    this.sending = true;
+    const events = this.buffer;
+    this.buffer = [];
+    let batch = {
+      siteKey: this.opts.siteKey,
+      sessionId: this.opts.sessionId,
+      seq: this.seq,
+      meta: this.opts.getMeta(),
+      events
+    };
+    if (this.opts.beforeSend) {
+      try {
+        batch = this.opts.beforeSend(batch);
+      } catch {
+        batch = null;
+      }
+    }
+    if (!batch) {
+      this.sending = false;
+      return true;
+    }
+    this.opts.onSeqDispatch?.(this.seq + 1);
+    const json = JSON.stringify(batch);
+    const gz = gzipSync(new TextEncoder().encode(json));
+    const ok = await this.send(gz, reason === "pagehide" || reason === "hidden");
+    this.opts.onFlush?.({ bytes: gz.byteLength, events: events.length, ok });
+    if (ok) {
+      this.seq++;
+      this.retryDelay = 1e3;
+      this.sending = false;
+      return true;
+    }
+    this.buffer = events.slice(-MAX_BUFFER_EVENTS).concat(this.buffer);
+    this.sending = false;
+    if (!this.stopped) {
+      const jitter = this.retryDelay * (0.5 + Math.random());
+      this.retryDelay = Math.min(this.retryDelay * 2, 3e4);
+      setTimeout(() => void this.flush("timer"), jitter);
+    }
+    return false;
+  }
+  async send(bytes, unloading) {
+    const url = `${this.opts.endpoint.replace(/\/$/, "")}/v1/batch`;
+    const headers = {
+      "content-type": "application/octet-stream",
+      "x-obsrviq-key": this.opts.siteKey
+    };
+    const body = bytes;
+    if (unloading) {
+      const blob = new Blob([bytes], { type: "application/octet-stream" });
+      if (typeof navigator.sendBeacon === "function") {
+        try {
+          if (navigator.sendBeacon(url, blob)) return true;
+        } catch {
+        }
+      }
+      try {
+        void fetch(url, { method: "POST", body, headers, keepalive: true, credentials: "omit", mode: "cors" }).catch(
+          () => {
+          }
+        );
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const ctrl = new AbortController();
+    const timeout = setTimeout(() => ctrl.abort(), 15e3);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        body,
+        headers,
+        credentials: "omit",
+        mode: "cors",
+        signal: ctrl.signal
+      });
+      return res.ok;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    document.removeEventListener("visibilitychange", this.onVisibility, { capture: true });
+    window.removeEventListener("pagehide", this.onPageHide, { capture: true });
+    void this.flush("manual");
+  }
+};
+
+// src/util.ts
+function uuid() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var Clock = class {
+  /** @param resumeStartedAt epoch ms of the original session start when RESUMING a
+   *  continued session; omit for a fresh session.
+   *  @param floorT highest `t` the prior page reached — guarantees this page's
+   *  timeline starts after it, so a backward wall-clock jump between loads can't
+   *  produce overlapping timestamps (which would corrupt replay ordering). */
+  constructor(resumeStartedAt, floorT) {
+    const wallNow = Date.now();
+    this.startedAt = resumeStartedAt ?? wallNow;
+    this.perfStart = typeof performance !== "undefined" ? performance.now() : 0;
+    this.baseT = Math.max(0, wallNow - this.startedAt, floorT ?? 0);
+  }
+  /** ms since the (original) session start — the master clock `t`. */
+  now() {
+    const p = typeof performance !== "undefined" ? performance.now() : Date.now() - this.startedAt;
+    return Math.max(0, this.baseT + Math.round(p - this.perfStart));
+  }
+  /** wall-clock epoch ms for display (`ts`). */
+  wall() {
+    return Date.now();
+  }
+  /** Convert a performance-timeline timestamp (since timeOrigin) to session t. */
+  fromPerf(perfTs) {
+    return Math.max(0, this.baseT + Math.round(perfTs - this.perfStart));
+  }
+};
+async function sha256Hex(input) {
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+    return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  let h = 0;
+  for (let i = 0; i < input.length; i++) h = Math.imul(31, h) + input.charCodeAt(i) | 0;
+  return (h >>> 0).toString(16);
+}
+function detectDevice() {
+  const ua = navigator.userAgent;
+  const viewport = { w: window.innerWidth, h: window.innerHeight };
+  let type = "desktop";
+  if (/iPad|Tablet/i.test(ua)) type = "tablet";
+  else if (/Mobi|Android|iPhone/i.test(ua)) type = "mobile";
+  let os;
+  if (/Windows/i.test(ua)) os = "Windows";
+  else if (/Mac OS X|Macintosh/i.test(ua)) os = "macOS";
+  else if (/Android/i.test(ua)) os = "Android";
+  else if (/iPhone|iPad|iOS/i.test(ua)) os = "iOS";
+  else if (/Linux/i.test(ua)) os = "Linux";
+  let browser;
+  if (/Edg\//.test(ua)) browser = "Edge";
+  else if (/Chrome\//.test(ua)) browser = "Chrome";
+  else if (/Firefox\//.test(ua)) browser = "Firefox";
+  else if (/Safari\//.test(ua)) browser = "Safari";
+  return { type, os, browser, viewport };
+}
+function privacySignalsOptOut() {
+  const nav = navigator;
+  if (nav.globalPrivacyControl === true) return true;
+  if (nav.doNotTrack === "1" || window.doNotTrack === "1") return true;
+  return false;
+}
+
+// src/recorder.ts
+var INCREMENTAL = 3;
+function instrumentDom(ctx) {
+  const stop = record({
+    emit(event) {
+      const dom = {
+        id: uuid(),
+        sessionId: ctx.sessionId,
+        type: "dom",
+        t: ctx.clock.fromPerf(performanceNow()),
+        ts: ctx.clock.wall(),
+        data: event
+      };
+      ctx.emit(dom);
+      if (event.type === INCREMENTAL) ctx.markActivity();
+    },
+    maskAllInputs: ctx.config.maskAllInputs,
+    // Password inputs stay masked even in no-privacy mode (maskAllInputs:false) —
+    // a hard floor so recordings never store plaintext passwords.
+    maskInputOptions: { password: true },
+    maskTextSelector: ctx.config.maskTextSelector,
+    blockSelector: ctx.config.blockSelector,
+    recordCanvas: ctx.config.recordCanvas,
+    // Periodic full snapshots → the player can start replay from the nearest
+    // checkpoint, enabling progressive buffering + reliable seeking (§8.6).
+    checkoutEveryNms: 3e4,
+    sampling: {
+      // Don't record every mousemove point; sample for a smaller payload.
+      mousemove: 50,
+      scroll: 150,
+      input: "last"
+    }
+  });
+  return () => {
+    try {
+      stop?.();
+    } catch {
+    }
+  };
+}
+function performanceNow() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+
+// src/mask.ts
+var EMAIL = /[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/gi;
+var CC = /\b(?:\d[ -]*?){13,19}\b/g;
+var SSN = /\b\d{3}-\d{2}-\d{4}\b/g;
+var LONG_DIGITS = /\b\d{9,}\b/g;
+var SENSITIVE_KEYS = /(pass(word)?|secret|token|api[-_]?key|authorization|cookie|ssn|card|cvv|pin|otp)/i;
+function maskString(input) {
+  return input.replace(EMAIL, "\xABemail\xBB").replace(CC, (m) => luhnish(m) ? "\xABcard\xBB" : m).replace(SSN, "\xABssn\xBB").replace(LONG_DIGITS, "\xABnumber\xBB");
+}
+function luhnish(s) {
+  const digits = s.replace(/\D/g, "");
+  return digits.length >= 13 && digits.length <= 19;
+}
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.test(key);
+}
+function maskValue(value, depth = 0) {
+  if (depth > 6) return "\xABdepth\xBB";
+  if (typeof value === "string") return maskString(value);
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v) => maskValue(v, depth + 1));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = isSensitiveKey(k) ? "\xABredacted\xBB" : maskValue(v, depth + 1);
+  }
+  return out;
+}
+
+// src/serialize.ts
+var DEFAULT_MAX_BYTES = 8 * 1024;
+function byteLen(s) {
+  return new Blob([s]).size;
+}
+function truncate(s, maxBytes) {
+  if (byteLen(s) <= maxBytes) return { value: s, truncated: false };
+  const approx = Math.max(16, Math.floor(maxBytes * 0.95));
+  return { value: s.slice(0, approx), truncated: true };
+}
+function serializeArg(arg, maxBytes = DEFAULT_MAX_BYTES) {
+  if (arg === null) return { kind: "primitive", value: null };
+  const type = typeof arg;
+  if (type === "number" || type === "boolean") {
+    return { kind: "primitive", value: arg };
+  }
+  if (type === "string") {
+    const masked = maskString(arg);
+    const { value, truncated } = truncate(masked, maxBytes);
+    return { kind: "string", value, truncated };
+  }
+  if (arg instanceof Error) {
+    return {
+      kind: "error",
+      name: arg.name,
+      message: maskString(arg.message),
+      stack: arg.stack ? maskString(arg.stack) : void 0
+    };
+  }
+  if (arg instanceof Element) {
+    return { kind: "dom", selector: cssPath(arg) };
+  }
+  if (type === "object" || type === "function" || type === "symbol" || type === "bigint") {
+    const masked = maskValue(arg);
+    let json;
+    let truncated = false;
+    try {
+      const full = JSON.stringify(masked, safeReplacer());
+      const cut = truncate(full ?? "undefined", maxBytes);
+      json = cut.value;
+      truncated = cut.truncated;
+    } catch {
+      json = void 0;
+    }
+    return { kind: "object", preview: previewOf(masked), json, truncated };
+  }
+  return { kind: "primitive", value: String(arg) };
+}
+function safeReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "bigint") return `${value.toString()}n`;
+    if (typeof value === "function") return `\u0192 ${value.name || "anonymous"}`;
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "\xABcircular\xBB";
+      seen.add(value);
+    }
+    return value;
+  };
+}
+function previewOf(value) {
+  if (Array.isArray(value)) return `Array(${value.length})`;
+  if (value && typeof value === "object") {
+    const keys = Object.keys(value);
+    const head = keys.slice(0, 4).join(", ");
+    return `{ ${head}${keys.length > 4 ? ", \u2026" : ""} }`;
+  }
+  return String(value);
+}
+function cssPath(el) {
+  const parts = [];
+  let node = el;
+  let depth = 0;
+  while (node && node.nodeType === 1 && depth < 5) {
+    let part = node.tagName.toLowerCase();
+    if (node.id) {
+      part += `#${node.id}`;
+      parts.unshift(part);
+      break;
+    }
+    const cls = (node.getAttribute("class") || "").trim().split(/\s+/).filter(Boolean)[0];
+    if (cls) part += `.${cls}`;
+    parts.unshift(part);
+    node = node.parentElement;
+    depth++;
+  }
+  return parts.join(" > ");
+}
+function parseSource(stack) {
+  if (!stack) return void 0;
+  const lines = stack.split("\n").map((l) => l.trim());
+  for (const line of lines) {
+    const m = line.match(/\((https?:\/\/[^)]+):(\d+):(\d+)\)/) || line.match(/at (https?:\/\/\S+):(\d+):(\d+)/) || line.match(/(https?:\/\/\S+):(\d+):(\d+)/);
+    if (m) return { url: m[1], line: Number(m[2]), col: Number(m[3]) };
+  }
+  return void 0;
+}
+
+// src/console.ts
+var LEVELS = ["log", "info", "warn", "error", "debug"];
+var MAX_PER_SEC = 100;
+function instrumentConsole(ctx) {
+  const original = {};
+  let windowStart = ctx.clock.now();
+  let inWindow = 0;
+  let suppressed = 0;
+  function rateLimited() {
+    const now = ctx.clock.now();
+    if (now - windowStart >= 1e3) {
+      if (suppressed > 0) {
+        emitConsole("warn", [
+          { kind: "string", value: `Obsrviq: suppressed ${suppressed} console messages (flood cap)` }
+        ]);
+        suppressed = 0;
+      }
+      windowStart = now;
+      inWindow = 0;
+    }
+    if (inWindow >= MAX_PER_SEC) {
+      suppressed++;
+      return true;
+    }
+    inWindow++;
+    return false;
+  }
+  function emitConsole(level, args, stack) {
+    const source = parseSource(stack);
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "console",
+      t: ctx.clock.now(),
+      ts: ctx.clock.wall(),
+      level,
+      args,
+      stack: level === "error" ? stack : void 0,
+      source
+    };
+    ctx.emit(e);
+  }
+  for (const level of LEVELS) {
+    const orig = console[level];
+    original[level] = orig;
+    console[level] = (...args) => {
+      try {
+        orig.apply(console, args);
+      } catch {
+      }
+      try {
+        if (rateLimited()) return;
+        const serialized = args.map((a) => serializeArg(a, ctx.config.maxArgBytes));
+        let stack;
+        if (level === "error") {
+          const errArg = args.find((a) => a instanceof Error);
+          stack = errArg?.stack ?? new Error().stack;
+        }
+        emitConsole(level, serialized, stack);
+      } catch {
+      }
+    };
+  }
+  return () => {
+    for (const level of LEVELS) {
+      if (original[level]) console[level] = original[level];
+    }
+  };
+}
+function errorToConsoleEvent(ctx, err) {
+  return {
+    id: uuid(),
+    sessionId: ctx.sessionId,
+    type: "console",
+    t: err.t,
+    ts: err.ts,
+    level: "error",
+    args: [{ kind: "error", name: err.name, message: err.message, stack: err.stack }],
+    stack: err.stack,
+    source: err.source
+  };
+}
+
+// src/network.ts
+var BODY_CAP = 4 * 1024;
+var HEADER_ALLOW = /* @__PURE__ */ new Set([
+  "content-type",
+  "content-length",
+  "accept",
+  "accept-encoding",
+  "cache-control",
+  "etag",
+  "last-modified",
+  "content-encoding",
+  "x-request-id",
+  "x-correlation-id",
+  "server",
+  "vary"
+]);
+function redactUrl(raw) {
+  try {
+    const u = new URL(raw, location.href);
+    if (u.search) u.search = "?\u2026";
+    return u.toString();
+  } catch {
+    return raw.split("?")[0] ?? raw;
+  }
+}
+function classifyHttp(status) {
+  if (status === 0) return "network";
+  if (status >= 500) return "http_5xx";
+  if (status >= 400) return "http_4xx";
+  return void 0;
+}
+function pickHeaders(redact, entries) {
+  const out = {};
+  const redactSet = new Set(redact.map((h) => h.toLowerCase()));
+  for (const [k, v] of entries) {
+    const key = k.toLowerCase();
+    if (redactSet.has(key)) out[key] = "redacted";
+    else if (HEADER_ALLOW.has(key)) out[key] = v;
+  }
+  return out;
+}
+function bodyPreview(text, contentType) {
+  if (text == null) return void 0;
+  const masked = maskString(text);
+  const truncated = masked.length > BODY_CAP;
+  return {
+    contentType,
+    preview: truncated ? masked.slice(0, BODY_CAP) : masked,
+    truncated,
+    redacted: masked !== text
+  };
+}
+function enrichTiming(ctx, url, base) {
+  try {
+    const entries = performance.getEntriesByType("resource");
+    const match = entries.filter((e) => e.name === url).pop();
+    if (!match) return base;
+    const t = { ...base };
+    if (match.domainLookupEnd && match.domainLookupStart)
+      t.dns = Math.max(0, match.domainLookupEnd - match.domainLookupStart);
+    if (match.connectEnd && match.connectStart)
+      t.tcp = Math.max(0, match.connectEnd - match.connectStart);
+    if (match.secureConnectionStart)
+      t.tls = Math.max(0, match.connectEnd - match.secureConnectionStart);
+    if (match.responseStart && match.requestStart)
+      t.ttfb = Math.max(0, match.responseStart - match.requestStart);
+    if (match.responseEnd && match.responseStart)
+      t.download = Math.max(0, match.responseEnd - match.responseStart);
+    return t;
+  } catch {
+    return base;
+  }
+}
+function instrumentNetwork(ctx) {
+  const teardowns = [];
+  teardowns.push(wrapFetch(ctx));
+  teardowns.push(wrapXhr(ctx));
+  teardowns.push(wrapBeacon(ctx));
+  teardowns.push(observeResources(ctx));
+  return () => teardowns.forEach((t) => t());
+}
+function wrapFetch(ctx) {
+  const orig = window.fetch;
+  if (!orig) return () => {
+  };
+  window.fetch = async function(input, init) {
+    const rawUrl = input instanceof Request ? input.url : String(input);
+    if (rawUrl.includes("/v1/batch")) return orig.call(window, input, init);
+    const startT = ctx.clock.now();
+    const method = (init?.method || (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const url = redactUrl(rawUrl);
+    const reqHeaders = pickHeaders(
+      ctx.config.redactHeaders,
+      headerEntries(init?.headers ?? (input instanceof Request ? input.headers : void 0))
+    );
+    const emit = (partial) => {
+      const endT = ctx.clock.now();
+      const timing = enrichTiming(ctx, rawUrl, { startT, endT, duration: endT - startT });
+      const ev = {
+        id: uuid(),
+        sessionId: ctx.sessionId,
+        type: "network",
+        t: startT,
+        ts: ctx.clock.wall(),
+        initiator: "fetch",
+        method,
+        url,
+        status: 0,
+        ok: false,
+        resourceType: "fetch",
+        requestHeaders: reqHeaders,
+        timing,
+        ...partial
+      };
+      ctx.emit(ev);
+      ctx.markActivity();
+    };
+    try {
+      const res = await orig.call(window, input, init);
+      const status = res.status;
+      const respHeaders = pickHeaders(ctx.config.redactHeaders, res.headers.entries());
+      const len = res.headers.get("content-length");
+      let responseBody;
+      if (ctx.config.captureNetworkBodies && isTexty(res.headers.get("content-type"))) {
+        try {
+          const text = await res.clone().text();
+          responseBody = bodyPreview(text, res.headers.get("content-type") || void 0);
+        } catch {
+        }
+      }
+      emit({
+        status,
+        ok: res.ok,
+        responseSize: len ? Number(len) : void 0,
+        responseHeaders: respHeaders,
+        requestBody: ctx.config.captureNetworkBodies ? bodyPreview(stringifyBody(init?.body), void 0) : void 0,
+        responseBody,
+        error: classifyHttp(status)
+      });
+      return res;
+    } catch (err) {
+      emit({ status: 0, ok: false, error: classifyFetchError(err) });
+      throw err;
+    }
+  };
+  return () => {
+    window.fetch = orig;
+  };
+}
+function classifyFetchError(err) {
+  const name = err?.name;
+  if (name === "AbortError") return "aborted";
+  const msg = String(err?.message || "").toLowerCase();
+  if (msg.includes("cors")) return "cors";
+  if (msg.includes("timeout")) return "timeout";
+  return "network";
+}
+function wrapXhr(ctx) {
+  const XHR = XMLHttpRequest.prototype;
+  const origOpen = XHR.open;
+  const origSend = XHR.send;
+  const origSetHeader = XHR.setRequestHeader;
+  const META = /* @__PURE__ */ new WeakMap();
+  XHR.open = function(method, url, ...rest) {
+    const rawUrl = String(url);
+    META.set(this, {
+      method: String(method).toUpperCase(),
+      rawUrl,
+      url: redactUrl(rawUrl),
+      startT: 0,
+      reqHeaders: {}
+    });
+    return origOpen.apply(this, [method, url, ...rest]);
+  };
+  XHR.setRequestHeader = function(name, value) {
+    const meta = META.get(this);
+    if (meta) {
+      const key = name.toLowerCase();
+      if (ctx.config.redactHeaders.map((h) => h.toLowerCase()).includes(key))
+        meta.reqHeaders[key] = "redacted";
+      else if (HEADER_ALLOW.has(key)) meta.reqHeaders[key] = value;
+    }
+    return origSetHeader.apply(this, [name, value]);
+  };
+  XHR.send = function(body) {
+    const meta = META.get(this);
+    if (meta) {
+      meta.startT = ctx.clock.now();
+      if (ctx.config.captureNetworkBodies) meta.body = stringifyBody(body);
+      const finish = (error) => {
+        const endT = ctx.clock.now();
+        const timing = enrichTiming(ctx, meta.rawUrl, {
+          startT: meta.startT,
+          endT,
+          duration: endT - meta.startT
+        });
+        const status = this.status;
+        const respHeaders = parseRawHeaders(ctx, this.getAllResponseHeaders());
+        let responseBody;
+        if (ctx.config.captureNetworkBodies && isTexty(this.getResponseHeader("content-type"))) {
+          try {
+            if (this.responseType === "" || this.responseType === "text") {
+              responseBody = bodyPreview(this.responseText, this.getResponseHeader("content-type") || void 0);
+            }
+          } catch {
+          }
+        }
+        const ev = {
+          id: uuid(),
+          sessionId: ctx.sessionId,
+          type: "network",
+          t: meta.startT,
+          ts: ctx.clock.wall(),
+          initiator: "xhr",
+          method: meta.method,
+          url: meta.url,
+          status,
+          ok: status >= 200 && status < 400,
+          resourceType: "xhr",
+          requestHeaders: meta.reqHeaders,
+          responseHeaders: respHeaders,
+          responseSize: safeLen(this),
+          requestBody: ctx.config.captureNetworkBodies ? bodyPreview(meta.body, void 0) : void 0,
+          responseBody,
+          timing,
+          error: error || classifyHttp(status)
+        };
+        ctx.emit(ev);
+        ctx.markActivity();
+      };
+      this.addEventListener("loadend", () => finish());
+      this.addEventListener("error", () => finish("network"));
+      this.addEventListener("timeout", () => finish("timeout"));
+      this.addEventListener("abort", () => finish("aborted"));
+    }
+    return origSend.apply(this, [body]);
+  };
+  return () => {
+    XHR.open = origOpen;
+    XHR.send = origSend;
+    XHR.setRequestHeader = origSetHeader;
+  };
+}
+function safeLen(xhr) {
+  try {
+    if (xhr.responseType === "" || xhr.responseType === "text")
+      return new Blob([xhr.responseText]).size;
+  } catch {
+  }
+  const len = xhr.getResponseHeader("content-length");
+  return len ? Number(len) : void 0;
+}
+function parseRawHeaders(ctx, raw) {
+  const entries = [];
+  for (const line of raw.trim().split(/[\r\n]+/)) {
+    const idx = line.indexOf(":");
+    if (idx > 0) entries.push([line.slice(0, idx).trim(), line.slice(idx + 1).trim()]);
+  }
+  return pickHeaders(ctx.config.redactHeaders, entries);
+}
+function wrapBeacon(ctx) {
+  const orig = navigator.sendBeacon;
+  if (!orig) return () => {
+  };
+  navigator.sendBeacon = function(url, data) {
+    const startT = ctx.clock.now();
+    let ok = false;
+    try {
+      ok = orig.call(navigator, url, data);
+    } finally {
+      const u = String(url);
+      if (!u.includes("/v1/batch")) {
+        const ev = {
+          id: uuid(),
+          sessionId: ctx.sessionId,
+          type: "network",
+          t: startT,
+          ts: ctx.clock.wall(),
+          initiator: "beacon",
+          method: "POST",
+          url: redactUrl(u),
+          status: ok ? 202 : 0,
+          ok,
+          resourceType: "other",
+          timing: { startT, endT: ctx.clock.now(), duration: 0 },
+          error: ok ? void 0 : "network"
+        };
+        ctx.emit(ev);
+      }
+    }
+    return ok;
+  };
+  return () => {
+    navigator.sendBeacon = orig;
+  };
+}
+var RESOURCE_TYPE_MAP = {
+  script: "script",
+  link: "stylesheet",
+  css: "stylesheet",
+  img: "image",
+  image: "image",
+  font: "font",
+  audio: "media",
+  video: "media",
+  track: "media"
+};
+function observeResources(ctx) {
+  if (typeof PerformanceObserver === "undefined") return () => {
+  };
+  let obs;
+  try {
+    obs = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        const it = entry.initiatorType;
+        if (it === "fetch" || it === "xmlhttprequest" || it === "beacon") continue;
+        const resourceType = RESOURCE_TYPE_MAP[it] || "other";
+        const startT = ctx.clock.fromPerf(entry.startTime);
+        const endT = ctx.clock.fromPerf(entry.responseEnd || entry.startTime);
+        const timing = {
+          startT,
+          endT,
+          duration: Math.max(0, endT - startT),
+          dns: nz(entry.domainLookupEnd - entry.domainLookupStart),
+          tcp: nz(entry.connectEnd - entry.connectStart),
+          tls: entry.secureConnectionStart ? nz(entry.connectEnd - entry.secureConnectionStart) : void 0,
+          ttfb: nz(entry.responseStart - entry.requestStart),
+          download: nz(entry.responseEnd - entry.responseStart)
+        };
+        const ev = {
+          id: uuid(),
+          sessionId: ctx.sessionId,
+          type: "network",
+          t: startT,
+          ts: ctx.clock.wall(),
+          initiator: "resource",
+          method: "GET",
+          url: redactUrl(entry.name),
+          status: entry.responseStatus || 200,
+          ok: !entry.responseStatus || entry.responseStatus < 400,
+          resourceType,
+          responseSize: entry.transferSize || entry.encodedBodySize || void 0,
+          timing
+        };
+        ctx.emit(ev);
+      }
+    });
+    obs.observe({ type: "resource", buffered: true });
+  } catch {
+    return () => {
+    };
+  }
+  return () => obs?.disconnect();
+}
+function nz(n) {
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : void 0;
+}
+function isTexty(contentType) {
+  if (!contentType) return false;
+  return /json|text|xml|x-www-form-urlencoded/i.test(contentType);
+}
+function stringifyBody(body) {
+  if (body == null) return void 0;
+  if (typeof body === "string") return body;
+  if (body instanceof URLSearchParams) return body.toString();
+  if (body instanceof FormData) {
+    const obj = {};
+    body.forEach((v, k) => obj[k] = typeof v === "string" ? v : "\xABfile\xBB");
+    return JSON.stringify(obj);
+  }
+  try {
+    return JSON.stringify(body);
+  } catch {
+    return void 0;
+  }
+}
+function headerEntries(headers) {
+  if (!headers) return [];
+  if (headers instanceof Headers) return headers.entries();
+  if (Array.isArray(headers)) return headers;
+  return Object.entries(headers);
+}
+
+// src/errors.ts
+function instrumentErrors(ctx) {
+  function emitError(args) {
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "error",
+      t: ctx.clock.now(),
+      ts: ctx.clock.wall(),
+      name: args.name,
+      message: maskString(args.message),
+      stack: args.stack ? maskString(args.stack) : void 0,
+      source: args.source,
+      handled: args.handled
+    };
+    ctx.emit(e);
+    ctx.emit(errorToConsoleEvent(ctx, e));
+  }
+  const onError = (ev) => {
+    const err = ev.error;
+    emitError({
+      name: err?.name || "Error",
+      message: err?.message || ev.message || "Unknown error",
+      stack: err?.stack,
+      source: { url: ev.filename, line: ev.lineno, col: ev.colno },
+      handled: false
+    });
+  };
+  const onRejection = (ev) => {
+    const reason = ev.reason;
+    if (reason instanceof Error) {
+      emitError({
+        name: reason.name,
+        message: reason.message,
+        stack: reason.stack,
+        source: parseSource(reason.stack),
+        handled: false
+      });
+    } else {
+      emitError({
+        name: "UnhandledRejection",
+        message: typeof reason === "string" ? reason : safeStringify(reason),
+        handled: false
+      });
+    }
+  };
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onRejection, true);
+  return () => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onRejection, true);
+  };
+}
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
+
+// src/vitals.ts
+function rate(metric, value) {
+  const t = {
+    LCP: [2500, 4e3],
+    INP: [200, 500],
+    CLS: [0.1, 0.25],
+    FCP: [1800, 3e3],
+    TTFB: [800, 1800]
+  };
+  const pair = t[metric];
+  if (!pair) return void 0;
+  if (value <= pair[0]) return "good";
+  if (value <= pair[1]) return "needs-improvement";
+  return "poor";
+}
+function instrumentVitals(ctx) {
+  if (typeof PerformanceObserver === "undefined") return () => {
+  };
+  const observers = [];
+  const emit = (metric, value, detail) => {
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "perf",
+      t: ctx.clock.now(),
+      ts: ctx.clock.wall(),
+      metric,
+      value: Math.round(value * 1e3) / 1e3,
+      rating: rate(metric, value),
+      detail
+    };
+    ctx.emit(e);
+  };
+  const obs = (type, cb, extra) => {
+    try {
+      const o = new PerformanceObserver((list) => cb(list.getEntries()));
+      o.observe({ type, buffered: true, ...extra });
+      observers.push(o);
+    } catch {
+    }
+  };
+  obs("paint", (entries) => {
+    for (const e of entries) if (e.name === "first-contentful-paint") emit("FCP", e.startTime);
+  });
+  let lcp = 0;
+  obs("largest-contentful-paint", (entries) => {
+    const last = entries[entries.length - 1];
+    if (last) lcp = last.startTime;
+  });
+  let cls = 0;
+  obs("layout-shift", (entries) => {
+    for (const e of entries) {
+      if (!e.hadRecentInput) cls += e.value;
+    }
+  });
+  let inp = 0;
+  obs(
+    "event",
+    (entries) => {
+      for (const e of entries) {
+        if (e.duration > inp) inp = e.duration;
+      }
+    },
+    { durationThreshold: 40 }
+  );
+  obs("navigation", (entries) => {
+    const nav = entries[0];
+    if (!nav) return;
+    emit("TTFB", nav.responseStart);
+    emit("navigation", nav.duration, {
+      domInteractive: Math.round(nav.domInteractive),
+      domComplete: Math.round(nav.domComplete),
+      loadEvent: Math.round(nav.loadEventEnd)
+    });
+  });
+  const flushFinal = () => {
+    if (lcp) emit("LCP", lcp);
+    emit("CLS", cls);
+    if (inp) emit("INP", inp);
+  };
+  const onHide = () => {
+    if (document.visibilityState === "hidden") flushFinal();
+  };
+  document.addEventListener("visibilitychange", onHide, true);
+  return () => {
+    observers.forEach((o) => o.disconnect());
+    document.removeEventListener("visibilitychange", onHide, true);
+  };
+}
+
+// src/interactions.ts
+var RAGE_WINDOW_MS = 1e3;
+var RAGE_THRESHOLD = 3;
+var DEAD_WAIT_MS = 3e3;
+function isInteractive(el) {
+  if (!el) return false;
+  let node = el;
+  for (let i = 0; i < 4 && node; i++) {
+    const tag = node.tagName.toLowerCase();
+    if (["a", "button", "input", "select", "textarea", "label", "summary"].includes(tag))
+      return true;
+    if (node.getAttribute("role") === "button" || node.hasAttribute("onclick")) return true;
+    if (node.getAttribute("contenteditable") === "true") return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+function instrumentInteractions(ctx) {
+  let recent = [];
+  let lastRageAt = -Infinity;
+  const emitCustom = (name, props, t) => {
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "custom",
+      t,
+      ts: ctx.clock.wall(),
+      name,
+      props
+    };
+    ctx.emit(e);
+  };
+  const onClick = (ev) => {
+    const target = ev.target;
+    if (!target || !(target instanceof Element)) return;
+    const t = ctx.clock.now();
+    const selector = cssPath(target);
+    recent = recent.filter((r) => t - r.t <= RAGE_WINDOW_MS);
+    recent.push({ el: target, t });
+    const sameTarget = recent.filter((r) => r.el === target);
+    if (sameTarget.length >= RAGE_THRESHOLD && t - lastRageAt > RAGE_WINDOW_MS) {
+      lastRageAt = t;
+      emitCustom("rage_click", { selector, count: sameTarget.length }, t);
+    }
+    if (!isInteractive(target)) {
+      const before = ctx.lastActivityT();
+      window.setTimeout(() => {
+        if (ctx.lastActivityT() <= Math.max(before, t)) {
+          emitCustom("dead_click", { selector }, t);
+        }
+      }, DEAD_WAIT_MS);
+    }
+  };
+  window.addEventListener("click", onClick, true);
+  return () => window.removeEventListener("click", onClick, true);
+}
+
+// src/forms.ts
+var TRACKED = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
+var SKIP_INPUT_TYPES = /* @__PURE__ */ new Set(["hidden", "submit", "button", "reset", "image", "file"]);
+var MAX_KEY = 80;
+var MAX_FOCUS_MS = 3e5;
+var MIN_FOCUS_MS = 100;
+function isTracked(el) {
+  if (!(el instanceof HTMLElement) || !TRACKED.has(el.tagName)) return false;
+  if (el instanceof HTMLInputElement && SKIP_INPUT_TYPES.has(el.type)) return false;
+  return true;
+}
+function controlType(el) {
+  if (el instanceof HTMLTextAreaElement) return "textarea";
+  if (el instanceof HTMLSelectElement) return "select";
+  return el.type || "text";
+}
+function isFilled(el) {
+  if (el instanceof HTMLInputElement) {
+    if (el.type === "checkbox" || el.type === "radio") return el.checked;
+    return el.value.trim().length > 0;
+  }
+  if (el instanceof HTMLSelectElement) return el.value !== "";
+  return el.value.trim().length > 0;
+}
+function clip(s) {
+  const t = s.trim().replace(/\s+/g, " ");
+  return t.length > MAX_KEY ? t.slice(0, MAX_KEY) : t;
+}
+function fieldKey(el) {
+  const name = el.getAttribute("name");
+  if (name) return clip(name);
+  if (el.id) return clip(el.id);
+  const aria = el.getAttribute("aria-label");
+  if (aria) return clip(aria);
+  const labelledby = el.getAttribute("aria-labelledby");
+  if (labelledby) {
+    const lbl = labelledby.split(/\s+/).map((id) => el.ownerDocument.getElementById(id)?.textContent || "").join(" ").trim();
+    if (lbl) return clip(lbl);
+  }
+  if (el.labels && el.labels.length) {
+    const lbl = el.labels[0].textContent?.trim();
+    if (lbl) return clip(lbl);
+  }
+  const ph = el.getAttribute("placeholder");
+  if (ph) return clip(ph);
+  return clip(cssPath(el));
+}
+function formKey(el) {
+  const form = el.form;
+  if (form) {
+    if (form.getAttribute("name")) return clip(form.getAttribute("name"));
+    if (form.id) return clip(form.id);
+    const aria = form.getAttribute("aria-label");
+    if (aria) return clip(aria);
+    const action = form.getAttribute("action");
+    if (action) {
+      try {
+        return clip(new URL(action, location.href).pathname);
+      } catch {
+        return clip(action);
+      }
+    }
+    return clip(cssPath(form));
+  }
+  return clip(`page:${location.pathname}`);
+}
+function instrumentForms(ctx) {
+  const block = ctx.config.blockSelector;
+  let focused = null;
+  const emit = (name, props) => {
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "custom",
+      t: ctx.clock.now(),
+      ts: ctx.clock.wall(),
+      name,
+      props
+    };
+    ctx.emit(e);
+  };
+  const blocked = (el) => {
+    try {
+      return !!block && !!el.closest(block);
+    } catch {
+      return false;
+    }
+  };
+  const flush = () => {
+    if (!focused) return;
+    const { el, start, changed } = focused;
+    focused = null;
+    const ms = Math.min(MAX_FOCUS_MS, Math.max(0, ctx.clock.now() - start));
+    if (ms < MIN_FOCUS_MS && !changed) return;
+    emit("form_field", {
+      form: formKey(el),
+      field: fieldKey(el),
+      type: controlType(el),
+      ms,
+      changed,
+      filled: isFilled(el)
+    });
+  };
+  const onFocusIn = (ev) => {
+    const el = ev.target;
+    if (!isTracked(el) || blocked(el)) return;
+    if (focused && focused.el !== el) flush();
+    focused = { el, start: ctx.clock.now(), changed: false };
+  };
+  const onInput = (ev) => {
+    if (focused && ev.target === focused.el) focused.changed = true;
+  };
+  const onFocusOut = (ev) => {
+    if (focused && ev.target === focused.el) flush();
+  };
+  const onSubmit = (ev) => {
+    const form = ev.target;
+    if (!(form instanceof HTMLFormElement) || blocked(form)) return;
+    flush();
+    const probe = form.querySelector("input,textarea,select");
+    const key = probe && !blocked(probe) ? formKey(probe) : clip(form.getAttribute("name") || form.id || cssPath(form));
+    emit("form_submit", { form: key });
+  };
+  document.addEventListener("focusin", onFocusIn, true);
+  document.addEventListener("focusout", onFocusOut, true);
+  document.addEventListener("input", onInput, true);
+  document.addEventListener("submit", onSubmit, true);
+  window.addEventListener("pagehide", flush, true);
+  return () => {
+    flush();
+    document.removeEventListener("focusin", onFocusIn, true);
+    document.removeEventListener("focusout", onFocusOut, true);
+    document.removeEventListener("input", onInput, true);
+    document.removeEventListener("submit", onSubmit, true);
+    window.removeEventListener("pagehide", flush, true);
+  };
+}
+
+// src/scroll.ts
+function instrumentScrollDepth(ctx) {
+  let path = location.pathname;
+  let maxBand = 0;
+  let scheduled = false;
+  const emit = (depth) => {
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "custom",
+      t: ctx.clock.now(),
+      ts: ctx.clock.wall(),
+      name: "_scroll",
+      props: { path, depth }
+    };
+    ctx.emit(e);
+  };
+  const docHeight = () => {
+    const d = document.documentElement;
+    const b = document.body;
+    return Math.max(d.scrollHeight, b ? b.scrollHeight : 0, d.clientHeight) || 1;
+  };
+  const measure = () => {
+    scheduled = false;
+    if (location.pathname !== path) {
+      path = location.pathname;
+      maxBand = 0;
+    }
+    const vh = window.innerHeight || document.documentElement.clientHeight || 1;
+    const reached = Math.min(1, (window.scrollY + vh) / docHeight());
+    const band = Math.min(100, Math.round(reached * 10) * 10);
+    if (band > maxBand) {
+      maxBand = band;
+      emit(band);
+    }
+  };
+  const onScroll = () => {
+    if (scheduled) return;
+    scheduled = true;
+    requestAnimationFrame(measure);
+  };
+  window.addEventListener("scroll", onScroll, { passive: true, capture: true });
+  measure();
+  return () => {
+    window.removeEventListener("scroll", onScroll, true);
+  };
+}
+
+// src/pageviews.ts
+function instrumentPageviews(ctx) {
+  let lastPath = null;
+  const currentPath = () => {
+    const hash = location.hash;
+    return location.pathname + (hash.startsWith("#/") ? hash : "");
+  };
+  const fire = () => {
+    const path = currentPath();
+    if (path === lastPath) return;
+    const referrer = lastPath ?? "";
+    lastPath = path;
+    const e = {
+      id: uuid(),
+      sessionId: ctx.sessionId,
+      type: "pageview",
+      t: ctx.clock.now(),
+      ts: ctx.clock.wall(),
+      url: location.href,
+      path,
+      title: document.title || void 0,
+      referrer: referrer || void 0
+    };
+    ctx.emit(e);
+    ctx.markActivity();
+  };
+  const origPush = history.pushState;
+  const origReplace = history.replaceState;
+  const wrap = (orig) => function patched(data, unused, url) {
+    const ret = orig.call(this, data, unused, url);
+    queueMicrotask(fire);
+    return ret;
+  };
+  history.pushState = wrap(origPush);
+  history.replaceState = wrap(origReplace);
+  window.addEventListener("popstate", fire);
+  window.addEventListener("hashchange", fire);
+  fire();
+  return () => {
+    history.pushState = origPush;
+    history.replaceState = origReplace;
+    window.removeEventListener("popstate", fire);
+    window.removeEventListener("hashchange", fire);
+  };
+}
+
+// src/ui.ts
+function blockClassFrom(blockSelector) {
+  const m = /\.([A-Za-z0-9_-]+)/.exec(blockSelector || "");
+  const derived = m && m[1] ? m[1] : "";
+  return ["obsrviq-block", derived].filter(Boolean).join(" ");
+}
+function makeHost(blockSelector) {
+  const host = document.createElement("div");
+  host.className = blockClassFrom(blockSelector);
+  host.setAttribute("data-obsrviq-ui", "");
+  host.style.cssText = "all:initial";
+  const root = host.attachShadow({ mode: "open" });
+  return { host, root };
+}
+function adopt(root, css) {
+  try {
+    const sheet = new CSSStyleSheet();
+    sheet.replaceSync(css);
+    root.adoptedStyleSheets = [sheet];
+  } catch {
+    const style = document.createElement("style");
+    style.textContent = css;
+    root.appendChild(style);
+  }
+}
+function mount(host) {
+  (document.body || document.documentElement).appendChild(host);
+}
+var ACCENT = "#6e76f1";
+var CONSENT_CSS = `
+:host { all: initial; }
+.card {
+  position: fixed; bottom: 20px; right: 20px; z-index: 2147483647;
+  max-width: 340px; box-sizing: border-box;
+  display: grid; grid-template-columns: auto 1fr;
+  grid-template-areas: 'dot txt' 'actions actions'; gap: 9px 12px; padding: 16px 18px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+  color: #f4f5fb; background: #14151b; border: 1px solid rgba(255,255,255,.08);
+  border-radius: 14px; box-shadow: 0 16px 48px rgba(0,0,0,.5);
+  opacity: 0; transform: translateY(10px); transition: opacity .22s ease, transform .22s ease;
+}
+.card.in { opacity: 1; transform: none; }
+.dot { grid-area: dot; width: 9px; height: 9px; margin-top: 5px; border-radius: 50%;
+  background: ${ACCENT}; box-shadow: 0 0 0 4px rgba(110,118,241,.18); }
+.txt { grid-area: txt; min-width: 0; }
+.title { font-size: 13.5px; font-weight: 600; line-height: 1.35; }
+.body { margin-top: 3px; font-size: 12px; line-height: 1.45; color: #a9adbe; }
+.actions { grid-area: actions; display: flex; gap: 8px; justify-content: flex-end; margin-top: 2px; }
+button { font: inherit; font-size: 12.5px; font-weight: 600; padding: 7px 15px; border-radius: 9px;
+  cursor: pointer; border: 1px solid transparent; transition: background .15s ease, color .15s ease; }
+.deny { background: transparent; color: #a9adbe; border-color: rgba(255,255,255,.14); }
+.deny:hover { color: #f4f5fb; background: rgba(255,255,255,.05); }
+.allow { background: ${ACCENT}; color: #fff; }
+.allow:hover { background: #5a62e0; }
+button:focus-visible { outline: 2px solid ${ACCENT}; outline-offset: 2px; }
+@media (prefers-reduced-motion: reduce) { .card { transition: none; } }
+@media (max-width: 480px) { .card { left: 16px; right: 16px; bottom: 16px; max-width: none; } }
+`;
+var DOT_CSS = `
+:host { all: initial; }
+.recdot {
+  position: fixed; bottom: 16px; right: 16px; z-index: 2147483647;
+  width: 12px; height: 12px; border-radius: 50%;
+  background: #ef4444; box-shadow: 0 0 0 0 rgba(239,68,68,.5);
+  animation: lum-pulse 2s ease-out infinite;
+}
+@keyframes lum-pulse {
+  0%   { box-shadow: 0 0 0 0 rgba(239,68,68,.5); }
+  70%  { box-shadow: 0 0 0 9px rgba(239,68,68,0); }
+  100% { box-shadow: 0 0 0 0 rgba(239,68,68,0); }
+}
+@media (prefers-reduced-motion: reduce) { .recdot { animation: none; } }
+`;
+function showConsent(blockSelector, text, onAllow, onDeny) {
+  const { host, root } = makeHost(blockSelector);
+  adopt(root, CONSENT_CSS);
+  const t = text ?? {};
+  const card = document.createElement("div");
+  card.className = "card";
+  card.setAttribute("role", "dialog");
+  card.setAttribute("aria-label", t.title || "Session recording consent");
+  const dot = document.createElement("div");
+  dot.className = "dot";
+  dot.setAttribute("aria-hidden", "true");
+  const txt = document.createElement("div");
+  txt.className = "txt";
+  const title = document.createElement("div");
+  title.className = "title";
+  title.textContent = t.title || "We record this session to improve the experience.";
+  const body = document.createElement("div");
+  body.className = "body";
+  body.textContent = t.body || "No passwords or typed input are captured.";
+  txt.append(title, body);
+  const actions = document.createElement("div");
+  actions.className = "actions";
+  const deny = document.createElement("button");
+  deny.type = "button";
+  deny.className = "deny";
+  deny.textContent = t.deny || "Decline";
+  const allow = document.createElement("button");
+  allow.type = "button";
+  allow.className = "allow";
+  allow.textContent = t.allow || "Allow";
+  actions.append(deny, allow);
+  card.append(dot, txt, actions);
+  root.appendChild(card);
+  mount(host);
+  requestAnimationFrame(() => card.classList.add("in"));
+  let done = false;
+  const unmount = () => {
+    if (host.parentNode) host.parentNode.removeChild(host);
+  };
+  const choose = (fn) => () => {
+    if (done) return;
+    done = true;
+    unmount();
+    fn();
+  };
+  allow.addEventListener("click", choose(onAllow));
+  deny.addEventListener("click", choose(onDeny));
+  return unmount;
+}
+function showRecordingDot(blockSelector) {
+  const { host, root } = makeHost(blockSelector);
+  adopt(root, DOT_CSS);
+  const dot = document.createElement("div");
+  dot.className = "recdot";
+  dot.setAttribute("role", "status");
+  dot.setAttribute("aria-label", "Session recording in progress");
+  root.appendChild(dot);
+  mount(host);
+  return () => {
+    if (host.parentNode) host.parentNode.removeChild(host);
+  };
+}
+
+// src/storage.ts
+var VISITOR_KEY = "obsrviq.visitor";
+var SESSION_KEY = "obsrviq.session";
+function readSession() {
+  const raw = readLS(SESSION_KEY);
+  if (!raw) return null;
+  try {
+    const p = JSON.parse(raw);
+    if (p && typeof p.id === "string" && p.id && typeof p.startedAt === "number") {
+      return {
+        id: p.id,
+        startedAt: p.startedAt,
+        lastActivity: typeof p.lastActivity === "number" ? p.lastActivity : p.startedAt,
+        seq: typeof p.seq === "number" && p.seq >= 0 ? p.seq : 0,
+        lastT: typeof p.lastT === "number" && p.lastT >= 0 ? p.lastT : void 0,
+        userId: typeof p.userId === "string" ? p.userId : void 0
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function writeSession(rec) {
+  writeLS(SESSION_KEY, JSON.stringify(rec));
+}
+function clearSession() {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.removeItem(SESSION_KEY);
+  } catch {
+  }
+}
+function readLS(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeLS(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function registerVisit(now) {
+  let rec = null;
+  const raw = readLS(VISITOR_KEY);
+  if (raw) {
+    try {
+      const p = JSON.parse(raw);
+      if (p && typeof p.id === "string" && p.id) {
+        rec = {
+          id: p.id,
+          firstSeenAt: typeof p.firstSeenAt === "number" ? p.firstSeenAt : now,
+          lastSeenAt: typeof p.lastSeenAt === "number" ? p.lastSeenAt : now,
+          visits: typeof p.visits === "number" && p.visits > 0 ? p.visits : 1
+        };
+      }
+    } catch {
+    }
+  }
+  const next = rec ? { ...rec, visits: rec.visits + 1, lastSeenAt: now } : { id: uuid(), firstSeenAt: now, lastSeenAt: now, visits: 1 };
+  writeLS(VISITOR_KEY, JSON.stringify(next));
+  return next;
+}
+
+// src/index.ts
+var DEFAULTS = {
+  maskAllInputs: true,
+  blockSelector: ".obsrviq-block",
+  noPrivacy: false,
+  captureNetworkBodies: false,
+  redactHeaders: ["authorization", "cookie", "set-cookie"],
+  sampleRate: 1,
+  recordCanvas: false,
+  endpoint: "https://in.lumera.app",
+  flushIntervalMs: 5e3,
+  continueSession: false,
+  sessionTimeoutMs: 30 * 60 * 1e3,
+  requireConsent: false,
+  askPermission: false,
+  showRecording: false,
+  maxArgBytes: 8 * 1024
+};
+var ObsrviqClient = class {
+  constructor() {
+    this.config = null;
+    this.clock = null;
+    this.transport = null;
+    this.teardowns = [];
+    this.meta = null;
+    this.recording = false;
+    this.consent = null;
+    this.sampledIn = true;
+    this.lastActivity = 0;
+    /** Next batch seq — mirrored from the transport so we can persist continuation. */
+    this.nextSeq = 0;
+    /** Open task spans keyed by task name → the span id + start time, so endTask()
+     *  can pair with its startTask(). Re-starting the same name supersedes the
+     *  earlier open span (the player pairs by spanId, so this only affects which
+     *  start an unqualified end() resolves to). */
+    this.openTasks = /* @__PURE__ */ new Map();
+    this.consentUnmount = null;
+    this.recDotUnmount = null;
+    this.diag = {
+      recording: false,
+      sessionId: null,
+      flushes: 0,
+      bytesSent: 0,
+      eventsSent: 0,
+      eventsQueued: 0
+    };
+  }
+  /** The current session id (null until init). */
+  get sessionId() {
+    return this.diag.sessionId;
+  }
+  init(config) {
+    if (this.config) return;
+    if (!config.siteKey) {
+      console.warn("[obsrviq] init() called without siteKey \u2014 recording disabled.");
+      return;
+    }
+    this.config = { ...DEFAULTS, ...stripUndefined(config) };
+    if (this.config.noPrivacy && config.maskAllInputs === void 0) {
+      this.config.maskAllInputs = false;
+    }
+    if (this.config.askPermission) this.config.requireConsent = true;
+    this.startSession();
+    if (config.userId != null) this.applyUserId(config.userId);
+    if (config.metadata && this.meta) this.meta.metadata = { ...config.metadata };
+    if (privacySignalsOptOut()) {
+      this.consent = false;
+      return;
+    }
+    if (this.config.requireConsent) {
+      if (this.config.askPermission) {
+        this.consentUnmount = showConsent(
+          this.config.blockSelector,
+          this.config.consentText,
+          () => this.setConsent(true),
+          () => this.setConsent(false)
+        );
+      }
+    } else {
+      this.maybeStart();
+    }
+  }
+  /** (Re)create the session id, clock, meta, and transport. Used by init() and
+   *  reset(). Does not start recording — callers decide via maybeStart().
+   *  @param seedInitUser seed identity from the init-time `cfg.userId`. True for
+   *  the initial init() session; FALSE for reset() (logout) — otherwise the fresh
+   *  post-logout session would be re-attributed to the user who just logged out. */
+  startSession(seedInitUser = true) {
+    const cfg = this.config;
+    const now = Date.now();
+    let resume = null;
+    if (cfg.continueSession) {
+      const rec = readSession();
+      if (rec && now - rec.lastActivity < cfg.sessionTimeoutMs && !(cfg.userId != null && rec.userId != null && rec.userId !== String(cfg.userId))) {
+        resume = rec;
+      }
+    }
+    const sessionId = resume ? resume.id : uuid();
+    this.clock = resume ? new Clock(resume.startedAt, resume.lastT) : new Clock();
+    this.currentUserId = resume?.userId ?? (seedInitUser && cfg.userId != null ? String(cfg.userId) : void 0);
+    this.nextSeq = resume ? resume.seq : 0;
+    this.diag.sessionId = sessionId;
+    this.meta = {
+      startedAt: this.clock.startedAt,
+      entryUrl: location.href,
+      device: detectDevice()
+    };
+    this.sampledIn = resume ? true : Math.random() < (cfg.sampleRate ?? 1);
+    this.transport = new Transport({
+      endpoint: cfg.endpoint,
+      siteKey: cfg.siteKey,
+      sessionId,
+      getMeta: () => this.meta ?? void 0,
+      beforeSend: cfg.beforeSend,
+      flushIntervalMs: cfg.flushIntervalMs,
+      startSeq: this.nextSeq,
+      onSeqDispatch: (next) => {
+        this.nextSeq = next;
+        this.persistSession();
+      },
+      onFlush: ({ bytes, events, ok }) => {
+        if (ok) {
+          this.diag.flushes++;
+          this.diag.bytesSent += bytes;
+          this.diag.eventsSent += events;
+        }
+      }
+    });
+    this.recording = false;
+    this.diag.recording = false;
+  }
+  /** Persist the session-continuation record (no-op unless continueSession). Only
+   *  ever writes for a RECORDING session — a sampled-out or pre-consent session must
+   *  not leave a record that a later page would resume (and force back into
+   *  recording), and identify() can fire before recording starts. */
+  persistSession() {
+    if (!this.config?.continueSession || !this.recording || !this.clock || !this.diag.sessionId) return;
+    writeSession({
+      id: this.diag.sessionId,
+      startedAt: this.clock.startedAt,
+      lastActivity: Date.now(),
+      seq: this.nextSeq,
+      lastT: this.clock.now(),
+      userId: this.currentUserId
+    });
+  }
+  maybeStart() {
+    if (this.recording || !this.config || !this.clock || !this.transport) return;
+    if (this.config.requireConsent && this.consent !== true) return;
+    if (this.consent === false) return;
+    if (!this.sampledIn) return;
+    if (this.meta && this.meta.visitorId == null) {
+      const visit = registerVisit(Date.now());
+      this.meta.visitorId = visit.id;
+      this.meta.visitCount = visit.visits;
+      this.meta.firstSeenAt = visit.firstSeenAt;
+    }
+    const ctx = {
+      clock: this.clock,
+      sessionId: this.diag.sessionId,
+      config: this.config,
+      emit: (e) => {
+        this.transport.enqueue(e);
+        this.diag.eventsQueued++;
+      },
+      markActivity: () => {
+        this.lastActivity = this.clock.now();
+      },
+      lastActivityT: () => this.lastActivity
+    };
+    this.transport.start();
+    this.teardowns.push(instrumentConsole(ctx));
+    this.teardowns.push(instrumentNetwork(ctx));
+    this.teardowns.push(instrumentErrors(ctx));
+    this.teardowns.push(instrumentVitals(ctx));
+    this.teardowns.push(instrumentInteractions(ctx));
+    this.teardowns.push(instrumentForms(ctx));
+    this.teardowns.push(instrumentScrollDepth(ctx));
+    this.teardowns.push(instrumentPageviews(ctx));
+    this.teardowns.push(instrumentDom(ctx));
+    this.recording = true;
+    this.diag.recording = true;
+    this.persistSession();
+    if (this.config.showRecording && !this.recDotUnmount) {
+      this.recDotUnmount = showRecordingDot(this.config.blockSelector);
+    }
+  }
+  /** Associate the session with an application user. Stores the RAW userId (for
+   *  search + display) AND a SHA-256 identityHash, merges any traits into metadata,
+   *  and force-flushes so the live session is retro-stamped promptly. Safe to call
+   *  before recording starts (values ride the first batch) and after login. */
+  identify(userId, traits) {
+    if (!this.meta) return;
+    const uid = String(userId);
+    if (this.config?.continueSession && this.currentUserId != null && this.currentUserId !== uid) {
+      this.reset();
+    }
+    this.currentUserId = uid;
+    this.applyUserId(uid);
+    if (traits) this.mergeMetadata(traits);
+    this.track("identify", { hasTraits: !!traits });
+    void this.flush();
+    this.persistSession();
+  }
+  /** Merge custom properties onto the session at any time (searchable server-side). */
+  setMetadata(props) {
+    if (!this.meta) return;
+    this.mergeMetadata(props);
+    this.track("metadata", { keys: Object.keys(props) });
+    void this.flush();
+  }
+  /** Forget the current identity (e.g. on logout) and rotate to a fresh anonymous
+   *  session, so post-logout activity isn't attributed to the prior user. (Identity
+   *  can't be cleared on the existing row — the server merge only fills nulls — so
+   *  we start a new session instead.) */
+  reset() {
+    if (!this.config) return;
+    const wasRecording = this.recording;
+    if (this.recording) this.teardown();
+    clearSession();
+    this.currentUserId = void 0;
+    this.startSession(false);
+    if (wasRecording && this.consent !== false && !privacySignalsOptOut()) this.maybeStart();
+  }
+  /** Set the raw userId on meta and compute its hash (async). */
+  applyUserId(userId) {
+    const raw = String(userId);
+    if (this.meta) this.meta.userId = raw;
+    void sha256Hex(raw).then((hash) => {
+      if (this.meta && this.meta.userId === raw) this.meta.identityHash = hash;
+    });
+  }
+  mergeMetadata(props) {
+    if (!this.meta) return;
+    this.meta.metadata = { ...this.meta.metadata ?? {}, ...props };
+  }
+  /** Emit a custom event (e.g. conversions). */
+  track(name, props) {
+    if (!this.recording || !this.clock || !this.transport) return;
+    this.transport.enqueue({
+      id: uuid(),
+      sessionId: this.diag.sessionId,
+      type: "custom",
+      t: this.clock.now(),
+      ts: this.clock.wall(),
+      name,
+      props
+    });
+    this.diag.eventsQueued++;
+  }
+  /** Mark a conversion. Conversion is client-defined, so the NAME matters —
+   *  "checkout", "signup", "trial_started" — and each is denormalised onto the
+   *  session for per-client filtering. Sets props.conversion so the legacy
+   *  'conversion' flag still lights up. Sugar over track(name, {conversion:true}). */
+  conversion(name, props) {
+    const clean = String(name).trim();
+    if (!clean) return;
+    this.track(clean, { ...props, conversion: true });
+  }
+  /** Attach one or more free-form, searchable labels to the current session.
+   *  Tags are session-level (deduped server-side) — use them to slice sessions
+   *  however a client likes ("vip", "ab_variant_b", "mobile_app"). */
+  tag(...names) {
+    const clean = names.map((n) => String(n).trim()).filter(Boolean);
+    if (!clean.length) return;
+    this.track("_tag", { tags: clean });
+    void this.flush();
+  }
+  /** Begin a named sub-event span. Pairs with end() / endTask(name) to produce a
+   *  searchable, duration-bearing span on the session timeline. Returns a handle
+   *  so callers can `const t = Obsrviq.startTask('checkout'); …; t.end()`. */
+  startTask(name, props) {
+    const clean = String(name).trim();
+    const spanId = uuid();
+    const startT = this.clock ? this.clock.now() : 0;
+    if (clean) {
+      this.openTasks.set(clean, { spanId, startT });
+      this.track(`${clean}:started`, { ...props, spanId, task: clean });
+    }
+    return { end: (endProps) => this.endTask(clean, endProps) };
+  }
+  /** Close a named sub-event span opened by startTask(name). Safe to call even
+   *  if the start was never seen (renders as an orphan end on the timeline). */
+  endTask(name, props) {
+    const clean = String(name).trim();
+    if (!clean) return;
+    const open = this.openTasks.get(clean);
+    this.openTasks.delete(clean);
+    const spanId = open?.spanId ?? uuid();
+    this.track(`${clean}:ended`, {
+      ...props,
+      spanId,
+      task: clean,
+      ...open ? { startT: open.startT } : {}
+    });
+  }
+  /** Gate recording (PRIV-2). true starts; false stops + flushes. Dismisses the
+   *  built-in consent prompt if one is showing. */
+  setConsent(granted) {
+    this.consent = granted;
+    this.consentUnmount?.();
+    this.consentUnmount = null;
+    if (granted) this.maybeStart();
+    else if (this.recording) this.teardown();
+  }
+  /** Hard stop + flush. */
+  stop() {
+    this.teardown();
+  }
+  /** Force a flush now (returns when send is attempted). */
+  flush() {
+    return this.transport ? this.transport.flush("manual") : Promise.resolve(true);
+  }
+  getDiagnostics() {
+    return { ...this.diag };
+  }
+  teardown() {
+    for (const t of this.teardowns.splice(0)) {
+      try {
+        t();
+      } catch {
+      }
+    }
+    this.recDotUnmount?.();
+    this.recDotUnmount = null;
+    this.transport?.stop();
+    this.recording = false;
+    this.diag.recording = false;
+  }
+};
+function stripUndefined(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+var Obsrviq = new ObsrviqClient();
+var src_default = Obsrviq;
+
+export { Obsrviq, src_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map