@offscript/sdk 0.0.0-stage → 0.1.1

package/dist/chunk-3NX2AGXM.cjs

@@ -0,0 +1,2671 @@
+'use strict';
+
+var chunkB6GO5FE5_cjs = require('./chunk-B6GO5FE5.cjs');
+
+// src/types/config.ts
+var DEFAULT_RECORDING = {
+  rrweb: true,
+  actions: true,
+  http: true,
+  console: true,
+  errors: true,
+  context: true,
+  iframes: true,
+  mouseMove: false,
+  consoleLevels: ["log", "info", "warn", "error"],
+  throttleMs: 100,
+  rrwebCheckoutEveryMs: 5 * 6e4,
+  rrwebRecordCanvas: false,
+  testIdAttributes: ["data-testid", "data-test", "data-cy", "data-qa"],
+  stableAttributes: ["name", "data-id", "aria-label"]
+};
+var DEFAULT_PRIVACY = {
+  maskSensitiveInputs: true,
+  maskAllText: false,
+  captureRequestBodies: false,
+  captureResponseBodies: false,
+  allowedInputSelectors: ["[data-offscript-allow]"],
+  captureChoiceValues: true,
+  blockSelectors: ["[data-offscript-block]", ".offscript-block"],
+  maskTextSelectors: ["[data-offscript-mask]", ".offscript-mask"],
+  ignoreSelectors: ["[data-offscript-ignore]", ".offscript-ignore"],
+  ignoreUrls: [],
+  redactHeaders: [],
+  redactKeys: [],
+  maxBodyBytes: 16 * 1024,
+  textContentTypes: [/^text\//i, /json/i, /xml/i, /x-www-form-urlencoded/i, /javascript/i],
+  localRetentionMs: 24 * 36e5
+};
+var DEFAULT_TRANSPORT = {
+  batchMaxEvents: 200,
+  batchMaxBytes: 512 * 1024,
+  flushIntervalMs: 3e3,
+  maxMemoryEvents: 5e3,
+  maxBufferBytes: 64 * 1024 * 1024,
+  maxRetries: 6,
+  retryBaseMs: 500,
+  retryMaxMs: 3e4,
+  compress: false,
+  keepaliveMaxBytes: 60 * 1024,
+  persist: true,
+  requestTimeoutMs: 15e3
+};
+
+// src/utils/misc.ts
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function debounce(fn, ms) {
+  let timer;
+  let args;
+  const d = ((...a) => {
+    args = a;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      const x = args;
+      args = void 0;
+      if (x) fn(...x);
+    }, ms);
+  });
+  d.cancel = () => {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+    args = void 0;
+  };
+  d.flush = () => {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = void 0;
+    const x = args;
+    args = void 0;
+    if (x) fn(...x);
+  };
+  return d;
+}
+function approxSize(value) {
+  try {
+    return JSON.stringify(value)?.length ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  if (!patch) return out;
+  for (const [k, v] of Object.entries(patch)) if (v !== void 0) out[k] = v;
+  return out;
+}
+var Disposer = class {
+  constructor() {
+    this.fns = [];
+  }
+  add(fn) {
+    this.fns.push(fn);
+  }
+  listen(target, type, handler, opts) {
+    target.addEventListener(type, handler, opts);
+    this.fns.push(() => target.removeEventListener(type, handler, opts));
+  }
+  dispose() {
+    const fns = this.fns;
+    this.fns = [];
+    for (const fn of fns.reverse()) safe(fn);
+  }
+};
+
+// src/privacy/PrivacyConfig.ts
+function resolvePrivacy(user) {
+  return deepMerge(DEFAULT_PRIVACY, user);
+}
+var BASE_SENSITIVE_HEADERS = [
+  "authorization",
+  "proxy-authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "x-session-token"
+];
+var BASE_SENSITIVE_KEY_PATTERN = /pass(word|wd)?|senha|secret|token|auth|bearer|api[-_]?key|apikey|credential|session|cookie|jwt|signature|private|cvv|cvc|card[-_]?(number|num)|cartao|cpf|cnpj|ssn|otp|pin$/i;
+
+// src/privacy/DataSanitizer.ts
+var REDACTED = "[REDACTED]";
+var JWT = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*\b/g;
+var BEARER = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi;
+var CPF = /\b\d{3}\.\d{3}\.\d{3}-\d{2}\b/g;
+var CNPJ = /\b\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}\b/g;
+var CARD = /\b(?:\d[ -]?){13,19}\b/g;
+function luhn(digits) {
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (alt) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+var DataSanitizer = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.headerSet = /* @__PURE__ */ new Set([...BASE_SENSITIVE_HEADERS, ...cfg.redactHeaders.map((h) => h.toLowerCase())]);
+    this.extraKeys = new Set(cfg.redactKeys.map((k) => k.toLowerCase()));
+  }
+  isSensitiveKey(key) {
+    return BASE_SENSITIVE_KEY_PATTERN.test(key) || this.extraKeys.has(key.toLowerCase());
+  }
+  /** Mascara padrões sensíveis em texto livre (JWT, Bearer, CPF, CNPJ, cartões). */
+  scrubString(input) {
+    if (!input) return input;
+    let s = input.replace(JWT, REDACTED).replace(BEARER, (_m, scheme) => `${scheme} ${REDACTED}`);
+    s = s.replace(CNPJ, REDACTED).replace(CPF, REDACTED);
+    s = s.replace(CARD, (m) => {
+      const digits = m.replace(/[ -]/g, "");
+      return digits.length >= 13 && digits.length <= 19 && luhn(digits) ? REDACTED : m;
+    });
+    return s;
+  }
+  sanitizeHeaders(headers) {
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+      out[k] = this.headerSet.has(k.toLowerCase()) || this.isSensitiveKey(k) ? REDACTED : this.scrubString(v);
+    }
+    return out;
+  }
+  /** Redige query params sensíveis e credenciais embutidas (user:pass@). */
+  sanitizeUrl(raw, base) {
+    try {
+      const u = new URL(raw, base ?? (typeof location !== "undefined" ? location.href : void 0));
+      if (u.username || u.password) {
+        u.username = "";
+        u.password = "";
+      }
+      for (const key of Array.from(new Set(u.searchParams.keys()))) {
+        if (this.isSensitiveKey(key)) u.searchParams.set(key, REDACTED);
+        else u.searchParams.set(key, this.scrubString(u.searchParams.get(key) ?? ""));
+      }
+      if (u.hash && /(access_token|id_token|token|code)=/i.test(u.hash)) u.hash = `#${REDACTED}`;
+      return u.toString();
+    } catch {
+      return this.scrubString(raw);
+    }
+  }
+  /** Redige query/fragmento de um valor de atributo de URL preservando a forma original (relativa ou absoluta). */
+  redactUrlAttribute(value) {
+    if (typeof value !== "string" || !/[?#@]/.test(value)) return value;
+    const hashAt = value.indexOf("#");
+    const hash = hashAt >= 0 ? value.slice(hashAt) : "";
+    const noHash = hashAt >= 0 ? value.slice(0, hashAt) : value;
+    const q = noHash.indexOf("?");
+    let base = q >= 0 ? noHash.slice(0, q) : noHash;
+    base = base.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, "$1");
+    let query = "";
+    if (q >= 0) {
+      const params = new URLSearchParams(noHash.slice(q + 1));
+      for (const k of Array.from(new Set(params.keys()))) {
+        if (this.isSensitiveKey(k)) params.set(k, REDACTED);
+        else params.set(k, this.scrubString(params.get(k) ?? ""));
+      }
+      query = `?${params.toString()}`;
+    }
+    return base + query + (hash && /(access_token|id_token|token|code)=/i.test(hash) ? `#${REDACTED}` : hash);
+  }
+  parseQuery(raw) {
+    try {
+      const u = new URL(raw, typeof location !== "undefined" ? location.href : void 0);
+      const out = {};
+      u.searchParams.forEach((v, k) => {
+        const val = this.isSensitiveKey(k) ? REDACTED : this.scrubString(v);
+        const prev = out[k];
+        out[k] = prev === void 0 ? val : Array.isArray(prev) ? [...prev, val] : [prev, val];
+      });
+      return Object.keys(out).length ? out : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Redação profunda de objetos (chaves sensíveis + padrões em strings). */
+  sanitizeValue(value, depth = 0) {
+    if (depth > 8) return "[Truncated]";
+    if (typeof value === "string") return this.scrubString(value);
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.slice(0, 200).map((v) => this.sanitizeValue(v, depth + 1));
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = this.isSensitiveKey(k) ? REDACTED : this.sanitizeValue(v, depth + 1);
+    }
+    return out;
+  }
+  /** Converte um corpo textual em CapturedBody sanitizado, respeitando o limite. */
+  sanitizeTextBody(text, contentType, size = text.length) {
+    const max = this.cfg.maxBodyBytes;
+    const truncated = text.length > max;
+    const slice = truncated ? text.slice(0, max) : text;
+    if (/json/i.test(contentType) && !truncated) {
+      try {
+        return { kind: "json", value: this.sanitizeValue(JSON.parse(slice)), size };
+      } catch {
+      }
+    }
+    if (/x-www-form-urlencoded/i.test(contentType)) {
+      const params = new URLSearchParams(slice);
+      const form = {};
+      params.forEach((v, k) => form[k] = this.isSensitiveKey(k) ? REDACTED : this.scrubString(v));
+      return { kind: "form", value: form, size, truncated };
+    }
+    return { kind: "text", value: this.scrubString(slice), size, truncated };
+  }
+  isTextual(contentType) {
+    return this.cfg.textContentTypes.some((re) => re.test(contentType));
+  }
+  isIgnoredUrl(url) {
+    return this.cfg.ignoreUrls.some((p) => typeof p === "string" ? url.includes(p) : p.test(url));
+  }
+  /** Referência opaca para valores não autorizados. */
+  redactedRef(value, salt) {
+    let h = 2166136261;
+    const s = salt + value;
+    for (let i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+    return `ref_${(h >>> 0).toString(16).padStart(8, "0")}`;
+  }
+  /** Remove valores de atributos de seletor que podem conter dados sensíveis. */
+  sanitizeSelectorCandidates(list) {
+    return list.map((c) => ({ ...c, selector: this.scrubString(c.selector) }));
+  }
+};
+
+// src/utils/errors.ts
+var OffscriptError = class extends Error {
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "OffscriptError";
+    this.code = code;
+    this.status = opts.status;
+    this.cause = opts.cause;
+  }
+};
+var ConfigError = class extends OffscriptError {
+  constructor(message) {
+    super("CONFIG_INVALID", message);
+    this.name = "ConfigError";
+  }
+};
+var AuthError = class extends OffscriptError {
+  constructor(message, status) {
+    super("AUTH_FAILED", message, { status });
+    this.name = "AuthError";
+  }
+};
+var SessionExpiredError = class extends OffscriptError {
+  constructor(message = "Sess\xE3o expirada") {
+    super("SESSION_EXPIRED", message, { status: 410 });
+    this.name = "SessionExpiredError";
+  }
+};
+var SessionDisabledError = class extends OffscriptError {
+  constructor(message = "Grava\xE7\xE3o desativada pelo backend") {
+    super("SESSION_DISABLED", message);
+    this.name = "SessionDisabledError";
+  }
+};
+var InvalidStateError = class extends OffscriptError {
+  constructor(message) {
+    super("INVALID_STATE", message);
+    this.name = "InvalidStateError";
+  }
+};
+var TransportError = class extends OffscriptError {
+  constructor(message, opts) {
+    super("TRANSPORT_FAILED", message, opts);
+    this.name = "TransportError";
+    this.retryable = opts.retryable;
+  }
+};
+var Emitter = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  on(type, fn) {
+    let s = this.handlers.get(type);
+    if (!s) this.handlers.set(type, s = /* @__PURE__ */ new Set());
+    s.add(fn);
+    return () => this.off(type, fn);
+  }
+  off(type, fn) {
+    this.handlers.get(type)?.delete(fn);
+  }
+  emit(type, payload) {
+    for (const fn of Array.from(this.handlers.get(type) ?? [])) {
+      try {
+        fn(payload);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    this.handlers.clear();
+  }
+};
+
+// src/core/ApiClient.ts
+var ORIGINAL_FETCH = "__offscriptOriginal";
+function nativeFetch() {
+  const f = globalThis.fetch;
+  if (!f) throw new TransportError("fetch indispon\xEDvel", { retryable: false });
+  return (f[ORIGINAL_FETCH] ?? f).bind(globalThis);
+}
+var ApiClient = class {
+  constructor(apiUrl, getToken, timeoutMs) {
+    this.apiUrl = apiUrl;
+    this.getToken = getToken;
+    this.timeoutMs = timeoutMs;
+  }
+  get baseUrl() {
+    return this.apiUrl;
+  }
+  createSession(body) {
+    return this.json("POST", "/sdk/sessions", body);
+  }
+  heartbeat(sessionId, body) {
+    return this.json("POST", `/sdk/sessions/${encodeURIComponent(sessionId)}/heartbeat`, body);
+  }
+  complete(sessionId, body) {
+    return this.json("POST", `/sdk/sessions/${encodeURIComponent(sessionId)}/complete`, body);
+  }
+  status(sessionId) {
+    return this.json("GET", `/sdk/sessions/${encodeURIComponent(sessionId)}/status`);
+  }
+  async sendEvents(batch, opts = {}) {
+    const path = `/sdk/sessions/${encodeURIComponent(batch.sessionId)}/events`;
+    return this.json("POST", path, batch, { "Idempotency-Key": batch.batchId }, opts);
+  }
+  async json(method, path, body, extraHeaders = {}, opts = {}) {
+    const headers = {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.getToken()}`,
+      "X-Offscript-Sdk": chunkB6GO5FE5_cjs.SDK_VERSION,
+      ...extraHeaders
+    };
+    let payload;
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      const text = JSON.stringify(body);
+      payload = text;
+      if (opts.compress && !opts.keepalive && text.length > 1024) {
+        const gz = await gzip(text);
+        if (gz) {
+          payload = gz;
+          headers["Content-Encoding"] = "gzip";
+        }
+      }
+    }
+    const ctrl = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    const timer = ctrl && !opts.keepalive ? setTimeout(() => ctrl.abort(), this.timeoutMs) : void 0;
+    let res;
+    try {
+      res = await nativeFetch()(this.apiUrl + path, {
+        method,
+        headers,
+        body: payload,
+        keepalive: opts.keepalive,
+        credentials: "omit",
+        mode: "cors",
+        signal: ctrl?.signal
+      });
+    } catch (e) {
+      throw new TransportError(`Falha de rede: ${e?.message ?? e}`, { retryable: true, cause: e });
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+    if (res.ok) {
+      const text = await res.text();
+      return text ? JSON.parse(text) : {};
+    }
+    const detail = await res.text().catch(() => "");
+    const msg = `HTTP ${res.status} ${method} ${path}${detail ? `: ${detail.slice(0, 200)}` : ""}`;
+    if (res.status === 401 || res.status === 403) throw new AuthError(msg, res.status);
+    if (res.status === 410) throw new SessionExpiredError(msg);
+    const retryAfter = Number(res.headers.get("retry-after"));
+    const err = new TransportError(msg, {
+      status: res.status,
+      retryable: res.status === 408 || res.status === 429 || res.status >= 500
+    });
+    if (retryAfter > 0) err.retryAfterMs = retryAfter * 1e3;
+    throw err;
+  }
+};
+async function gzip(text) {
+  try {
+    const CS = globalThis.CompressionStream;
+    if (!CS) return null;
+    const body = new Response(text).body;
+    if (!body) return null;
+    return new Uint8Array(await new Response(body.pipeThrough(new CS("gzip"))).arrayBuffer());
+  } catch {
+    return null;
+  }
+}
+
+// src/transport/EventQueue.ts
+var EventQueue = class {
+  constructor(maxEvents, maxBytes) {
+    this.maxEvents = maxEvents;
+    this.maxBytes = maxBytes;
+    this.staged = [];
+    this.pendingCount = 0;
+    this.pendingBytes = 0;
+    this.dropped = 0;
+  }
+  canAccept(priority) {
+    const factor = priority === "critical" ? 2 : priority === "normal" ? 1 : 0.5;
+    return this.pendingCount < this.maxEvents * factor && this.pendingBytes < this.maxBytes * factor;
+  }
+  noteDropped() {
+    this.dropped++;
+  }
+  push(e, size) {
+    this.staged.push(e);
+    this.pendingCount++;
+    this.pendingBytes += size;
+  }
+  /** Devolve eventos ao staging sem recontar. */
+  restore(events) {
+    this.staged = [...events, ...this.staged];
+  }
+  takeStaged() {
+    const s = this.staged;
+    this.staged = [];
+    return s;
+  }
+  peekStaged() {
+    return this.staged;
+  }
+  get stagedCount() {
+    return this.staged.length;
+  }
+  acked(count, bytes) {
+    this.pendingCount = Math.max(0, this.pendingCount - count);
+    this.pendingBytes = Math.max(0, this.pendingBytes - bytes);
+  }
+  reset(count, bytes) {
+    this.pendingCount = count;
+    this.pendingBytes = bytes;
+  }
+  get pending() {
+    return this.pendingCount;
+  }
+  get bytes() {
+    return this.pendingBytes;
+  }
+};
+
+// src/transport/RetryManager.ts
+var RetryManager = class {
+  constructor(baseMs, maxMs, random = Math.random) {
+    this.baseMs = baseMs;
+    this.maxMs = maxMs;
+    this.random = random;
+  }
+  delay(attempt) {
+    const cap = Math.min(this.maxMs, this.baseMs * 2 ** Math.max(0, attempt));
+    return Math.round(this.random() * cap);
+  }
+  sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+};
+
+// src/transport/EventTransport.ts
+var EventTransport = class extends Emitter {
+  constructor(cfg, api, buffer) {
+    super();
+    this.cfg = cfg;
+    this.api = api;
+    this.buffer = buffer;
+    this.identity = null;
+    this.running = null;
+    this.again = false;
+    this.failures = 0;
+    this.stopped = true;
+    this.fatal = false;
+    this.online = true;
+    this.lastDroppedReported = 0;
+    this.queue = new EventQueue(cfg.maxMemoryEvents, cfg.maxBufferBytes);
+    this.retry = new RetryManager(cfg.retryBaseMs, cfg.retryMaxMs);
+  }
+  get bufferKind() {
+    return this.buffer.kind;
+  }
+  /** Inicia o transporte para uma sessão/aba e recupera o que ficou pendente no buffer. */
+  async start(identity) {
+    this.identity = identity;
+    this.stopped = false;
+    this.fatal = false;
+    this.failures = 0;
+    const st = await this.buffer.stats(identity.sessionId).catch(() => ({ count: 0, bytes: 0 }));
+    this.queue.reset(st.count, st.bytes);
+    this.scheduleFlush();
+  }
+  setOnline(online) {
+    this.online = online;
+    if (online && !this.stopped) void this.flush();
+  }
+  canAccept(priority) {
+    return !this.stopped && !this.fatal && this.queue.canAccept(priority);
+  }
+  noteDropped() {
+    this.queue.noteDropped();
+    if (this.queue.dropped - this.lastDroppedReported >= 1) {
+      this.lastDroppedReported = this.queue.dropped;
+      this.emit("overflow", { dropped: this.queue.dropped });
+    }
+  }
+  get pending() {
+    return this.queue.pending;
+  }
+  enqueue(event) {
+    if (this.stopped) return;
+    this.queue.push(event, approxSize(event));
+    if (this.queue.stagedCount >= 50) void this.commit();
+    else if (!this.commitTimer) this.commitTimer = setTimeout(() => void this.commit(), 100);
+  }
+  async commit() {
+    if (this.commitTimer) clearTimeout(this.commitTimer);
+    this.commitTimer = void 0;
+    const staged = this.queue.takeStaged();
+    if (!staged.length) return;
+    try {
+      await this.buffer.put(staged);
+    } catch {
+      this.queue.restore(staged);
+      throw new TransportError("Falha ao persistir eventos localmente", { retryable: true });
+    }
+  }
+  scheduleFlush() {
+    if (this.flushTimer || this.stopped) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      void this.flush().finally(() => this.scheduleFlush());
+    }, this.cfg.flushIntervalMs);
+  }
+  /** Flush de melhor esforço. Retorna true se tudo foi confirmado pelo backend. */
+  flush(opts = { inlineRetries: 0 }) {
+    if (this.running) {
+      this.again = true;
+      return this.running;
+    }
+    this.running = (async () => {
+      try {
+        let ok = await this.drain(opts);
+        while (this.again && ok) {
+          this.again = false;
+          ok = await this.drain(opts);
+        }
+        return ok;
+      } finally {
+        this.running = null;
+        this.again = false;
+      }
+    })();
+    return this.running;
+  }
+  /** Flush final com retries inline e prazo máximo. */
+  async flushFinal(maxWaitMs = 1e4) {
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = void 0;
+    const running = this.running;
+    if (running) await running.catch(() => false);
+    const ok = await this.flush({ inlineRetries: this.cfg.maxRetries, deadline: Date.now() + maxWaitMs });
+    return { ok, pending: this.queue.pending };
+  }
+  async drain(opts) {
+    const id = this.identity;
+    if (!id || this.fatal) return false;
+    for (; ; ) {
+      try {
+        await this.commit();
+        const { items } = await this.buffer.peek(id.sessionId, id.tabId, this.cfg.batchMaxEvents, this.cfg.batchMaxBytes);
+        if (!items.length) {
+          this.failures = 0;
+          return true;
+        }
+        const events = items.map((i) => i.event);
+        await this.sendWithRetry(events, opts);
+        await this.buffer.remove(items.map((i) => i.key));
+        this.queue.acked(items.length, items.reduce((n, i) => n + i.size, 0));
+        this.failures = 0;
+      } catch (error) {
+        return this.onFailure(error);
+      }
+    }
+  }
+  onFailure(error) {
+    if (error instanceof AuthError || error instanceof SessionExpiredError) {
+      this.fatal = true;
+      this.emit("fatal", { error });
+      return false;
+    }
+    this.failures++;
+    const retryable = !(error instanceof TransportError) || error.retryable;
+    const willRetryInMs = retryable ? this.retry.delay(this.failures) : void 0;
+    this.emit("failed", { error, willRetryInMs });
+    if (retryable && !this.stopped) {
+      if (this.retryTimer) clearTimeout(this.retryTimer);
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = void 0;
+        void this.flush();
+      }, willRetryInMs);
+    }
+    return false;
+  }
+  async sendWithRetry(events, opts) {
+    const batch = this.buildBatch(events);
+    for (let attempt = 0; ; attempt++) {
+      try {
+        if (!this.online) throw new TransportError("Offline", { retryable: true });
+        const ack = await this.api.sendEvents(batch, { compress: this.cfg.compress });
+        this.emit("flushed", { events: events.length, batchId: batch.batchId, duplicate: !!ack.duplicate });
+        return;
+      } catch (e) {
+        if (e instanceof TransportError && e.status === 413 && events.length > 1) {
+          const mid = Math.ceil(events.length / 2);
+          await this.sendWithRetry(events.slice(0, mid), opts);
+          await this.sendWithRetry(events.slice(mid), opts);
+          return;
+        }
+        const retryable = !(e instanceof TransportError) || e.retryable;
+        if (!retryable || attempt >= opts.inlineRetries) throw e;
+        const wait = Math.max(this.retry.delay(attempt), e.retryAfterMs ?? 0);
+        if (opts.deadline && Date.now() + wait > opts.deadline) throw e;
+        await this.retry.sleep(wait);
+      }
+    }
+  }
+  buildBatch(events) {
+    const id = this.identity;
+    const first = events[0].sequence;
+    const last = events[events.length - 1].sequence;
+    return {
+      schemaVersion: chunkB6GO5FE5_cjs.SCHEMA_VERSION,
+      batchId: `${id.sessionId}.${id.tabId}.${first}-${last}.${events.length}`,
+      sessionId: id.sessionId,
+      executionId: id.executionId,
+      tabId: id.tabId,
+      sequenceStart: first,
+      sequenceEnd: last,
+      createdAt: Date.now(),
+      sdkVersion: chunkB6GO5FE5_cjs.SDK_VERSION,
+      events
+    };
+  }
+  /**
+   * Chamado em pagehide/beforeunload. Persiste o que está em staging (best effort, assíncrono) e
+   * tenta enviar o final da fila com fetch keepalive (limite ~64KB). Sem ACK: os eventos continuam
+   * no IndexedDB e serão reenviados (de forma idempotente) na próxima página.
+   * Não há garantia de entrega se o navegador for encerrado abruptamente.
+   */
+  flushOnUnload() {
+    const id = this.identity;
+    if (!id || this.stopped || this.fatal) return;
+    const staged = this.queue.takeStaged();
+    if (!staged.length) return;
+    safe(() => void this.buffer.put(staged).catch(() => void 0));
+    const events = [];
+    let bytes = 0;
+    for (const e of staged) {
+      const s = approxSize(e);
+      if (bytes + s > this.cfg.keepaliveMaxBytes) break;
+      events.push(e);
+      bytes += s;
+    }
+    if (!events.length) return;
+    safe(() => void this.api.sendEvents(this.buildBatch(events), { keepalive: true }).catch(() => void 0));
+  }
+  /** Para timers; eventos não confirmados permanecem no buffer. */
+  stop() {
+    this.stopped = true;
+    for (const t of [this.commitTimer, this.flushTimer, this.retryTimer]) if (t) clearTimeout(t);
+    this.commitTimer = this.flushTimer = this.retryTimer = void 0;
+  }
+  async clearSession(sessionId) {
+    await this.buffer.clearSession(sessionId).catch(() => void 0);
+    this.queue.reset(0, 0);
+  }
+  async purgeExpired(retentionMs) {
+    await this.buffer.purgeOlderThan(Date.now() - retentionMs).catch(() => void 0);
+  }
+  close() {
+    this.stop();
+    this.buffer.close();
+  }
+};
+
+// src/transport/PersistentBuffer.ts
+var eventKey = (sessionId, tabId, seq) => `${sessionId}|${tabId}|${String(seq).padStart(12, "0")}`;
+var toStored = (e) => ({
+  key: eventKey(e.sessionId, e.tabId, e.sequence),
+  sessionId: e.sessionId,
+  tabId: e.tabId,
+  sequence: e.sequence,
+  storedAt: Date.now(),
+  size: approxSize(e),
+  event: e
+});
+var MemoryBuffer = class {
+  constructor() {
+    this.kind = "memory";
+    this.map = /* @__PURE__ */ new Map();
+  }
+  async put(events) {
+    for (const e of events) {
+      const s = toStored(e);
+      this.map.set(s.key, s);
+    }
+  }
+  async peek(sessionId, tabId, maxEvents, maxBytes) {
+    const prefix = `${sessionId}|${tabId}|`;
+    const keys = Array.from(this.map.keys()).filter((k) => k.startsWith(prefix)).sort();
+    const items = [];
+    let bytes = 0;
+    for (const k of keys) {
+      const s = this.map.get(k);
+      if (items.length >= maxEvents || items.length > 0 && bytes + s.size > maxBytes) break;
+      items.push(s);
+      bytes += s.size;
+    }
+    return { items, bytes };
+  }
+  async remove(keys) {
+    for (const k of keys) this.map.delete(k);
+  }
+  async stats(sessionId) {
+    let count = 0;
+    let bytes = 0;
+    for (const s of this.map.values()) {
+      if (sessionId && s.sessionId !== sessionId) continue;
+      count++;
+      bytes += s.size;
+    }
+    return { count, bytes };
+  }
+  async purgeOlderThan(ts) {
+    let n = 0;
+    for (const [k, s] of this.map) if (s.storedAt < ts) this.map.delete(k), n++;
+    return n;
+  }
+  async clearSession(sessionId) {
+    for (const [k, s] of this.map) if (s.sessionId === sessionId) this.map.delete(k);
+  }
+  close() {
+  }
+};
+var STORE = "events";
+function req(r) {
+  return new Promise((resolve, reject) => {
+    r.onsuccess = () => resolve(r.result);
+    r.onerror = () => reject(r.error);
+  });
+}
+function done(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+  });
+}
+var IndexedDBBuffer = class _IndexedDBBuffer {
+  constructor(db) {
+    this.db = db;
+    this.kind = "indexeddb";
+  }
+  static async open(name) {
+    if (typeof indexedDB === "undefined") throw new Error("IndexedDB indispon\xEDvel");
+    const db = await new Promise((resolve, reject) => {
+      const r = indexedDB.open(name, 1);
+      r.onupgradeneeded = () => {
+        const store = r.result.createObjectStore(STORE, { keyPath: "key" });
+        store.createIndex("bySession", "sessionId");
+        store.createIndex("byStoredAt", "storedAt");
+      };
+      r.onsuccess = () => resolve(r.result);
+      r.onerror = () => reject(r.error);
+      r.onblocked = () => reject(new Error("IndexedDB bloqueado"));
+    });
+    return new _IndexedDBBuffer(db);
+  }
+  async put(events) {
+    if (!events.length) return;
+    const tx = this.db.transaction(STORE, "readwrite");
+    const store = tx.objectStore(STORE);
+    for (const e of events) store.put(toStored(e));
+    await done(tx);
+  }
+  async peek(sessionId, tabId, maxEvents, maxBytes) {
+    const prefix = `${sessionId}|${tabId}|`;
+    const range = IDBKeyRange.bound(prefix, prefix + "\uFFFF");
+    const tx = this.db.transaction(STORE, "readonly");
+    const items = [];
+    let bytes = 0;
+    await new Promise((resolve, reject) => {
+      const cur = tx.objectStore(STORE).openCursor(range);
+      cur.onsuccess = () => {
+        const c = cur.result;
+        if (!c) return resolve();
+        const s = c.value;
+        if (items.length >= maxEvents || items.length > 0 && bytes + s.size > maxBytes) return resolve();
+        items.push(s);
+        bytes += s.size;
+        c.continue();
+      };
+      cur.onerror = () => reject(cur.error);
+    });
+    return { items, bytes };
+  }
+  async remove(keys) {
+    if (!keys.length) return;
+    const tx = this.db.transaction(STORE, "readwrite");
+    const store = tx.objectStore(STORE);
+    for (const k of keys) store.delete(k);
+    await done(tx);
+  }
+  async stats(sessionId) {
+    const tx = this.db.transaction(STORE, "readonly");
+    const store = tx.objectStore(STORE);
+    if (!sessionId) return { count: await req(store.count()), bytes: 0 };
+    let count = 0;
+    let bytes = 0;
+    await new Promise((resolve, reject) => {
+      const cur = store.index("bySession").openCursor(IDBKeyRange.only(sessionId));
+      cur.onsuccess = () => {
+        const c = cur.result;
+        if (!c) return resolve();
+        count++;
+        bytes += c.value.size;
+        c.continue();
+      };
+      cur.onerror = () => reject(cur.error);
+    });
+    return { count, bytes };
+  }
+  async purgeOlderThan(ts) {
+    const tx = this.db.transaction(STORE, "readwrite");
+    let n = 0;
+    await new Promise((resolve, reject) => {
+      const cur = tx.objectStore(STORE).index("byStoredAt").openCursor(IDBKeyRange.upperBound(ts, true));
+      cur.onsuccess = () => {
+        const c = cur.result;
+        if (!c) return resolve();
+        c.delete();
+        n++;
+        c.continue();
+      };
+      cur.onerror = () => reject(cur.error);
+    });
+    await done(tx);
+    return n;
+  }
+  async clearSession(sessionId) {
+    const tx = this.db.transaction(STORE, "readwrite");
+    await new Promise((resolve, reject) => {
+      const cur = tx.objectStore(STORE).index("bySession").openCursor(IDBKeyRange.only(sessionId));
+      cur.onsuccess = () => {
+        const c = cur.result;
+        if (!c) return resolve();
+        c.delete();
+        c.continue();
+      };
+      cur.onerror = () => reject(cur.error);
+    });
+    await done(tx);
+  }
+  close() {
+    safe(() => this.db.close());
+  }
+};
+async function openBuffer(name, persist) {
+  if (persist) {
+    try {
+      return await IndexedDBBuffer.open(name);
+    } catch {
+    }
+  }
+  return new MemoryBuffer();
+}
+
+// src/recorders/types.ts
+function guard(sink, name, fn) {
+  try {
+    fn();
+  } catch (e) {
+    try {
+      sink?.emit("lifecycle", { type: "recorder-error", detail: { recorder: name, message: String(e?.message ?? e) } }, { priority: "low" });
+    } catch {
+    }
+  }
+}
+
+// src/recorders/ActionRecorder.ts
+var KEYS = /* @__PURE__ */ new Set(["Enter", "Escape", "Tab", "Backspace", "Delete", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown"]);
+var INTERACTIVE = "a,button,input,select,textarea,summary,[role=button],[role=link],[role=menuitem],[role=tab],[role=option],[data-testid],[data-test],[data-cy]";
+var INPUT_IDLE_MS = 700;
+var DRAG_MIN_PX = 8;
+var ActionRecorder = class {
+  constructor(sink) {
+    this.sink = sink;
+    this.name = "actions";
+    this.d = new Disposer();
+    this.paused = false;
+    this.salt = Math.random().toString(36).slice(2);
+    this.scrollState = /* @__PURE__ */ new Map();
+    this.move = [];
+    const r = sink.config.recording;
+    this.gen = new chunkB6GO5FE5_cjs.SelectorGenerator({ testIdAttributes: r.testIdAttributes, stableAttributes: r.stableAttributes });
+  }
+  start() {
+    const d = this.d;
+    const cap = { capture: true, passive: true };
+    const on = (type, fn, target = document) => d.listen(target, type, (e) => guard(this.sink, this.name, () => !this.paused && fn(e)), cap);
+    on("click", (e) => this.onClick(e));
+    on("dblclick", (e) => this.onDblClick(e));
+    on("input", (e) => this.onInput(e));
+    on("change", (e) => this.onChange(e));
+    on("keydown", (e) => this.onKey(e));
+    on("focusin", (e) => this.onFocus("focus", e));
+    on("focusout", (e) => this.onFocus("blur", e));
+    on("scroll", (e) => this.onScroll(e));
+    on("mouseover", (e) => this.onOver(e));
+    on("mouseout", (e) => this.onOut(e));
+    on("mousedown", (e) => this.onDown(e));
+    on("mouseup", (e) => this.onUp(e));
+    on("mousemove", (e) => this.onMove(e));
+    on("dragstart", () => this.drag && (this.drag.html5 = true));
+    this.moveFlush = debounce(() => this.flushMove(), 500);
+    d.add(() => this.moveFlush?.cancel());
+  }
+  pause() {
+    this.flushAll();
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  stop() {
+    guard(this.sink, this.name, () => this.flushAll());
+    this.d.dispose();
+    for (const s of this.scrollState.values()) s.flush.cancel();
+    this.scrollState.clear();
+    if (this.hover?.timer) clearTimeout(this.hover.timer);
+  }
+  /** Descarrega estados pendentes (input em edição, scroll, trajetória do mouse). */
+  flushAll() {
+    this.flushInput();
+    for (const s of this.scrollState.values()) s.flush.flush();
+    this.flushMove();
+  }
+  // ---- API usada pelo núcleo ----------------------------------------------
+  recordNavigation(from, to, kind) {
+    guard(this.sink, this.name, () => {
+      if (this.paused) return;
+      this.flushAll();
+      const s = this.sink.sanitizer;
+      this.emit({ type: "navigate", payload: { from: s.sanitizeUrl(from), to: s.sanitizeUrl(to), kind } });
+    });
+  }
+  recordPageLoad(navType, referrer) {
+    guard(this.sink, this.name, () => {
+      const s = this.sink.sanitizer;
+      if (navType === "reload") this.emit({ type: "reload", payload: { url: s.sanitizeUrl(location.href) } });
+      else if (navType === "back_forward" || navType === "navigate")
+        this.emit({ type: "navigate", payload: { from: referrer ? s.sanitizeUrl(referrer) : void 0, to: s.sanitizeUrl(location.href), kind: navType === "back_forward" ? "history" : "document" } });
+    });
+  }
+  // ---- helpers --------------------------------------------------------------
+  emit(draft, el, extra) {
+    const s = this.sink.sanitizer;
+    const data = {
+      schemaVersion: chunkB6GO5FE5_cjs.ACTION_SCHEMA_VERSION,
+      type: draft.type,
+      url: s.sanitizeUrl(location.href),
+      viewport: { width: window.innerWidth, height: window.innerHeight },
+      payload: draft.payload,
+      metadata: draft.metadata
+    };
+    if (extra?.x !== void 0 && extra.y !== void 0) data.coordinates = { x: Math.round(extra.x), y: Math.round(extra.y) };
+    if (el) {
+      const r = this.gen.generate(el);
+      data.selector = s.scrubString(r.selector);
+      data.selectorUnique = r.unique;
+      data.selectorCandidates = s.sanitizeSelectorCandidates(r.candidates);
+      data.element = this.gen.describe(el);
+      if (data.element.text) data.element.text = s.scrubString(data.element.text);
+      if (data.element.name) data.element.name = s.scrubString(data.element.name);
+    }
+    this.sink.emit("action", data, { priority: "normal" });
+  }
+  target(e) {
+    const t = e.target;
+    const el = t instanceof Element ? t : t instanceof Node ? t.parentElement : null;
+    if (!el) return null;
+    const { ignoreSelectors, blockSelectors } = this.sink.config.privacy;
+    const sel = [...ignoreSelectors, ...blockSelectors].join(",");
+    if (sel && safe(() => el.closest(sel))) return null;
+    return el;
+  }
+  // ---- handlers -------------------------------------------------------------
+  onClick(e) {
+    const el = this.target(e);
+    if (!el) return;
+    this.flushInput();
+    const last = this.lastClick;
+    if (last && el instanceof HTMLInputElement && last.el.control === el && e.timeStamp - last.t < 100) return;
+    this.lastClick = { el, t: e.timeStamp };
+    const clickable = el.closest(INTERACTIVE) ?? el;
+    this.emit({ type: "click", payload: { button: e.button, detail: e.detail, modifiers: mods(e), trusted: e.isTrusted } }, clickable, { x: e.clientX, y: e.clientY });
+  }
+  onDblClick(e) {
+    const el = this.target(e);
+    if (!el) return;
+    const interval = this.lastClick ? Math.round(e.timeStamp - this.lastClick.t) : void 0;
+    this.emit({ type: "dblclick", payload: { intervalMs: interval, modifiers: mods(e) } }, el.closest(INTERACTIVE) ?? el, { x: e.clientX, y: e.clientY });
+  }
+  onInput(e) {
+    const el = this.target(e);
+    if (!el || !(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return;
+    if (el instanceof HTMLInputElement && ["checkbox", "radio", "file", "range", "color"].includes(el.type)) return;
+    if (this.pendingInput && this.pendingInput.el !== el) this.flushInput();
+    this.pendingInput ?? (this.pendingInput = { el, inputType: e.inputType ?? "input", startedAt: Date.now() });
+    if (this.inputTimer) clearTimeout(this.inputTimer);
+    this.inputTimer = setTimeout(() => guard(this.sink, this.name, () => this.flushInput()), INPUT_IDLE_MS);
+  }
+  flushInput() {
+    if (this.inputTimer) clearTimeout(this.inputTimer);
+    this.inputTimer = void 0;
+    const p = this.pendingInput;
+    this.pendingInput = void 0;
+    if (!p || !p.el.isConnected) return;
+    const el = p.el;
+    const value = el.value ?? "";
+    const payload = { inputType: p.inputType, length: value.length, typingMs: Date.now() - p.startedAt, fieldType: el instanceof HTMLInputElement ? el.type : "textarea" };
+    const policy = this.sink.config.privacy;
+    const allowed = policy.allowedInputSelectors.join(",");
+    const isPassword = el instanceof HTMLInputElement && el.type === "password";
+    if (!isPassword && allowed && safe(() => el.matches(allowed))) {
+      payload.value = this.sink.sanitizer.scrubString(value);
+      payload.valueCaptured = true;
+    } else {
+      payload.valueCaptured = false;
+      payload.valueRef = this.sink.sanitizer.redactedRef(value, this.salt);
+    }
+    this.emit({ type: "input", payload }, el);
+  }
+  onChange(e) {
+    const el = this.target(e);
+    if (!el) return;
+    if (el instanceof HTMLInputElement && (el.type === "checkbox" || el.type === "radio")) {
+      this.flushInput();
+      const capture = this.sink.config.privacy.captureChoiceValues;
+      this.emit({ type: "check", payload: { checked: el.checked, inputType: el.type, value: capture ? el.value : void 0 } }, el);
+    } else if (el instanceof HTMLSelectElement) {
+      this.flushInput();
+      const capture = this.sink.config.privacy.captureChoiceValues;
+      const opts = Array.from(el.selectedOptions);
+      this.emit(
+        { type: "select", payload: capture ? { values: opts.map((o) => o.value), labels: opts.map((o) => o.label), multiple: el.multiple } : { count: opts.length, multiple: el.multiple } },
+        el
+      );
+    } else if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+      this.flushInput();
+    }
+  }
+  onKey(e) {
+    const el = this.target(e);
+    if (!el) return;
+    const modified = e.ctrlKey || e.metaKey || e.altKey;
+    const relevant = KEYS.has(e.key) || /^F\d{1,2}$/.test(e.key) || modified && e.key.length === 1;
+    if (!relevant) return;
+    if (e.key === "Enter" || e.key === "Tab") this.flushInput();
+    this.emit({ type: "keydown", payload: { key: e.key, code: e.code, modifiers: mods(e), repeat: e.repeat } }, el);
+  }
+  onFocus(type, e) {
+    const el = this.target(e);
+    if (!el || el === document.body || el === document.documentElement) return;
+    if (type === "blur") this.flushInput();
+    this.emit({ type }, el);
+  }
+  onScroll(e) {
+    const t = e.target;
+    const isDoc = t === document || t === document.documentElement || t === document.body;
+    const el = isDoc ? null : t instanceof Element ? t : null;
+    if (!isDoc && (!el || this.target(e) === null)) return;
+    const pos = () => isDoc ? { x: Math.round(window.scrollX), y: Math.round(window.scrollY) } : { x: Math.round(el.scrollLeft), y: Math.round(el.scrollTop) };
+    const key = isDoc ? document : t;
+    let st = this.scrollState.get(key);
+    if (!st) {
+      const start = pos();
+      st = {
+        ...start,
+        flush: debounce(() => {
+          const s = this.scrollState.get(key);
+          if (!s) return;
+          this.scrollState.delete(key);
+          const end = pos();
+          if (end.x === s.x && end.y === s.y) return;
+          guard(this.sink, this.name, () => this.emit({ type: "scroll", payload: { from: { x: s.x, y: s.y }, to: end, target: isDoc ? "window" : "element" } }, el));
+        }, 200)
+      };
+      this.scrollState.set(key, st);
+    }
+    st.flush();
+  }
+  onOver(e) {
+    const el = this.target(e);
+    const hit = el?.closest(INTERACTIVE);
+    if (!hit || this.hover?.el === hit) return;
+    this.endHover();
+    const h = { el: hit, entered: false };
+    h.timer = setTimeout(() => {
+      h.entered = true;
+      guard(this.sink, this.name, () => this.emit({ type: "hover", payload: { phase: "enter" } }, hit, { x: e.clientX, y: e.clientY }));
+    }, 200);
+    this.hover = h;
+  }
+  onOut(e) {
+    const h = this.hover;
+    if (!h) return;
+    const to = e.relatedTarget;
+    if (to && h.el.contains(to)) return;
+    this.endHover();
+  }
+  endHover() {
+    const h = this.hover;
+    if (!h) return;
+    if (h.timer) clearTimeout(h.timer);
+    this.hover = void 0;
+    if (h.entered) this.emit({ type: "hover", payload: { phase: "leave" } }, h.el);
+  }
+  onDown(e) {
+    const el = this.target(e);
+    if (!el || e.button !== 0) return;
+    this.drag = { el, x: e.clientX, y: e.clientY, t: Date.now(), points: [{ x: e.clientX, y: e.clientY, t: 0 }], html5: false };
+  }
+  onUp(e) {
+    const d = this.drag;
+    this.drag = void 0;
+    if (!d) return;
+    const dist = Math.hypot(e.clientX - d.x, e.clientY - d.y);
+    if (dist < DRAG_MIN_PX) return;
+    const dropEl = safe(() => document.elementFromPoint(e.clientX, e.clientY));
+    const traj = d.points.length > 50 ? d.points.filter((_, i) => i % Math.ceil(d.points.length / 50) === 0) : d.points;
+    const to = dropEl && !(dropEl === d.el) ? this.gen.generate(dropEl) : void 0;
+    this.emit(
+      {
+        type: "drag",
+        payload: {
+          from: { x: Math.round(d.x), y: Math.round(d.y) },
+          to: { x: Math.round(e.clientX), y: Math.round(e.clientY) },
+          trajectory: traj,
+          durationMs: Date.now() - d.t,
+          html5: d.html5,
+          target: to ? { selector: this.sink.sanitizer.scrubString(to.selector), unique: to.unique, element: dropEl ? this.gen.describe(dropEl) : void 0 } : void 0
+        }
+      },
+      d.el,
+      { x: d.x, y: d.y }
+    );
+  }
+  onMove(e) {
+    const t = Date.now();
+    if (this.drag) {
+      const last2 = this.drag.points[this.drag.points.length - 1];
+      if (t - this.drag.t - last2.t >= 30) this.drag.points.push({ x: Math.round(e.clientX), y: Math.round(e.clientY), t: t - this.drag.t });
+    }
+    if (!this.sink.config.recording.mouseMove) return;
+    const last = this.move[this.move.length - 1];
+    if (last && t - last.t < this.sink.config.recording.throttleMs) return;
+    this.move.push({ x: Math.round(e.clientX), y: Math.round(e.clientY), t });
+    if (this.move.length >= 40) this.flushMove();
+    else this.moveFlush?.();
+  }
+  flushMove() {
+    if (!this.move.length) return;
+    const points = this.move;
+    this.move = [];
+    this.emit({ type: "mousemove", payload: { points } }, null, { x: points[points.length - 1].x, y: points[points.length - 1].y });
+  }
+};
+function mods(e) {
+  const m = [];
+  if (e.ctrlKey) m.push("Control");
+  if (e.metaKey) m.push("Meta");
+  if (e.altKey) m.push("Alt");
+  if (e.shiftKey) m.push("Shift");
+  return m;
+}
+
+// src/recorders/ContextRecorder.ts
+function parseBrowser(ua) {
+  const rules = [
+    ["Edge", /Edg(?:e|A|iOS)?\/([\d.]+)/],
+    ["Opera", /OPR\/([\d.]+)/],
+    ["Firefox", /Firefox\/([\d.]+)/],
+    ["Chrome", /(?:Chrome|CriOS)\/([\d.]+)/],
+    ["Safari", /Version\/([\d.]+).*Safari/]
+  ];
+  for (const [name, re] of rules) {
+    const m = ua.match(re);
+    if (m) return { name, version: m[1] };
+  }
+  return {};
+}
+function collectContext(id, reason, appVersion) {
+  const nav = navigator;
+  const ua = nav.userAgent ?? "";
+  let browser = parseBrowser(ua);
+  const brands = nav.userAgentData?.brands?.filter((b) => !/not.?a.?brand/i.test(b.brand));
+  const preferred = brands?.find((b) => /chrom|edge|opera/i.test(b.brand)) ?? brands?.[0];
+  if (preferred && !browser.name) browser = { name: preferred.brand, version: preferred.version };
+  const navEntry = safe(() => performance.getEntriesByType("navigation")[0]);
+  return {
+    reason,
+    url: location.href,
+    referrer: document.referrer || void 0,
+    title: document.title || void 0,
+    navigationType: navEntry?.type,
+    browser,
+    os: nav.userAgentData?.platform ?? nav.platform,
+    userAgent: ua,
+    screen: { width: screen?.width ?? 0, height: screen?.height ?? 0 },
+    viewport: { width: window.innerWidth, height: window.innerHeight },
+    devicePixelRatio: window.devicePixelRatio ?? 1,
+    language: nav.language,
+    timezone: safe(() => Intl.DateTimeFormat().resolvedOptions().timeZone),
+    online: nav.onLine,
+    visibility: document.visibilityState,
+    platformId: id.platformId,
+    testCaseId: id.testCaseId,
+    executionId: id.executionId,
+    sdkVersion: chunkB6GO5FE5_cjs.SDK_VERSION,
+    appVersion
+  };
+}
+var ContextRecorder = class {
+  constructor(sink, identity) {
+    this.sink = sink;
+    this.identity = identity;
+    this.name = "context";
+    this.d = new Disposer();
+  }
+  start() {
+    this.record("page-load");
+    const onResize = debounce(() => this.record("viewport"), 500);
+    this.d.listen(window, "resize", onResize);
+    this.d.listen(window, "orientationchange", onResize);
+    this.d.add(() => onResize.cancel());
+  }
+  record(reason) {
+    guard(this.sink, this.name, () => {
+      const data = collectContext(this.identity(), reason, this.sink.config.appVersion);
+      data.url = this.sink.sanitizer.sanitizeUrl(data.url);
+      if (data.referrer) data.referrer = this.sink.sanitizer.sanitizeUrl(data.referrer);
+      this.sink.emit("context", data, { priority: "normal" });
+    });
+  }
+  stop() {
+    this.d.dispose();
+  }
+};
+
+// src/recorders/ErrorRecorder.ts
+var MAX_ARG_DEPTH = 3;
+var MAX_STR = 2e3;
+function serializeArg(v, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (v === null || v === void 0) return v;
+  const t = typeof v;
+  if (t === "string") return v.length > MAX_STR ? `${v.slice(0, MAX_STR)}\u2026` : v;
+  if (t === "number" || t === "boolean") return v;
+  if (t === "bigint") return `${String(v)}n`;
+  if (t === "function") return `[Function ${v.name || "anonymous"}]`;
+  if (t === "symbol") return String(v);
+  if (v instanceof Error) return { name: v.name, message: v.message, stack: v.stack };
+  if (typeof Node !== "undefined" && v instanceof Node) return `[${v.nodeName}]`;
+  if (depth >= MAX_ARG_DEPTH) return "[Object]";
+  const obj = v;
+  if (seen.has(obj)) return "[Circular]";
+  seen.add(obj);
+  if (Array.isArray(obj)) return obj.slice(0, 20).map((x) => serializeArg(x, depth + 1, seen));
+  const out = {};
+  for (const k of Object.keys(obj).slice(0, 30)) out[k] = safe(() => serializeArg(obj[k], depth + 1, seen));
+  return out;
+}
+var FRAME = /(?:at\s+.*?\(|at\s+|@)(.+?):(\d+):(\d+)\)?$/;
+function firstFrame(stack) {
+  if (!stack) return {};
+  for (const line of stack.split("\n")) {
+    const m = line.trim().match(FRAME);
+    if (m && !/offscript/i.test(m[1])) return { file: m[1], line: Number(m[2]), column: Number(m[3]) };
+  }
+  return {};
+}
+var originals = /* @__PURE__ */ new Map();
+var ErrorRecorder = class {
+  constructor(sink) {
+    this.sink = sink;
+    this.name = "errors";
+    this.d = new Disposer();
+    this.busy = false;
+  }
+  start() {
+    const { console: wantConsole, errors, consoleLevels } = this.sink.config.recording;
+    if (wantConsole) for (const level of consoleLevels) this.wrapConsole(level);
+    if (errors) {
+      this.d.listen(
+        window,
+        "error",
+        (e) => {
+          const target = e.target;
+          if (target && target !== window && target.tagName) {
+            this.report({ source: "resource", message: `Falha ao carregar <${target.tagName.toLowerCase()}>`, file: target.src || target.href });
+            return;
+          }
+          const err = e.error;
+          const frame = err?.stack ? firstFrame(err.stack) : {};
+          this.report({
+            source: "window.onerror",
+            message: e.message || String(err),
+            name: err?.name,
+            stack: err?.stack,
+            file: e.filename || frame.file,
+            line: e.lineno || frame.line,
+            column: e.colno || frame.column
+          });
+        },
+        true
+      );
+      this.d.listen(window, "unhandledrejection", (e) => {
+        const r = e.reason;
+        const isErr = r instanceof Error;
+        const stack = isErr ? r.stack : void 0;
+        this.report({
+          source: "unhandledrejection",
+          message: isErr ? r.message : String(safe(() => JSON.stringify(r)) ?? r),
+          name: isErr ? r.name : void 0,
+          stack,
+          ...firstFrame(stack)
+        });
+      });
+    }
+  }
+  report(partial) {
+    guard(this.sink, this.name, () => {
+      const s = this.sink.sanitizer;
+      this.sink.emit(
+        "error",
+        {
+          ...partial,
+          message: s.scrubString(partial.message ?? ""),
+          stack: partial.stack ? s.scrubString(partial.stack) : void 0,
+          file: partial.file ? s.sanitizeUrl(partial.file) : void 0,
+          url: s.sanitizeUrl(location.href)
+        },
+        { priority: "critical" }
+      );
+    });
+  }
+  wrapConsole(level) {
+    const current = console[level];
+    if (!current || originals.has(level)) return;
+    const self = this;
+    const wrapped = function(...args) {
+      const result = current.apply(this === void 0 ? console : this, args);
+      if (!self.busy) {
+        self.busy = true;
+        try {
+          self.captureConsole(level, args);
+        } catch {
+        } finally {
+          self.busy = false;
+        }
+      }
+      return result;
+    };
+    originals.set(level, { orig: current, wrapped });
+    console[level] = wrapped;
+    this.d.add(() => {
+      const entry = originals.get(level);
+      if (entry && console[level] === entry.wrapped) console[level] = entry.orig;
+      originals.delete(level);
+    });
+  }
+  captureConsole(level, args) {
+    const s = this.sink.sanitizer;
+    const serial = args.map((a) => s.sanitizeValue(serializeArg(a)));
+    const message = serial.map((a) => typeof a === "string" ? a : safe(() => JSON.stringify(a)) ?? String(a)).join(" ");
+    const stack = level === "error" || level === "warn" ? s.scrubString(new Error().stack?.split("\n").slice(3).join("\n") ?? "") : void 0;
+    this.sink.emit(
+      "console",
+      { level, args: serial, message: message.slice(0, 4e3), stack, url: s.sanitizeUrl(location.href) },
+      { priority: level === "error" ? "normal" : "low" }
+    );
+  }
+  stop() {
+    this.d.dispose();
+  }
+};
+
+// src/utils/id.ts
+function uid(prefix = "") {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return prefix + c.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (c?.getRandomValues) c.getRandomValues(bytes);
+  else for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  return prefix + Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/recorders/HTTPRecorder.ts
+var XHR_PATCHED = "__offscriptXhrOriginal";
+var HTTPRecorder = class {
+  constructor(sink, ownApiUrl) {
+    this.sink = sink;
+    this.ownApiUrl = ownApiUrl;
+    this.name = "http";
+    this.inflight = 0;
+    this.active = false;
+    this.restore = [];
+  }
+  start() {
+    if (this.active) return;
+    this.active = true;
+    this.patchFetch();
+    this.patchXhr();
+  }
+  stop() {
+    this.active = false;
+    for (const r of this.restore.splice(0).reverse()) {
+      try {
+        r();
+      } catch {
+      }
+    }
+  }
+  isIgnored(url) {
+    if (this.ownApiUrl && url.startsWith(this.ownApiUrl)) return true;
+    return this.sink.sanitizer.isIgnoredUrl(url);
+  }
+  // ---------------------------------------------------------------- fetch
+  patchFetch() {
+    if (typeof globalThis.fetch !== "function") return;
+    const orig = globalThis.fetch;
+    const self = this;
+    const patched = function(input, init) {
+      let ctx = null;
+      if (self.active) {
+        try {
+          ctx = self.beginFetch(input, init);
+        } catch {
+          ctx = null;
+        }
+      }
+      let p;
+      try {
+        p = orig.apply(this, arguments);
+      } catch (e) {
+        if (ctx) self.inflight--;
+        throw e;
+      }
+      if (ctx) {
+        const c = ctx;
+        p.then(
+          (res) => self.endFetch(c, res),
+          (err) => self.failFetch(c, err)
+        ).catch(() => void 0);
+      }
+      return p;
+    };
+    patched[ORIGINAL_FETCH] = orig[ORIGINAL_FETCH] ?? orig;
+    globalThis.fetch = patched;
+    this.restore.push(() => {
+      if (globalThis.fetch === patched) globalThis.fetch = orig;
+    });
+  }
+  beginFetch(input, init) {
+    const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const abs = new URL(rawUrl, location.href).href;
+    if (this.isIgnored(abs)) return null;
+    const isReq = typeof Request !== "undefined" && input instanceof Request;
+    const method = (init?.method ?? (isReq ? input.method : "GET")).toUpperCase();
+    const ctx = { requestId: uid("req_"), transport: "fetch", url: abs, method, startedAt: Date.now(), concurrent: this.inflight };
+    const s = this.sink.sanitizer;
+    const hdrs = {};
+    new Headers(init?.headers ?? (isReq ? input.headers : void 0)).forEach((v, k) => hdrs[k] = v);
+    ctx.requestHeaders = s.sanitizeHeaders(hdrs);
+    if (this.sink.config.privacy.captureRequestBodies) {
+      const ct = hdrs["content-type"] ?? "";
+      if (init?.body != null) ctx.requestBody = this.describeBody(init.body, ct);
+      else ctx.requestBody = { kind: "omitted", reason: isReq ? "request-object" : "no-body" };
+    }
+    this.inflight++;
+    return ctx;
+  }
+  endFetch(ctx, res) {
+    this.inflight = Math.max(0, this.inflight - 1);
+    guard(this.sink, this.name, () => {
+      const endedAt = Date.now();
+      const headers = {};
+      res.headers.forEach((v, k) => headers[k] = v);
+      const base = this.base(ctx, endedAt);
+      base.status = res.status;
+      base.statusText = res.statusText;
+      base.responseHeaders = this.sink.sanitizer.sanitizeHeaders(headers);
+      const ct = headers["content-type"] ?? "";
+      if (!this.sink.config.privacy.captureResponseBodies) return void this.emit(base);
+      if (!this.sink.sanitizer.isTextual(ct) || /event-stream/i.test(ct) || !res.body) {
+        base.responseBody = { kind: "omitted", reason: !res.body ? "no-body" : /event-stream/i.test(ct) ? "stream" : "binary" };
+        return void this.emit(base);
+      }
+      let clone;
+      try {
+        clone = res.clone();
+      } catch {
+        base.responseBody = { kind: "omitted", reason: "body-used" };
+        return void this.emit(base);
+      }
+      this.readBounded(clone).then(({ text, size, truncated }) => {
+        const b = this.sink.sanitizer.sanitizeTextBody(text, ct, size);
+        b.truncated = truncated || b.truncated;
+        base.responseBody = b;
+      }).catch(() => {
+        base.responseBody = { kind: "omitted", reason: "read-failed" };
+      }).finally(() => guard(this.sink, this.name, () => this.emit(base)));
+    });
+  }
+  async readBounded(res) {
+    const max = this.sink.config.privacy.maxBodyBytes;
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let text = "";
+    let size = 0;
+    let truncated = false;
+    for (; ; ) {
+      const { done: done2, value } = await reader.read();
+      if (done2) break;
+      size += value.byteLength;
+      if (text.length < max) text += dec.decode(value, { stream: true });
+      if (size > max * 4) {
+        truncated = true;
+        await reader.cancel().catch(() => void 0);
+        break;
+      }
+    }
+    if (text.length > max) {
+      text = text.slice(0, max);
+      truncated = true;
+    }
+    return { text, size, truncated };
+  }
+  failFetch(ctx, err) {
+    this.inflight = Math.max(0, this.inflight - 1);
+    guard(this.sink, this.name, () => {
+      const e = err;
+      const base = this.base(ctx, Date.now());
+      base.aborted = e?.name === "AbortError";
+      base.error = { name: e?.name ?? "Error", message: this.sink.sanitizer.scrubString(String(e?.message ?? e)) };
+      this.emit(base);
+    });
+  }
+  // ---------------------------------------------------------------- XHR
+  patchXhr() {
+    if (typeof XMLHttpRequest === "undefined") return;
+    const proto = XMLHttpRequest.prototype;
+    const self = this;
+    const metas = /* @__PURE__ */ new WeakMap();
+    const origOpen = proto.open;
+    const origSend = proto.send;
+    const origSet = proto.setRequestHeader;
+    const open = function(...args) {
+      try {
+        if (self.active) metas.set(this, { method: String(args[0]).toUpperCase(), url: String(args[1]), headers: {} });
+      } catch {
+      }
+      return origOpen.apply(this, args);
+    };
+    const setHeader = function(name, value) {
+      try {
+        const m = metas.get(this);
+        if (m) m.headers[name.toLowerCase()] = value;
+      } catch {
+      }
+      return origSet.call(this, name, value);
+    };
+    const send = function(body) {
+      try {
+        const m = metas.get(this);
+        if (m && self.active) self.beginXhr(this, m, body);
+      } catch {
+      }
+      return origSend.call(this, body);
+    };
+    open[XHR_PATCHED] = origOpen;
+    proto.open = open;
+    proto.setRequestHeader = setHeader;
+    proto.send = send;
+    this.restore.push(() => {
+      if (proto.open === open) proto.open = origOpen;
+      if (proto.setRequestHeader === setHeader) proto.setRequestHeader = origSet;
+      if (proto.send === send) proto.send = origSend;
+    });
+  }
+  beginXhr(xhr, m, body) {
+    const abs = new URL(m.url, location.href).href;
+    if (this.isIgnored(abs)) return;
+    const ctx = { requestId: uid("req_"), transport: "xhr", url: abs, method: m.method, startedAt: Date.now(), concurrent: this.inflight };
+    ctx.requestHeaders = this.sink.sanitizer.sanitizeHeaders(m.headers);
+    if (this.sink.config.privacy.captureRequestBodies) {
+      ctx.requestBody = body == null ? { kind: "omitted", reason: "no-body" } : this.describeBody(body, m.headers["content-type"] ?? "");
+    }
+    m.ctx = ctx;
+    this.inflight++;
+    xhr.addEventListener("abort", () => m.aborted = true);
+    xhr.addEventListener("timeout", () => m.timedOut = true);
+    xhr.addEventListener("loadend", () => {
+      this.inflight = Math.max(0, this.inflight - 1);
+      guard(this.sink, this.name, () => this.endXhr(xhr, m, ctx));
+    });
+  }
+  endXhr(xhr, m, ctx) {
+    const base = this.base(ctx, Date.now());
+    const failed = xhr.status === 0;
+    if (!failed) {
+      base.status = xhr.status;
+      base.statusText = xhr.statusText;
+    }
+    const headers = {};
+    xhr.getAllResponseHeaders().trim().split(/\r?\n/).forEach((line) => {
+      const i = line.indexOf(":");
+      if (i > 0) headers[line.slice(0, i).trim().toLowerCase()] = line.slice(i + 1).trim();
+    });
+    base.responseHeaders = this.sink.sanitizer.sanitizeHeaders(headers);
+    if (m.aborted) base.aborted = true;
+    if (failed) base.error = { name: m.aborted ? "AbortError" : m.timedOut ? "TimeoutError" : "NetworkError", message: m.aborted ? "aborted" : m.timedOut ? "timeout" : "network error" };
+    if (!failed && this.sink.config.privacy.captureResponseBodies) {
+      const ct = headers["content-type"] ?? "";
+      if (this.sink.sanitizer.isTextual(ct) && (xhr.responseType === "" || xhr.responseType === "text")) base.responseBody = this.sink.sanitizer.sanitizeTextBody(xhr.responseText, ct);
+      else if (xhr.responseType === "json") base.responseBody = this.sink.sanitizer.sanitizeTextBody(JSON.stringify(xhr.response ?? null), "application/json");
+      else base.responseBody = { kind: "omitted", reason: "binary" };
+    }
+    this.emit(base);
+  }
+  // ---------------------------------------------------------------- comum
+  base(ctx, endedAt) {
+    const s = this.sink.sanitizer;
+    return {
+      requestId: ctx.requestId,
+      transport: ctx.transport,
+      url: s.sanitizeUrl(ctx.url),
+      method: ctx.method,
+      query: s.parseQuery(ctx.url),
+      requestHeaders: ctx.requestHeaders,
+      requestBody: ctx.requestBody,
+      startedAt: ctx.startedAt,
+      endedAt,
+      durationMs: endedAt - ctx.startedAt,
+      concurrent: ctx.concurrent
+    };
+  }
+  emit(data) {
+    this.sink.emit("http", data, { priority: "normal", at: data.startedAt });
+  }
+  describeBody(body, contentType) {
+    const s = this.sink.sanitizer;
+    const max = this.sink.config.privacy.maxBodyBytes;
+    if (typeof body === "string") return s.sanitizeTextBody(body, contentType || "text/plain", body.length);
+    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return s.sanitizeTextBody(body.toString(), "application/x-www-form-urlencoded");
+    if (typeof FormData !== "undefined" && body instanceof FormData) {
+      const form = {};
+      body.forEach((v, k) => {
+        form[k] = s.isSensitiveKey(k) ? "[REDACTED]" : typeof v === "string" ? s.scrubString(v.slice(0, max)) : `[File ${v.name}, ${v.size}B]`;
+      });
+      return { kind: "form", value: form };
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) return { kind: "binary", size: body.size, reason: "blob" };
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return { kind: "binary", size: body.byteLength };
+    return { kind: "omitted", reason: "unsupported-body" };
+  }
+};
+
+// src/recorders/IframeRecorder.ts
+var SEATSIO = /(^|\.)seatsio\.net$|(^|\.)seats\.io$/i;
+var LIMITATION = "Conte\xFAdo interno de iframes cross-origin n\xE3o \xE9 acess\xEDvel ao SDK nem ao rrweb; apenas presen\xE7a, geometria, foco e intera\xE7\xF5es observ\xE1veis na p\xE1gina principal s\xE3o registrados.";
+var IframeRecorder = class {
+  constructor(sink) {
+    this.sink = sink;
+    this.name = "iframes";
+    this.d = new Disposer();
+    this.known = /* @__PURE__ */ new WeakMap();
+    this.counter = 0;
+  }
+  start() {
+    document.querySelectorAll("iframe").forEach((f) => this.add(f));
+    this.mo = new MutationObserver(
+      (records) => guard(this.sink, this.name, () => {
+        for (const r of records) {
+          r.addedNodes.forEach((n) => this.scan(n, true));
+          r.removedNodes.forEach((n) => this.scan(n, false));
+        }
+      })
+    );
+    this.mo.observe(document.documentElement, { childList: true, subtree: true });
+    this.d.add(() => this.mo?.disconnect());
+    let focused = null;
+    this.d.listen(
+      window,
+      "blur",
+      () => setTimeout(() => {
+        guard(this.sink, this.name, () => {
+          const a = document.activeElement;
+          if (a instanceof HTMLIFrameElement) {
+            focused = a;
+            this.event("focus", a);
+          }
+        });
+      }, 0)
+    );
+    this.d.listen(
+      window,
+      "focus",
+      () => guard(this.sink, this.name, () => {
+        if (focused) {
+          this.event("blur", focused);
+          focused = null;
+        }
+      })
+    );
+    const onResize = debounce(() => document.querySelectorAll("iframe").forEach((f) => this.known.has(f) && this.event("resized", f)), 500);
+    this.d.listen(window, "resize", onResize);
+    this.d.add(() => onResize.cancel());
+  }
+  scan(n, added) {
+    if (!(n instanceof Element)) return;
+    const frames = n instanceof HTMLIFrameElement ? [n] : Array.from(n.querySelectorAll("iframe"));
+    for (const f of frames) {
+      if (added) this.add(f);
+      else if (this.known.has(f)) this.event("removed", f);
+    }
+  }
+  add(f) {
+    if (this.known.has(f)) return;
+    this.known.set(f, ++this.counter);
+    this.event("present", f);
+    f.addEventListener("load", () => guard(this.sink, this.name, () => this.event("resized", f)), { once: true });
+  }
+  event(phase, f) {
+    const src = f.getAttribute("src") ?? "";
+    let origin;
+    let path;
+    let host = "";
+    try {
+      const u = new URL(src, location.href);
+      origin = u.origin;
+      path = u.pathname;
+      host = u.hostname;
+    } catch {
+    }
+    const crossOrigin = origin !== void 0 && origin !== location.origin && origin !== "null";
+    const r = safe(() => f.getBoundingClientRect());
+    const idx = this.known.get(f) ?? 0;
+    this.sink.emit(
+      "iframe",
+      {
+        phase,
+        provider: SEATSIO.test(host) ? "seatsio" : "unknown",
+        origin,
+        path,
+        crossOrigin,
+        rect: { x: Math.round(r?.x ?? 0), y: Math.round(r?.y ?? 0), width: Math.round(r?.width ?? 0), height: Math.round(r?.height ?? 0) },
+        index: idx,
+        limitation: crossOrigin ? LIMITATION : "same-origin"
+      },
+      { priority: "normal" }
+    );
+  }
+  stop() {
+    this.d.dispose();
+  }
+};
+
+// src/recorders/RRWebRecorder.ts
+var PRIORITY = { 2: "critical", 4: "critical", 5: "critical", 0: "normal", 1: "normal", 3: "normal", 6: "normal" };
+var URL_ATTRS = ["src", "href", "action", "poster", "data-src", "data", "formaction", "srcset", "cite", "rr_src"];
+var LOW_SOURCES = /* @__PURE__ */ new Set([1, 6, 12, 3]);
+var RRWebRecorder = class {
+  constructor(sink) {
+    this.sink = sink;
+    this.name = "rrweb";
+    this.paused = false;
+    this.stopped = true;
+    this.needsSnapshot = false;
+    this.snapshotsTaken = 0;
+  }
+  async start() {
+    this.stopped = false;
+    const { recording, privacy } = this.sink.config;
+    const mod = this.mod ?? (this.mod = await import('rrweb'));
+    if (this.stopped) return;
+    const allowed = privacy.allowedInputSelectors.join(",");
+    const block = privacy.blockSelectors.join(",");
+    const maskText = privacy.maskAllText ? "*" : privacy.maskTextSelectors.join(",");
+    const options = {
+      emit: (event) => this.onEvent(event),
+      blockSelector: block || void 0,
+      maskTextSelector: maskText || void 0,
+      maskAllInputs: privacy.maskSensitiveInputs,
+      maskInputOptions: privacy.maskSensitiveInputs ? { password: true, email: true, tel: true, text: true, textarea: true, search: true, url: true, number: true, select: true, date: true, "datetime-local": true, month: true, time: true, week: true } : { password: true },
+      maskInputFn: (text, el) => {
+        if (el?.type === "password") return "*".repeat(text.length);
+        if (allowed && safe(() => el.matches(allowed))) return text;
+        return "*".repeat(text.length);
+      },
+      recordCanvas: recording.rrwebRecordCanvas,
+      collectFonts: false,
+      inlineStylesheet: true,
+      sampling: { mousemove: Math.max(50, recording.throttleMs), scroll: 150, input: "last", media: 800 },
+      slimDOMOptions: { script: true, comment: true, headFavicon: true, headWhitespace: true },
+      checkoutEveryNms: recording.rrwebCheckoutEveryMs > 0 ? recording.rrwebCheckoutEveryMs : void 0,
+      errorHandler: () => true
+      // erros internos do rrweb não propagam
+    };
+    this.stopFn = mod.record(options) ?? void 0;
+  }
+  onEvent(event) {
+    if (this.paused) return;
+    guard(this.sink, this.name, () => {
+      this.sanitizeEvent(event);
+      let priority = PRIORITY[event.type] ?? "normal";
+      if (event.type === 3 && LOW_SOURCES.has(event.data?.source)) priority = "low";
+      if (event.type === 2) this.snapshotsTaken++;
+      const emitted = this.sink.emit("rrweb", event, { priority, at: event.timestamp });
+      if (!emitted && event.type === 3) this.needsSnapshot = true;
+    });
+  }
+  /** Sanitiza URLs em atributos e padrões sensíveis em textos ANTES de persistir/enviar. */
+  sanitizeEvent(event) {
+    const s = this.sink.sanitizer;
+    const clean = (k, v) => k === "srcset" ? v.split(",").map((part) => {
+      const [u, ...rest] = part.trim().split(/\s+/);
+      return [s.redactUrlAttribute(u), ...rest].join(" ");
+    }).join(", ") : s.redactUrlAttribute(v);
+    const node = (n) => {
+      if (!n || typeof n !== "object") return;
+      if (n.type === 2 && n.attributes) {
+        for (const k of URL_ATTRS) if (typeof n.attributes[k] === "string") n.attributes[k] = clean(k, n.attributes[k]);
+      } else if (n.type === 3 && typeof n.textContent === "string") {
+        n.textContent = s.scrubString(n.textContent);
+      }
+      if (Array.isArray(n.childNodes)) for (const c of n.childNodes) node(c);
+    };
+    if (event.type === 4 && event.data?.href) event.data.href = s.sanitizeUrl(event.data.href);
+    else if (event.type === 2) node(event.data?.node);
+    else if (event.type === 3 && event.data?.source === 0) {
+      for (const a of event.data.adds ?? []) node(a.node);
+      for (const t of event.data.texts ?? []) if (typeof t.value === "string") t.value = s.scrubString(t.value);
+      for (const a of event.data.attributes ?? []) {
+        for (const k of URL_ATTRS) if (typeof a.attributes?.[k] === "string") a.attributes[k] = clean(k, a.attributes[k]);
+      }
+    }
+  }
+  /** Chamado pelo núcleo quando há folga novamente após descartes. */
+  recoverIfNeeded() {
+    if (this.needsSnapshot && !this.paused) {
+      this.needsSnapshot = false;
+      this.takeFullSnapshot();
+    }
+  }
+  takeFullSnapshot() {
+    if (this.stopped) return;
+    guard(this.sink, this.name, () => this.mod?.record.takeFullSnapshot(true));
+  }
+  addCustomEvent(tag, payload) {
+    if (this.stopped) return;
+    guard(this.sink, this.name, () => this.mod?.record.addCustomEvent(tag, payload));
+  }
+  get snapshots() {
+    return this.snapshotsTaken;
+  }
+  pause() {
+    this.paused = true;
+  }
+  /** Ao retomar, as mutações perdidas durante a pausa exigem um snapshot completo. */
+  resume() {
+    this.paused = false;
+    this.takeFullSnapshot();
+  }
+  stop() {
+    this.stopped = true;
+    safe(() => this.stopFn?.());
+    this.stopFn = void 0;
+  }
+};
+
+// src/core/LifecycleManager.ts
+var PATCHED = "__offscriptHistoryPatched";
+var LifecycleManager = class {
+  constructor(h) {
+    this.h = h;
+    this.d = new Disposer();
+    this.lastUrl = "";
+    this.installed = false;
+  }
+  install() {
+    if (this.installed || typeof window === "undefined") return;
+    this.installed = true;
+    this.lastUrl = location.href;
+    const d = this.d;
+    d.listen(window, "pagehide", () => safe(() => this.h.onPageHide()), { capture: true });
+    d.listen(window, "beforeunload", () => safe(() => this.h.onPageHide()), { capture: true });
+    d.listen(document, "visibilitychange", () => {
+      const hidden = document.visibilityState === "hidden";
+      safe(() => this.h.onVisibility(hidden));
+      if (hidden) safe(() => this.h.onPageHide());
+    });
+    d.listen(window, "online", () => safe(() => this.h.onConnectivity(true)));
+    d.listen(window, "offline", () => safe(() => this.h.onConnectivity(false)));
+    d.listen(window, "popstate", () => this.notify("popstate"));
+    d.listen(window, "hashchange", () => this.notify("hashchange"));
+    this.patchHistory("pushState");
+    this.patchHistory("replaceState");
+  }
+  notify(kind) {
+    const to = location.href;
+    if (to === this.lastUrl) return;
+    const from = this.lastUrl;
+    this.lastUrl = to;
+    safe(() => this.h.onNavigation({ from, to, kind }));
+  }
+  patchHistory(method) {
+    const original = history[method];
+    if (original[PATCHED]) return;
+    const self = this;
+    const patched = function(...args) {
+      const result = original.apply(this, args);
+      self.notify(method);
+      return result;
+    };
+    patched[PATCHED] = original;
+    history[method] = patched;
+    this.d.add(() => {
+      if (history[method] === patched) history[method] = original;
+    });
+  }
+  uninstall() {
+    this.d.dispose();
+    this.installed = false;
+  }
+};
+
+// src/core/SessionManager.ts
+var STATE_VERSION = 1;
+var SessionManager = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.state = null;
+    this.info = null;
+    this.seq = 0;
+    this.token = "";
+    this.storageKey = `${cfg.storagePrefix}:state:${cfg.platformId}`;
+    this.seqKey = `${cfg.storagePrefix}:seq:${cfg.platformId}`;
+    this.api = new ApiClient(cfg.apiUrl, () => this.token, cfg.transport.requestTimeoutMs);
+  }
+  get session() {
+    return this.info;
+  }
+  get tabId() {
+    return this.info?.tabId;
+  }
+  get currentToken() {
+    return this.token;
+  }
+  // ---- persistência -------------------------------------------------------
+  loadPersisted() {
+    const raw = safe(() => sessionStorage.getItem(this.storageKey));
+    if (!raw) return null;
+    try {
+      const s = JSON.parse(raw);
+      if (s.version !== STATE_VERSION || s.platformId !== this.cfg.platformId || !s.sessionId || !s.sessionToken) return null;
+      if (s.expiresAt && s.expiresAt < Date.now()) return null;
+      const seq = Number(safe(() => sessionStorage.getItem(this.seqKey)) ?? 0);
+      s.sequence = Math.max(s.sequence ?? 0, Number.isFinite(seq) ? seq : 0);
+      return s;
+    } catch {
+      return null;
+    }
+  }
+  persist(status, extra = {}) {
+    if (!this.info) return;
+    this.state = {
+      version: STATE_VERSION,
+      tabId: this.info.tabId,
+      sessionId: this.info.sessionId,
+      executionId: this.info.executionId,
+      testCaseId: this.info.testCaseId,
+      platformId: this.cfg.platformId,
+      sessionToken: this.token,
+      status,
+      sequence: this.seq,
+      pageCount: this.state?.pageCount ?? 0,
+      heartbeatIntervalMs: this.state?.heartbeatIntervalMs,
+      expiresAt: this.state?.expiresAt,
+      updatedAt: Date.now(),
+      ...extra
+    };
+    safe(() => sessionStorage.setItem(this.storageKey, JSON.stringify(this.state)));
+  }
+  setStatus(status) {
+    this.persist(status);
+  }
+  clearPersisted() {
+    safe(() => sessionStorage.removeItem(this.storageKey));
+    safe(() => sessionStorage.removeItem(this.seqKey));
+    this.state = null;
+  }
+  // ---- sequência ----------------------------------------------------------
+  nextSequence() {
+    this.seq++;
+    safe(() => sessionStorage.setItem(this.seqKey, String(this.seq)));
+    return this.seq;
+  }
+  get lastSequence() {
+    return this.seq;
+  }
+  /** Sobe a sequência até pelo menos `n` (ex.: maior sequência encontrada no buffer). */
+  ensureSequenceAtLeast(n) {
+    if (n > this.seq) this.seq = n;
+  }
+  newPage() {
+    if (!this.info) throw new InvalidStateError("Sem sess\xE3o ativa");
+    this.info = { ...this.info, pageId: uid("pg_") };
+    this.persist(this.state?.status ?? "recording", { pageCount: (this.state?.pageCount ?? 0) + 1 });
+    return this.info.pageId;
+  }
+  get pageCount() {
+    return this.state?.pageCount ?? 0;
+  }
+  // ---- ciclo de vida ------------------------------------------------------
+  /** Cria (ou obtém, de forma idempotente) a sessão no backend. */
+  async create(opts, context) {
+    if (!opts?.sessionToken || !opts.executionId || !opts.testCaseId)
+      throw new AuthError("sessionToken, executionId e testCaseId s\xE3o obrigat\xF3rios");
+    this.token = opts.sessionToken;
+    const tabId = await resolveTabId(this.cfg.storagePrefix, this.loadPersisted()?.tabId);
+    const res = await this.api.createSession({
+      platformId: this.cfg.platformId,
+      testCaseId: opts.testCaseId,
+      executionId: opts.executionId,
+      tabId,
+      sdkVersion: chunkB6GO5FE5_cjs.SDK_VERSION,
+      appVersion: this.cfg.appVersion,
+      context
+    });
+    if (!res.recording?.enabled) {
+      this.disabledReason = res.recording?.reason;
+      throw new SessionDisabledError(res.recording?.reason);
+    }
+    if (res.sessionToken) this.token = res.sessionToken;
+    this.seq = 0;
+    this.info = {
+      sessionId: res.sessionId,
+      executionId: opts.executionId,
+      testCaseId: opts.testCaseId,
+      platformId: this.cfg.platformId,
+      tabId,
+      pageId: uid("pg_"),
+      startedAt: Date.now()
+    };
+    safe(() => sessionStorage.removeItem(this.seqKey));
+    this.persist("recording", {
+      heartbeatIntervalMs: res.heartbeatIntervalMs,
+      expiresAt: res.expiresAt,
+      pageCount: 1,
+      sequence: 0
+    });
+    return res;
+  }
+  /** Reidrata sessão persistida (reload/navegação MPA) após validar no backend. */
+  async resume(state) {
+    this.token = state.sessionToken;
+    const tabId = await resolveTabId(this.cfg.storagePrefix, state.tabId);
+    const res = await this.api.status(state.sessionId);
+    if (res.status === "expired") throw new SessionExpiredError();
+    if (res.status === "disabled") throw new SessionDisabledError();
+    if (res.sessionToken) this.token = res.sessionToken;
+    this.state = { ...state, tabId };
+    this.seq = tabId === state.tabId ? state.sequence : 0;
+    this.info = {
+      sessionId: state.sessionId,
+      executionId: state.executionId,
+      testCaseId: state.testCaseId,
+      platformId: state.platformId,
+      tabId,
+      pageId: uid("pg_"),
+      startedAt: Date.now()
+    };
+    this.persist(state.status, { sessionToken: this.token, expiresAt: res.expiresAt ?? state.expiresAt, pageCount: state.pageCount + 1, tabId });
+    return res;
+  }
+  startHeartbeat(onResult, onError, pending, status) {
+    this.stopHeartbeat();
+    const every = this.state?.heartbeatIntervalMs ?? this.cfg.heartbeatIntervalMs;
+    if (!every || every <= 0) return;
+    this.heartbeatTimer = setInterval(async () => {
+      if (!this.info) return;
+      try {
+        const r = await this.api.heartbeat(this.info.sessionId, {
+          tabId: this.info.tabId,
+          pageId: this.info.pageId,
+          status: status(),
+          pending: pending(),
+          lastSequence: this.seq
+        });
+        if (r.sessionToken) {
+          this.token = r.sessionToken;
+          this.persist(this.state?.status ?? "recording", { sessionToken: r.sessionToken, expiresAt: r.expiresAt });
+        }
+        onResult(r);
+      } catch (e) {
+        if (e instanceof AuthError || e instanceof SessionExpiredError) onError(e);
+      }
+    }, every);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = void 0;
+  }
+  async complete(summary) {
+    if (!this.info) return false;
+    const r = await this.api.complete(this.info.sessionId, { tabId: this.info.tabId, lastSequence: this.seq, ...summary });
+    return !!r.completed;
+  }
+  reset() {
+    this.stopHeartbeat();
+    this.info = null;
+    this.state = null;
+    this.token = "";
+    this.seq = 0;
+  }
+};
+var heldLocks = [];
+async function resolveTabId(prefix, previous) {
+  const candidate = previous ?? uid("tab_");
+  const locks = globalThis.navigator?.locks;
+  if (!locks || !previous) {
+    if (locks) void claim(locks, `${prefix}:tab:${candidate}`);
+    return candidate;
+  }
+  if (heldLocks.includes(candidate)) return candidate;
+  const ok = await claim(locks, `${prefix}:tab:${candidate}`);
+  if (ok) return candidate;
+  const fresh = uid("tab_");
+  void claim(locks, `${prefix}:tab:${fresh}`);
+  return fresh;
+}
+function claim(locks, name) {
+  return new Promise((resolve) => {
+    try {
+      void locks.request(name, { ifAvailable: true }, (lock) => {
+        if (!lock) {
+          resolve(false);
+          return void 0;
+        }
+        heldLocks.push(name.split(":tab:")[1]);
+        resolve(true);
+        return new Promise(() => void 0);
+      }).catch(() => resolve(true));
+    } catch {
+      resolve(true);
+    }
+  });
+}
+
+// src/core/config.ts
+function resolveConfig(input) {
+  if (!input || typeof input !== "object") throw new ConfigError("Configura\xE7\xE3o ausente");
+  if (!input.platformId) throw new ConfigError("platformId \xE9 obrigat\xF3rio");
+  if (!input.apiUrl) throw new ConfigError("apiUrl \xE9 obrigat\xF3rio");
+  let url;
+  try {
+    url = new URL(input.apiUrl);
+  } catch {
+    throw new ConfigError(`apiUrl inv\xE1lida: ${input.apiUrl}`);
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local))
+    throw new ConfigError("apiUrl deve usar HTTPS (HTTP s\xF3 \xE9 aceito em localhost)");
+  return {
+    apiUrl: url.origin + url.pathname.replace(/\/+$/, ""),
+    platformId: input.platformId,
+    appVersion: input.appVersion,
+    recording: deepMerge(DEFAULT_RECORDING, input.recording),
+    privacy: resolvePrivacy(input.privacy),
+    transport: deepMerge(DEFAULT_TRANSPORT, input.transport),
+    correlationWindowMs: input.correlationWindowMs ?? 3e3,
+    autoResume: input.autoResume ?? true,
+    heartbeatIntervalMs: input.heartbeatIntervalMs ?? 3e4,
+    storagePrefix: input.storagePrefix ?? "offscript",
+    debug: input.debug ?? false
+  };
+}
+
+// src/core/OffscriptSDK.ts
+var MAX_LOG = 5e3;
+var Offscript = class {
+  constructor(config) {
+    this.bus = new Emitter();
+    this.status = "idle";
+    this.recorders = [];
+    this.accepting = false;
+    this.destroyed = false;
+    this.recent = [];
+    this.actionLog = [];
+    this.contextLog = [];
+    this.eventCount = 0;
+    this.metrics = { emitMs: 0, emitted: 0, dropped: 0 };
+    this.config = resolveConfig(config);
+    this.sanitizer = new DataSanitizer(this.config.privacy);
+    this.sessions = new SessionManager(this.config);
+  }
+  // ------------------------------------------------------------------ API pública
+  getState() {
+    return { status: this.status, session: this.sessions.session, pending: this.transport?.pending ?? 0, lastError: this.lastError };
+  }
+  getMetrics() {
+    return { emitted: this.metrics.emitted, dropped: this.metrics.dropped, avgEmitMs: this.metrics.emitted ? this.metrics.emitMs / this.metrics.emitted : 0, bufferKind: this.transport?.bufferKind };
+  }
+  /** Idempotente. Prepara armazenamento/transporte e retoma sessão persistida (reload/MPA). */
+  init() {
+    if (this.destroyed) return Promise.reject(new InvalidStateError("SDK destru\xEDdo"));
+    this.initPromise ?? (this.initPromise = this.doInit());
+    return this.initPromise;
+  }
+  async doInit() {
+    if (typeof window === "undefined") throw new OffscriptError("NOT_SUPPORTED", "O SDK requer um ambiente de navegador");
+    this.setStatus("initializing");
+    try {
+      const buffer = await openBuffer(`${this.config.storagePrefix}-${this.config.platformId}`, this.config.transport.persist);
+      this.transport = new EventTransport(this.config.transport, this.sessions.api, buffer);
+      this.transport.on("flushed", (e) => this.bus.emit("flush", e));
+      this.transport.on("overflow", (e) => this.bus.emit("overflow", e));
+      this.transport.on("fatal", ({ error }) => void this.onFatal(error));
+      this.transport.on("failed", ({ error }) => this.debug("transport failed", error));
+      await this.transport.purgeExpired(this.config.privacy.localRetentionMs);
+      this.setStatus("idle");
+      const persisted = this.config.autoResume ? this.sessions.loadPersisted() : null;
+      if (persisted) await this.resumePersisted(persisted);
+    } catch (e) {
+      this.fail(e);
+      throw e;
+    }
+  }
+  async startRecording(opts) {
+    if (this.destroyed) throw new InvalidStateError("SDK destru\xEDdo");
+    if (this.startPromise) return this.startPromise;
+    const p = this.doStart(opts).finally(() => this.startPromise = void 0);
+    this.startPromise = p;
+    return p;
+  }
+  async doStart(opts) {
+    await this.init();
+    const cur = this.sessions.session;
+    if ((this.status === "recording" || this.status === "paused") && cur) {
+      if (cur.executionId === opts.executionId) return cur;
+      throw new InvalidStateError(`J\xE1 existe grava\xE7\xE3o ativa para a execu\xE7\xE3o ${cur.executionId}. Encerre-a antes.`);
+    }
+    if (this.status === "stopping") throw new InvalidStateError("Grava\xE7\xE3o em encerramento");
+    this.setStatus("initializing");
+    try {
+      const ctx = collectContext({ platformId: this.config.platformId, testCaseId: opts.testCaseId, executionId: opts.executionId }, "initial", this.config.appVersion);
+      await this.sessions.create(opts, { ...ctx, url: this.sanitizer.sanitizeUrl(ctx.url), referrer: void 0, title: void 0 });
+      const s = this.sessions.session;
+      await this.transport.start({ sessionId: s.sessionId, executionId: s.executionId, tabId: s.tabId });
+      this.attach();
+      this.accepting = true;
+      this.setStatus("recording");
+      this.emitLifecycle("session-start", { pageCount: 1 }, "critical");
+      await this.startRecorders();
+      this.sessions.startHeartbeat((r) => this.onHeartbeat(r.status), (e) => void this.onFatal(e), () => this.transport?.pending ?? 0, () => this.status);
+      this.bus.emit("sessionStart", s);
+      return s;
+    } catch (e) {
+      await this.teardown();
+      this.sessions.clearPersisted();
+      this.sessions.reset();
+      this.fail(e);
+      throw e;
+    }
+  }
+  async resumePersisted(state) {
+    this.setStatus("initializing");
+    try {
+      await this.sessions.resume(state);
+      const s = this.sessions.session;
+      await this.transport.start({ sessionId: s.sessionId, executionId: s.executionId, tabId: s.tabId });
+      this.attach();
+      this.accepting = state.status === "recording";
+      this.setStatus(state.status);
+      this.emitLifecycle("session-resume", { pageCount: this.sessions.pageCount }, "critical");
+      this.emitLifecycle("page-start", { navigationType: safe(() => performance.getEntriesByType("navigation")[0]?.type) }, "critical");
+      await this.startRecorders();
+      if (state.status === "paused") this.recorders.forEach((r) => r.pause?.());
+      this.actions?.recordPageLoad(safe(() => performance.getEntriesByType("navigation")[0]?.type), document.referrer);
+      this.sessions.startHeartbeat((r) => this.onHeartbeat(r.status), (e) => void this.onFatal(e), () => this.transport?.pending ?? 0, () => this.status);
+      this.bus.emit("sessionStart", s);
+    } catch (e) {
+      await this.teardown();
+      this.sessions.clearPersisted();
+      this.sessions.reset();
+      this.fail(e);
+      if (!(e instanceof SessionExpiredError || e instanceof SessionDisabledError || e instanceof AuthError)) throw e;
+    }
+  }
+  async pauseRecording() {
+    if (this.status === "paused") return;
+    if (this.status !== "recording") throw new InvalidStateError(`N\xE3o \xE9 poss\xEDvel pausar no estado ${this.status}`);
+    this.actions?.flushAll();
+    this.emitLifecycle("pause", {}, "critical");
+    this.accepting = false;
+    this.recorders.forEach((r) => safe(() => r.pause?.()));
+    this.sessions.setStatus("paused");
+    this.setStatus("paused");
+    void this.transport?.flush();
+  }
+  async resumeRecording() {
+    if (this.status === "recording") return;
+    if (this.status !== "paused") throw new InvalidStateError(`N\xE3o \xE9 poss\xEDvel retomar no estado ${this.status}`);
+    this.accepting = true;
+    this.sessions.setStatus("recording");
+    this.setStatus("recording");
+    this.emitLifecycle("resume", {}, "critical");
+    for (const r of this.recorders) await Promise.resolve(safe(() => r.resume?.()));
+  }
+  stopRecording() {
+    if (this.stopPromise) return this.stopPromise;
+    const s = this.sessions.session;
+    if (!s || this.status !== "recording" && this.status !== "paused" && this.status !== "error") {
+      if (this.status === "stopped" || this.status === "idle")
+        return Promise.resolve({ sessionId: s?.sessionId ?? "", flushed: true, pendingEvents: 0, completed: true });
+      return Promise.reject(new InvalidStateError(`N\xE3o \xE9 poss\xEDvel encerrar no estado ${this.status}`));
+    }
+    this.stopPromise = this.doStop().finally(() => this.stopPromise = void 0);
+    return this.stopPromise;
+  }
+  async doStop() {
+    const session = this.sessions.session;
+    this.setStatus("stopping");
+    if (this.status === "stopping") {
+      this.actions?.flushAll();
+      this.emitLifecycle("stop", { eventCount: this.eventCount }, "critical");
+    }
+    this.accepting = false;
+    this.stopRecorders();
+    this.sessions.stopHeartbeat();
+    const { ok, pending } = await this.transport?.flushFinal() ?? { ok: true, pending: 0 };
+    let completed = false;
+    if (ok) {
+      try {
+        completed = await this.sessions.complete({ eventCount: this.eventCount, pages: this.sessions.pageCount });
+      } catch (e) {
+        this.bus.emit("error", e);
+      }
+    }
+    if (ok) await this.transport?.clearSession(session.sessionId);
+    this.transport?.stop();
+    this.lifecycle?.uninstall();
+    this.sessions.clearPersisted();
+    this.sessions.reset();
+    const summary = { sessionId: session.sessionId, flushed: ok, pendingEvents: pending, completed };
+    this.setStatus("stopped");
+    this.bus.emit("sessionEnd", summary);
+    return summary;
+  }
+  /**
+   * Libera todos os recursos. Por padrão encerra a gravação ativa; com `{ complete: false }` apenas
+   * desanexa a instrumentação e mantém a sessão persistida para ser retomada por outra instância.
+   */
+  async destroy(opts = {}) {
+    if (this.destroyed) return;
+    if (opts.complete !== false && (this.status === "recording" || this.status === "paused")) {
+      await this.stopRecording().catch(() => void 0);
+    } else {
+      this.actions?.flushAll();
+      if (this.accepting) this.emitLifecycle("page-end", {}, "critical");
+      this.accepting = false;
+      await this.transport?.flushFinal(2e3).catch(() => void 0);
+    }
+    this.destroyed = true;
+    await this.teardown();
+    this.sessions.reset();
+    this.transport?.close();
+    this.bus.clear();
+  }
+  /** Dados estruturados para o motor Playwright, construídos a partir do que foi gravado nesta página. */
+  exportPlaywrightData() {
+    const s = this.sessions.session;
+    if (!s) throw new InvalidStateError("Sem sess\xE3o ativa");
+    return chunkB6GO5FE5_cjs.buildPlaywrightContract({
+      session: { sessionId: s.sessionId, executionId: s.executionId, testCaseId: s.testCaseId, platformId: s.platformId },
+      actions: this.actionLog,
+      contexts: this.contextLog.map((e) => e.data)
+    });
+  }
+  getRecordedActions() {
+    return this.actionLog;
+  }
+  // ------------------------------------------------------------------ EventSink
+  on(type, fn) {
+    return this.bus.on(type, fn);
+  }
+  off(type, fn) {
+    this.bus.off(type, fn);
+  }
+  /** Usado pelos recorders. Não confundir com os eventos públicos (`on`). */
+  emit(kind, data, opts = {}) {
+    return this.record(kind, data, opts);
+  }
+  record(kind, data, opts) {
+    const t0 = typeof performance !== "undefined" ? performance.now() : 0;
+    try {
+      const session = this.sessions.session;
+      const transport = this.transport;
+      if (!this.accepting || !session || !transport) return null;
+      const priority = opts.priority ?? "normal";
+      if (!transport.canAccept(priority)) {
+        transport.noteDropped();
+        this.metrics.dropped++;
+        return null;
+      }
+      this.rrweb?.recoverIfNeeded();
+      const sequence = this.sessions.nextSequence();
+      const timestamp = opts.at ?? Date.now();
+      const id = `${session.tabId}:${sequence}`;
+      let payload = data;
+      let relatedActionId;
+      let relatedActionDeltaMs;
+      if (kind === "action") {
+        const action = { ...data, id, sessionId: session.sessionId, executionId: session.executionId, sequence, timestamp };
+        payload = action;
+        this.recent.push({ id, t: timestamp });
+        if (this.recent.length > 50) this.recent.shift();
+        this.actionLog.push(action);
+        if (this.actionLog.length > MAX_LOG) this.actionLog.shift();
+      } else if (kind === "http" || kind === "console" || kind === "error" || kind === "iframe") {
+        const rel = this.correlate(timestamp);
+        relatedActionId = rel?.id;
+        relatedActionDeltaMs = rel ? timestamp - rel.t : void 0;
+      }
+      const event = {
+        id,
+        kind,
+        sessionId: session.sessionId,
+        executionId: session.executionId,
+        tabId: session.tabId,
+        pageId: session.pageId,
+        sequence,
+        timestamp,
+        relatedActionId,
+        relatedActionDeltaMs,
+        data: payload
+      };
+      if (kind === "context") {
+        this.contextLog.push(event);
+        if (this.contextLog.length > 50) this.contextLog.shift();
+      }
+      this.eventCount++;
+      transport.enqueue(event);
+      this.metrics.emitted++;
+      if (this.config.debug) this.debug("event", kind, sequence);
+      return event;
+    } catch (e) {
+      this.debug("emit failed", e);
+      return null;
+    } finally {
+      if (t0) this.metrics.emitMs += performance.now() - t0;
+    }
+  }
+  correlate(at) {
+    for (let i = this.recent.length - 1; i >= 0; i--) {
+      const a = this.recent[i];
+      if (a.t <= at) return at - a.t <= this.config.correlationWindowMs ? a : void 0;
+    }
+    return void 0;
+  }
+  // ------------------------------------------------------------------ internos
+  emitLifecycle(type, detail = {}, priority = "normal") {
+    this.record("lifecycle", { type, detail }, { priority });
+  }
+  attach() {
+    this.lifecycle ?? (this.lifecycle = new LifecycleManager({
+      onPageHide: () => {
+        if (!this.accepting) return;
+        this.actions?.flushAll();
+        this.emitLifecycle("page-end", { url: this.sanitizer.sanitizeUrl(location.href) }, "critical");
+        this.transport?.flushOnUnload();
+      },
+      onVisibility: (hidden) => {
+        if (hidden && this.accepting) {
+          this.actions?.flushAll();
+          void this.transport?.flush();
+        }
+      },
+      onConnectivity: (online) => this.transport?.setOnline(online),
+      onNavigation: ({ from, to, kind }) => {
+        if (!this.accepting) return;
+        this.actions?.recordNavigation(from, to, kind);
+        this.emitLifecycle("navigation", { from: this.sanitizer.sanitizeUrl(from), to: this.sanitizer.sanitizeUrl(to), kind }, "critical");
+        this.context?.record("navigation");
+      }
+    }));
+    this.lifecycle.install();
+    this.transport?.setOnline(typeof navigator === "undefined" ? true : navigator.onLine !== false);
+  }
+  async startRecorders() {
+    const r = this.config.recording;
+    const list = [];
+    if (r.rrweb) list.push(this.rrweb = new RRWebRecorder(this));
+    if (r.context) list.push(this.context = new ContextRecorder(this, () => ({ platformId: this.config.platformId, testCaseId: this.sessions.session.testCaseId, executionId: this.sessions.session.executionId })));
+    if (r.actions) list.push(this.actions = new ActionRecorder(this));
+    if (r.http) list.push(new HTTPRecorder(this, this.config.apiUrl));
+    if (r.console || r.errors) list.push(new ErrorRecorder(this));
+    if (r.iframes) list.push(new IframeRecorder(this));
+    this.recorders = list;
+    for (const rec of list) {
+      try {
+        await rec.start();
+      } catch (e) {
+        this.emitLifecycle("recorder-error", { recorder: rec.name, message: String(e?.message ?? e) });
+        this.bus.emit("error", e);
+      }
+    }
+  }
+  stopRecorders() {
+    for (const r of this.recorders.splice(0).reverse()) safe(() => r.stop());
+    this.rrweb = this.actions = this.context = void 0;
+  }
+  async teardown() {
+    this.accepting = false;
+    this.stopRecorders();
+    this.sessions.stopHeartbeat();
+    this.lifecycle?.uninstall();
+    this.lifecycle = void 0;
+    this.transport?.stop();
+  }
+  onHeartbeat(status) {
+    if (status === "disabled") void this.shutdownRemote(new SessionDisabledError());
+    else if (status === "expired") void this.onFatal(new SessionExpiredError());
+  }
+  /** Backend desativou a gravação: encerra com flush de melhor esforço. */
+  async shutdownRemote(err) {
+    if (this.status !== "recording" && this.status !== "paused") return;
+    this.accepting = false;
+    this.stopRecorders();
+    this.sessions.stopHeartbeat();
+    const session = this.sessions.session;
+    await this.transport?.flushFinal(3e3).catch(() => void 0);
+    this.transport?.stop();
+    this.lifecycle?.uninstall();
+    this.sessions.clearPersisted();
+    this.sessions.reset();
+    this.setStatus("stopped");
+    this.bus.emit("disabled", { reason: err.message });
+    if (session) this.bus.emit("sessionEnd", { sessionId: session.sessionId, flushed: false, pendingEvents: this.transport?.pending ?? 0, completed: false });
+  }
+  async onFatal(err) {
+    if (this.status === "error" || this.status === "stopped") return;
+    await this.teardown();
+    this.sessions.clearPersisted();
+    this.sessions.reset();
+    this.fail(err);
+  }
+  fail(e) {
+    const err = e instanceof Error ? e : new Error(String(e));
+    this.lastError = { code: err.code ?? "INTERNAL", message: err.message };
+    this.setStatus("error");
+    this.bus.emit("error", err);
+  }
+  setStatus(to) {
+    const from = this.status;
+    if (from === to) return;
+    this.status = to;
+    this.bus.emit("statusChange", { from, to });
+  }
+  debug(...args) {
+    if (this.config.debug) console.debug("[offscript]", ...args);
+  }
+};
+Offscript.version = chunkB6GO5FE5_cjs.SDK_VERSION;
+
+exports.AuthError = AuthError;
+exports.ConfigError = ConfigError;
+exports.DEFAULT_PRIVACY = DEFAULT_PRIVACY;
+exports.DEFAULT_RECORDING = DEFAULT_RECORDING;
+exports.DEFAULT_TRANSPORT = DEFAULT_TRANSPORT;
+exports.DataSanitizer = DataSanitizer;
+exports.InvalidStateError = InvalidStateError;
+exports.Offscript = Offscript;
+exports.OffscriptError = OffscriptError;
+exports.SessionDisabledError = SessionDisabledError;
+exports.SessionExpiredError = SessionExpiredError;
+exports.TransportError = TransportError;
+//# sourceMappingURL=chunk-3NX2AGXM.cjs.map
+//# sourceMappingURL=chunk-3NX2AGXM.cjs.map