@offscript/sdk 0.1.1 → 0.1.5

package/dist/{chunk-3OSCH7J2.js → chunk-XBXFGCUT.js}

@@ -1,4 +1,4 @@
-import { buildPlaywrightContract, SDK_VERSION, SCHEMA_VERSION, SelectorGenerator, ACTION_SCHEMA_VERSION } from './chunk-LFXHB4PN.js';
+import { buildPlaywrightContract, SDK_VERSION, SelectorGenerator, ACTION_SCHEMA_VERSION } from './chunk-6ROP37WI.js';
 
 // src/types/config.ts
 var DEFAULT_RECORDING = {
@@ -18,7 +18,7 @@ var DEFAULT_RECORDING = {
   stableAttributes: ["name", "data-id", "aria-label"]
 };
 var DEFAULT_PRIVACY = {
-  maskSensitiveInputs: true,
+  maskSensitiveInputs: false,
   maskAllText: false,
   captureRequestBodies: false,
   captureResponseBodies: false,
@@ -30,23 +30,9 @@ var DEFAULT_PRIVACY = {
   ignoreUrls: [],
   redactHeaders: [],
   redactKeys: [],
+  captureSensitiveValues: false,
   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
+  textContentTypes: [/^text\//i, /json/i, /xml/i, /x-www-form-urlencoded/i, /javascript/i]
 };
 
 // src/utils/misc.ts
@@ -85,13 +71,6 @@ function debounce(fn, ms) {
   };
   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;
@@ -159,13 +138,15 @@ var DataSanitizer = class {
     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()));
+    this.open = cfg.captureSensitiveValues === true;
   }
   isSensitiveKey(key) {
+    if (this.open) return false;
     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;
+    if (this.open || !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) => {
@@ -175,6 +156,7 @@ var DataSanitizer = class {
     return s;
   }
   sanitizeHeaders(headers) {
+    if (this.open) return { ...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);
@@ -183,6 +165,7 @@ var DataSanitizer = class {
   }
   /** Redige query params sensíveis e credenciais embutidas (user:pass@). */
   sanitizeUrl(raw, base) {
+    if (this.open) return raw;
     try {
       const u = new URL(raw, base ?? (typeof location !== "undefined" ? location.href : void 0));
       if (u.username || u.password) {
@@ -201,7 +184,7 @@ var DataSanitizer = class {
   }
   /** 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;
+    if (this.open || 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;
@@ -302,37 +285,12 @@ var ConfigError = class extends OffscriptError {
     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();
@@ -359,591 +317,6 @@ var Emitter = class {
   }
 };
 
-// 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": 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: 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: 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 {
@@ -958,6 +331,7 @@ function guard(sink, name, fn) {
 
 // src/recorders/ActionRecorder.ts
 var KEYS = /* @__PURE__ */ new Set(["Enter", "Escape", "Tab", "Backspace", "Delete", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown"]);
+var MODIFIERS = /* @__PURE__ */ new Set(["Control", "Shift", "Alt", "Meta"]);
 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;
@@ -1083,7 +457,7 @@ var ActionRecorder = class {
   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 (el instanceof HTMLInputElement && ["checkbox", "radio", "file"].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);
@@ -1101,8 +475,9 @@ var ActionRecorder = class {
     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);
+    const listed = Boolean(allowed) && safe(() => el.matches(allowed));
+    if (policy.captureSensitiveValues || !isPassword && (!policy.maskSensitiveInputs || listed)) {
+      payload.value = policy.captureSensitiveValues ? value : this.sink.sanitizer.scrubString(value);
       payload.valueCaptured = true;
     } else {
       payload.valueCaptured = false;
@@ -1130,13 +505,15 @@ var ActionRecorder = class {
     }
   }
   onKey(e) {
-    const el = this.target(e);
+    const el = this.target(e) ?? document.body;
     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;
+    const isModifier = MODIFIERS.has(e.key);
+    const relevant = KEYS.has(e.key) || isModifier || /^F\d{1,2}$/.test(e.key) || modified && e.key.length === 1;
+    if (!relevant || isModifier && e.repeat) 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);
+    const modifiers = mods(e).filter((name) => name !== e.key);
+    this.emit({ type: "keydown", payload: { key: e.key, code: e.code, modifiers, repeat: e.repeat } }, el);
   }
   onFocus(type, e) {
     const el = this.target(e);
@@ -1269,7 +646,7 @@ function parseBrowser(ua) {
   }
   return {};
 }
-function collectContext(id, reason, appVersion) {
+function collectContext(reason, captureSensitiveValues = false) {
   const nav = navigator;
   const ua = nav.userAgent ?? "";
   let browser = parseBrowser(ua);
@@ -1293,17 +670,13 @@ function collectContext(id, reason, appVersion) {
     timezone: safe(() => Intl.DateTimeFormat().resolvedOptions().timeZone),
     online: nav.onLine,
     visibility: document.visibilityState,
-    platformId: id.platformId,
-    testCaseId: id.testCaseId,
-    executionId: id.executionId,
     sdkVersion: SDK_VERSION,
-    appVersion
+    captureSensitiveValues
   };
 }
 var ContextRecorder = class {
-  constructor(sink, identity) {
+  constructor(sink) {
     this.sink = sink;
-    this.identity = identity;
     this.name = "context";
     this.d = new Disposer();
   }
@@ -1316,7 +689,7 @@ var ContextRecorder = class {
   }
   record(reason) {
     guard(this.sink, this.name, () => {
-      const data = collectContext(this.identity(), reason, this.sink.config.appVersion);
+      const data = collectContext(reason, this.sink.config.privacy.captureSensitiveValues);
       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" });
@@ -1475,23 +848,28 @@ function uid(prefix = "") {
 }
 
 // src/recorders/HTTPRecorder.ts
-var XHR_PATCHED = "__offscriptXhrOriginal";
 var HTTPRecorder = class {
-  constructor(sink, ownApiUrl) {
+  constructor(sink) {
     this.sink = sink;
-    this.ownApiUrl = ownApiUrl;
     this.name = "http";
     this.inflight = 0;
     this.active = false;
+    this.delivering = false;
+    this.pending = /* @__PURE__ */ new Set();
     this.restore = [];
   }
   start() {
     if (this.active) return;
     this.active = true;
+    this.delivering = true;
     this.patchFetch();
     this.patchXhr();
   }
   stop() {
+    this.delivering = false;
+    this.detach();
+  }
+  detach() {
     this.active = false;
     for (const r of this.restore.splice(0).reverse()) {
       try {
@@ -1500,8 +878,30 @@ var HTTPRecorder = class {
       }
     }
   }
+  /** Stops new capture and allows up to two seconds for pending HTTP/body capture. */
+  async drain() {
+    this.detach();
+    let timer;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(resolve, 2e3);
+    });
+    const settle = async () => {
+      while (this.delivering && this.pending.size) {
+        await Promise.allSettled([...this.pending]);
+      }
+    };
+    try {
+      await Promise.race([settle(), timeout]);
+    } finally {
+      clearTimeout(timer);
+      this.delivering = false;
+    }
+  }
+  track(promise) {
+    const tracked = promise.catch(() => void 0).finally(() => this.pending.delete(tracked));
+    this.pending.add(tracked);
+  }
   isIgnored(url) {
-    if (this.ownApiUrl && url.startsWith(this.ownApiUrl)) return true;
     return this.sink.sanitizer.isIgnoredUrl(url);
   }
   // ---------------------------------------------------------------- fetch
@@ -1527,14 +927,13 @@ var HTTPRecorder = class {
       }
       if (ctx) {
         const c = ctx;
-        p.then(
+        self.track(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;
@@ -1582,13 +981,13 @@ var HTTPRecorder = class {
         base.responseBody = { kind: "omitted", reason: "body-used" };
         return void this.emit(base);
       }
-      this.readBounded(clone).then(({ text, size, truncated }) => {
+      this.track(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)));
+      }).finally(() => guard(this.sink, this.name, () => this.emit(base))));
     });
   }
   async readBounded(res) {
@@ -1599,8 +998,8 @@ var HTTPRecorder = class {
     let size = 0;
     let truncated = false;
     for (; ; ) {
-      const { done: done2, value } = await reader.read();
-      if (done2) break;
+      const { done, value } = await reader.read();
+      if (done) break;
       size += value.byteLength;
       if (text.length < max) text += dec.decode(value, { stream: true });
       if (size > max * 4) {
@@ -1657,7 +1056,6 @@ var HTTPRecorder = class {
       }
       return origSend.call(this, body);
     };
-    open[XHR_PATCHED] = origOpen;
     proto.open = open;
     proto.setRequestHeader = setHeader;
     proto.send = send;
@@ -1679,9 +1077,14 @@ var HTTPRecorder = class {
     this.inflight++;
     xhr.addEventListener("abort", () => m.aborted = true);
     xhr.addEventListener("timeout", () => m.timedOut = true);
+    let finishCapture;
+    this.track(new Promise((resolve) => {
+      finishCapture = resolve;
+    }));
     xhr.addEventListener("loadend", () => {
       this.inflight = Math.max(0, this.inflight - 1);
       guard(this.sink, this.name, () => this.endXhr(xhr, m, ctx));
+      finishCapture();
     });
   }
   endXhr(xhr, m, ctx) {
@@ -1725,6 +1128,7 @@ var HTTPRecorder = class {
     };
   }
   emit(data) {
+    if (!this.delivering) return;
     this.sink.emit("http", data, { priority: "normal", at: data.startedAt });
   }
   describeBody(body, contentType) {
@@ -1870,9 +1274,10 @@ var RRWebRecorder = class {
       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 },
+      maskAllInputs: privacy.maskSensitiveInputs && !privacy.captureSensitiveValues,
+      maskInputOptions: privacy.captureSensitiveValues ? { password: false } : 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 (privacy.captureSensitiveValues) return text;
         if (el?.type === "password") return "*".repeat(text.length);
         if (allowed && safe(() => el.matches(allowed))) return text;
         return "*".repeat(text.length);
@@ -1973,11 +1378,12 @@ var LifecycleManager = class {
     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(window, "pageshow", (event) => {
+      if (event.persisted) safe(() => this.h.onPageShow?.());
+    });
     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)));
@@ -2014,532 +1420,1058 @@ var LifecycleManager = class {
   }
 };
 
-// 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;
+// src/core/RecordingStore.ts
+var RecordingStore = class _RecordingStore {
+  constructor(database) {
+    this.database = database;
+    this.pending = /* @__PURE__ */ new Set();
+    this.uncommitted = /* @__PURE__ */ new Map();
+  }
+  static async open(key) {
+    const database = await new Promise((resolve, reject) => {
+      const request = indexedDB.open(`offscript-recording-${key}`, 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore("events", { keyPath: "sequence" });
+        request.result.createObjectStore("state");
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+    return new _RecordingStore(database);
+  }
+  async load() {
+    await this.flush();
+    const checkpoint = sessionStorage.getItem(this.checkpointKey);
+    if (checkpoint) {
+      const saved = JSON.parse(checkpoint);
+      await this.write(["events", "state"], (transaction) => {
+        for (const event of saved.events) transaction.objectStore("events").put(event);
+        transaction.objectStore("state").put(saved.status, "status");
+      });
+      sessionStorage.removeItem(this.checkpointKey);
     }
+    return new Promise((resolve, reject) => {
+      const transaction = this.database.transaction(["events", "state"], "readonly");
+      const events = transaction.objectStore("events").getAll();
+      const state = transaction.objectStore("state").get("status");
+      transaction.oncomplete = () => {
+        this.status = state.result;
+        resolve(state.result ? { status: state.result, events: events.result } : null);
+      };
+      transaction.onabort = () => reject(transaction.error);
+    });
   }
-  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)));
+  append(event) {
+    this.uncommitted.set(event.sequence, event);
+    return this.write(["events"], (transaction) => {
+      transaction.objectStore("events").put(event);
+    }).then(() => {
+      this.uncommitted.delete(event.sequence);
+    });
   }
   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: SDK_VERSION,
-      appVersion: this.cfg.appVersion,
-      context
+    this.status = status;
+    return this.write(["state"], (transaction) => {
+      transaction.objectStore("state").put(status, "status");
     });
-    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
+  }
+  async clear() {
+    await this.write(["events", "state"], (transaction) => {
+      transaction.objectStore("events").clear();
+      transaction.objectStore("state").clear();
     });
-    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);
+    this.failure = void 0;
+    this.status = void 0;
+    this.uncommitted.clear();
+    sessionStorage.removeItem(this.checkpointKey);
   }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-    this.heartbeatTimer = void 0;
+  /** Synchronous handoff of the last uncommitted events before document unload. */
+  checkpoint() {
+    if (!this.status) return;
+    sessionStorage.setItem(this.checkpointKey, JSON.stringify({ status: this.status, events: [...this.uncommitted.values()] }));
   }
-  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;
+  get checkpointKey() {
+    return `${this.database.name}-handoff`;
   }
-  reset() {
-    this.stopHeartbeat();
-    this.info = null;
-    this.state = null;
-    this.token = "";
-    this.seq = 0;
+  async flush() {
+    await Promise.allSettled([...this.pending]);
+    if (this.failure) throw this.failure;
   }
-};
-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) => {
+  async close() {
     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);
+      await this.flush();
+    } finally {
+      this.database.close();
     }
-  });
-}
+  }
+  write(stores, apply) {
+    const operation = new Promise((resolve, reject) => {
+      const transaction = this.database.transaction(stores, "readwrite");
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error ?? new Error("Falha ao salvar grava\xE7\xE3o local"));
+      try {
+        apply(transaction);
+      } catch (error) {
+        transaction.abort();
+        reject(error);
+      }
+    });
+    this.pending.add(operation);
+    void operation.catch((error) => {
+      this.failure = error instanceof Error ? error : new Error(String(error));
+    }).finally(() => this.pending.delete(operation));
+    return operation;
+  }
+};
 
 // 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
+    controls: input.controls ?? true,
+    persistenceKey: input.persistenceKey,
+    onComplete: input.onComplete
   };
 }
 
+// src/ui/RecordingControls.ts
+var HOST_ATTR = "data-offscript-console";
+var EYE_SEQUENCE = [
+  { pose: "open", duration: 2600 },
+  { pose: "blink", duration: 160 },
+  { pose: "open", duration: 1800 },
+  { pose: "left", duration: 700 },
+  { pose: "open", duration: 1500 },
+  { pose: "wink", duration: 480 },
+  { pose: "open", duration: 1900 },
+  { pose: "right", duration: 700 },
+  { pose: "open", duration: 1600 },
+  { pose: "up", duration: 640 },
+  { pose: "happy", duration: 720 }
+];
+var EYE_PATHS = {
+  open: ["M59.5 79.5v15", "M93 79.5v15"],
+  blink: ["M52 89q7.5 5 15 0", "M85.5 89q7.5 5 15 0"],
+  wink: ["M52 89q7.5 5 15 0", "M93 79.5v15"],
+  happy: ["M52 91q7.5-12 15 0", "M85.5 91q7.5-12 15 0"]
+};
+var RecordingControls = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.eyeTimer = 0;
+    this.placeFrame = 0;
+    this.eyeIndex = 0;
+    this.busy = false;
+    this.expanded = true;
+    this.privacyOpen = true;
+    this.failure = "";
+    this.onVisibility = () => {
+      window.clearTimeout(this.eyeTimer);
+      if (!document.hidden) this.scheduleEye();
+    };
+    this.onViewport = () => {
+      this.placeConfirm();
+      this.schedulePlacePrivacy();
+    };
+  }
+  mount() {
+    if (this.host || typeof document === "undefined") return;
+    const host = document.createElement("div");
+    host.setAttribute(HOST_ATTR, "");
+    host.setAttribute("data-offscript-ignore", "");
+    host.className = "offscript-ignore";
+    host.style.cssText = "position:fixed;left:0;top:0;width:0;height:0;margin:0;padding:0;border:0;overflow:visible;z-index:2147483646;pointer-events:none;";
+    const shadow = host.attachShadow({ mode: "closed" });
+    shadow.innerHTML = TEMPLATE;
+    this.bind(shadow);
+    this.host = host;
+    this.shadow = shadow;
+    this.note = shadow.querySelector("[data-note]") ?? void 0;
+    this.place();
+    this.watchDom();
+    this.unsubscribe = this.sdk.on("statusChange", () => this.render());
+    window.addEventListener("resize", this.onViewport);
+    window.visualViewport?.addEventListener("resize", this.onViewport);
+    document.fonts?.ready.then(() => {
+      if (this.host) this.onViewport();
+    });
+    this.watchDock();
+    this.render();
+    this.startEyes();
+  }
+  /** Independent notice so the host may destroy the controls after successful upload. */
+  showSuccess() {
+    const notice = document.createElement("div");
+    notice.setAttribute("data-offscript-success", "");
+    notice.setAttribute("data-offscript-ignore", "");
+    notice.className = "offscript-ignore";
+    notice.style.cssText = "position:fixed;right:16px;bottom:16px;max-width:calc(100vw - 32px);z-index:2147483647;";
+    const shadow = notice.attachShadow({ mode: "closed" });
+    shadow.innerHTML = SUCCESS_TEMPLATE;
+    document.body.appendChild(notice);
+    const timer = window.setTimeout(() => notice.remove(), 8e3);
+    shadow.querySelector("button").addEventListener("click", () => {
+      window.clearTimeout(timer);
+      notice.remove();
+    });
+  }
+  unmount() {
+    this.unsubscribe?.();
+    this.unsubscribe = void 0;
+    this.observer?.disconnect();
+    this.observer = void 0;
+    this.dockWatch?.disconnect();
+    this.dockWatch = void 0;
+    window.cancelAnimationFrame(this.placeFrame);
+    this.placeFrame = 0;
+    window.clearTimeout(this.eyeTimer);
+    window.removeEventListener("resize", this.onViewport);
+    window.visualViewport?.removeEventListener("resize", this.onViewport);
+    document.removeEventListener("visibilitychange", this.onVisibility);
+    this.host?.remove();
+    this.host = void 0;
+    this.shadow = void 0;
+  }
+  place() {
+    const host = this.host;
+    const parent = document.body ?? document.documentElement;
+    if (!host || !parent || host.parentNode === parent) return;
+    parent.appendChild(host);
+  }
+  watchDom() {
+    if (typeof MutationObserver === "undefined") return;
+    this.observer?.disconnect();
+    this.observer = new MutationObserver(() => {
+      this.place();
+      if (document.body) this.observer?.observe(document.body, { childList: true });
+    });
+    this.observer.observe(document.documentElement, { childList: true });
+    if (document.body) this.observer.observe(document.body, { childList: true });
+  }
+  watchDock() {
+    const dock = this.shadow?.querySelector(".dock");
+    if (!(dock instanceof HTMLElement) || typeof ResizeObserver === "undefined") return;
+    this.dockWatch?.disconnect();
+    this.dockWatch = new ResizeObserver(() => this.placePrivacy());
+    this.dockWatch.observe(dock);
+  }
+  bind(shadow) {
+    const stop = (event) => event.stopPropagation();
+    shadow.addEventListener("click", (event) => {
+      const actionNode = event.composedPath().find((node) => node instanceof Element && node.hasAttribute("data-action"));
+      const action = actionNode instanceof Element ? actionNode.getAttribute("data-action") : null;
+      if (action === "open") {
+        this.expanded = true;
+        this.render();
+      } else if (action === "close") {
+        this.expanded = false;
+        this.render();
+      } else if (action === "record") void this.run(() => this.sdk.startRecording());
+      else if (action === "pause") void this.run(() => this.sdk.pauseRecording());
+      else if (action === "resume") void this.run(() => this.sdk.resumeRecording());
+      else if (action === "stop") void this.run(() => this.sdk.finishRecording());
+      else if (action === "new") this.openConfirm();
+      else if (action === "cancel") this.closeConfirm();
+      else if (action === "confirm") {
+        this.closeConfirm();
+        void this.run(() => this.sdk.discardRecording());
+      } else if (action === "privacy-show") {
+        this.privacyOpen = true;
+        this.render();
+      } else if (action === "privacy-hide") {
+        this.privacyOpen = false;
+        this.render();
+      }
+    }, true);
+    for (const type of ["click", "dblclick", "auxclick", "contextmenu", "pointerdown", "pointerup", "mousedown", "mouseup", "keydown", "keyup", "keypress", "input", "change", "mouseover", "mouseout"]) {
+      shadow.addEventListener(type, stop);
+    }
+    shadow.querySelector("[data-confirm]")?.addEventListener("keydown", (event) => {
+      if (event instanceof KeyboardEvent && event.key === "Escape") this.closeConfirm();
+    });
+    shadow.querySelector("[data-privacy]")?.addEventListener("keydown", (event) => {
+      if (event instanceof KeyboardEvent && event.key === "Escape") {
+        this.privacyOpen = false;
+        this.render();
+      }
+    });
+  }
+  openConfirm() {
+    const bubble = this.shadow?.querySelector("[data-confirm]");
+    if (!(bubble instanceof HTMLElement) || this.busy || !bubble.hidden) return;
+    bubble.hidden = false;
+    this.placeConfirm();
+    this.paintPrivacy();
+    const cancel = bubble.querySelector("[data-action='cancel']");
+    if (cancel instanceof HTMLElement) cancel.focus();
+  }
+  placeConfirm() {
+    const bubble = this.shadow?.querySelector("[data-confirm]");
+    const card = bubble?.querySelector(".bubble");
+    const button = this.shadow?.querySelector("[data-action='new']");
+    if (!(bubble instanceof HTMLElement) || !(card instanceof HTMLElement) || !(button instanceof HTMLElement)) return;
+    const buttonBox = button.getBoundingClientRect();
+    const buttonCenter = buttonBox.left + buttonBox.width / 2;
+    const tailHalf = 4.5;
+    const margin = 12;
+    const viewport = document.documentElement.clientWidth;
+    let rightEdge = buttonCenter + 22 + tailHalf;
+    rightEdge = Math.min(viewport - margin, Math.max(margin + card.offsetWidth, rightEdge));
+    bubble.style.right = `${Math.round(viewport - rightEdge)}px`;
+    const tail = Math.min(Math.max(12, rightEdge - buttonCenter - tailHalf), Math.max(12, card.offsetWidth - 18));
+    card.style.setProperty("--tail", `${Math.round(tail)}px`);
+  }
+  closeConfirm() {
+    const bubble = this.shadow?.querySelector("[data-confirm]");
+    if (bubble instanceof HTMLElement) bubble.hidden = true;
+    this.paintPrivacy();
+  }
+  async run(task) {
+    if (this.busy) return;
+    this.busy = true;
+    this.failure = "";
+    this.render();
+    try {
+      await task();
+    } catch {
+      this.failure = "N\xE3o foi poss\xEDvel concluir";
+    } finally {
+      this.busy = false;
+      this.render();
+    }
+  }
+  render() {
+    this.place();
+    const { status, pending } = this.sdk.getState();
+    const shell = this.shadow?.querySelector("[data-shell]");
+    shell?.setAttribute("data-open", this.expanded ? "true" : "false");
+    shell?.setAttribute("data-state", status);
+    if (this.note) this.note.textContent = this.failure;
+    const live = status === "recording" || status === "paused";
+    const canFinish = live || status === "stopped" && pending > 0;
+    if (!live) this.closeConfirm();
+    this.paintPrivacy();
+    this.setHidden("record", live || status === "initializing" || status === "stopping");
+    this.setHidden("pause", status !== "recording");
+    this.setHidden("resume", status !== "paused");
+    this.setHidden("new", !live);
+    this.setHidden("stop", !canFinish);
+    this.setEnabled("record", !this.busy && !live && status !== "initializing" && status !== "stopping");
+    this.setEnabled("pause", !this.busy && status === "recording");
+    this.setEnabled("resume", !this.busy && status === "paused");
+    this.setEnabled("stop", !this.busy && canFinish);
+    this.setEnabled("new", !this.busy && live);
+  }
+  paintPrivacy() {
+    const flag = this.sdk.capturesSensitiveValues();
+    const confirm = this.shadow?.querySelector("[data-confirm]");
+    const confirmOpen = confirm instanceof HTMLElement && !confirm.hidden;
+    const bubble = this.shadow?.querySelector("[data-privacy]");
+    const show = flag && this.privacyOpen && this.expanded && !confirmOpen;
+    if (bubble instanceof HTMLElement) {
+      bubble.hidden = !show;
+      if (!show) this.clearPrivacyPlace(bubble);
+    }
+    if (show) this.schedulePlacePrivacy();
+    this.setHidden("privacy-show", !flag || this.privacyOpen || !this.expanded);
+  }
+  schedulePlacePrivacy() {
+    this.placePrivacy();
+    window.cancelAnimationFrame(this.placeFrame);
+    this.placeFrame = window.requestAnimationFrame(() => {
+      this.placePrivacy();
+      this.placeFrame = window.requestAnimationFrame(() => {
+        this.placeFrame = 0;
+        this.placePrivacy();
+      });
+    });
+  }
+  clearPrivacyPlace(wrap) {
+    wrap.style.position = "";
+    wrap.style.transform = "";
+    wrap.style.width = "";
+    wrap.style.maxWidth = "";
+    wrap.style.left = "";
+    wrap.style.right = "";
+    wrap.style.top = "";
+    wrap.style.bottom = "";
+  }
+  placePrivacy() {
+    const wrap = this.shadow?.querySelector("[data-privacy]");
+    const card = wrap?.querySelector(".bubble");
+    const face = this.shadow?.querySelector(".face");
+    if (!(wrap instanceof HTMLElement) || !(card instanceof HTMLElement) || !(face instanceof HTMLElement) || wrap.hidden) return;
+    const box = face.getBoundingClientRect();
+    if (box.width < 8 || box.height < 8 || box.top < 1 && box.left < 1) return;
+    const margin = 12;
+    const viewport = document.documentElement.clientWidth;
+    const maxWidth = Math.min(264, viewport - margin * 2);
+    wrap.style.position = "fixed";
+    wrap.style.transform = "none";
+    wrap.style.width = `${maxWidth}px`;
+    wrap.style.maxWidth = `${maxWidth}px`;
+    wrap.style.left = "auto";
+    wrap.style.bottom = "auto";
+    const faceCenter = box.left + box.width / 2;
+    const tailHalf = 5;
+    let rightEdge = faceCenter + 12 + tailHalf;
+    rightEdge = Math.min(viewport - margin, Math.max(margin + maxWidth, rightEdge));
+    wrap.style.right = `${Math.round(viewport - rightEdge)}px`;
+    wrap.style.top = `${Math.round(Math.max(margin, box.top - 10 - wrap.offsetHeight))}px`;
+    const tail = Math.min(Math.max(12, rightEdge - faceCenter - tailHalf), Math.max(12, maxWidth - 18));
+    card.style.setProperty("--tail", `${Math.round(tail)}px`);
+  }
+  setEnabled(action, enabled) {
+    const button = this.shadow?.querySelector(`[data-action='${action}']`);
+    if (button instanceof HTMLButtonElement) button.disabled = !enabled;
+  }
+  setHidden(action, hidden) {
+    const button = this.shadow?.querySelector(`[data-action='${action}']`);
+    if (button instanceof HTMLButtonElement) button.hidden = hidden;
+  }
+  startEyes() {
+    const media = window.matchMedia?.("(prefers-reduced-motion: reduce)");
+    if (!media || media.matches) return;
+    document.addEventListener("visibilitychange", this.onVisibility);
+    this.scheduleEye();
+  }
+  scheduleEye() {
+    const beat = EYE_SEQUENCE[this.eyeIndex % EYE_SEQUENCE.length];
+    this.applyPose(beat.pose);
+    this.eyeIndex = (this.eyeIndex + 1) % EYE_SEQUENCE.length;
+    this.eyeTimer = window.setTimeout(() => this.scheduleEye(), beat.duration);
+  }
+  applyPose(pose) {
+    const [left, right] = EYE_PATHS[pose] ?? EYE_PATHS.open;
+    this.shadow?.querySelectorAll("[data-eye='left']").forEach((node) => node.setAttribute("d", left));
+    this.shadow?.querySelectorAll("[data-eye='right']").forEach((node) => node.setAttribute("d", right));
+    this.shadow?.querySelectorAll("[data-eyes]").forEach((node) => node.setAttribute("data-pose", pose));
+  }
+};
+var ICON = {
+  pause: `<svg viewBox="0 0 16 16" aria-hidden="true"><path d="M5 3.5v9M11 3.5v9"/></svg>`,
+  play: `<svg viewBox="0 0 16 16" aria-hidden="true"><path d="M6 3.8 12.2 8 6 12.2z" fill="currentColor" stroke="none"/></svg>`,
+  close: `<svg viewBox="0 0 16 16" aria-hidden="true"><path d="M4 4l8 8M12 4 4 12"/></svg>`,
+  speak: `<svg viewBox="0 0 16 16" aria-hidden="true"><path d="M3.5 3.5h9a1.5 1.5 0 0 1 1.5 1.5v5a1.5 1.5 0 0 1-1.5 1.5H7.2L4.5 13.5v-2H3.5A1.5 1.5 0 0 1 2 10V5a1.5 1.5 0 0 1 1.5-1.5Z"/></svg>`
+};
+function mark(gradientId) {
+  return `<svg class="mark" viewBox="14 9 138 126" fill="none" aria-hidden="true">
+    <defs>
+      <linearGradient id="${gradientId}" x1="112" y1="41" x2="143" y2="17" gradientUnits="userSpaceOnUse">
+        <stop offset="0" stop-color="#753eff"></stop>
+        <stop offset="1" stop-color="#1772ff"></stop>
+      </linearGradient>
+    </defs>
+    <path d="M72 23C88 23 101 26 109 32L112 40C122 50 128 64 128 80C128 109 104 131 72 131C41 131 16 108 16 80C16 46 40 23 72 23Z" fill="#eeeef7"></path>
+    <path d="M112 41C119 37 123 27 131 22C135 19 139 18 143 17" stroke="url(#${gradientId})" stroke-width="8" stroke-linecap="round"></path>
+    <g class="eyes" data-eyes data-pose="open" stroke="#10182e" stroke-width="7" stroke-linecap="round">
+      <path data-eye="left" d="M59.5 79.5v15"></path>
+      <path data-eye="right" d="M93 79.5v15"></path>
+    </g>
+  </svg>`;
+}
+var TEMPLATE = `
+<style>
+  :host { color-scheme: dark; }
+  button {
+    display: grid;
+    place-items: center;
+    width: 32px;
+    height: 32px;
+    margin: 0;
+    padding: 0;
+    border: 1px solid #3a4458;
+    border-radius: 999px;
+    background: transparent;
+    color: #f4f3fc;
+    cursor: pointer;
+  }
+  button svg {
+    width: 15px;
+    height: 15px;
+    fill: none;
+    stroke: currentColor;
+    stroke-width: 1.7;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+  }
+  button:hover:not(:disabled) { border-color: #a596ff; color: #d0c8ff; }
+  button:focus-visible { outline: 2px solid #a596ff; outline-offset: 2px; }
+  button:disabled { cursor: not-allowed; opacity: 0.4; }
+  button[hidden] { display: none; }
+  button.text {
+    width: auto;
+    padding: 0 12px;
+    font: 600 12px/1 "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+  }
+  button.record {
+    border: 0;
+    background: linear-gradient(100deg, #6847ff, #1673ff);
+    color: #fff;
+  }
+  button.finish {
+    border: 0;
+    background: #e5485f;
+    color: #fff;
+  }
+  button.record:hover:not(:disabled),
+  button.finish:hover:not(:disabled) { color: #fff; filter: brightness(1.08); }
+  button.primary {
+    border: 0;
+    background: linear-gradient(100deg, #6847ff, #1673ff);
+    color: #fff;
+  }
+  button.primary:hover:not(:disabled) { color: #fff; filter: brightness(1.08); }
+  .launcher, .dock {
+    position: fixed;
+    right: 16px;
+    bottom: 16px;
+    z-index: 1;
+    border: 1px solid #232b3b;
+    background: #151b27;
+    box-shadow: 0 18px 40px rgba(3, 5, 12, 0.5);
+    pointer-events: auto;
+    font-family: "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+  }
+  .launcher {
+    width: 56px;
+    height: 56px;
+    padding: 8px;
+    border-radius: 999px;
+    cursor: pointer;
+  }
+  .launcher .mark { width: 100%; height: 100%; }
+  .launcher::after {
+    content: "";
+    position: absolute;
+    right: 1px;
+    bottom: 1px;
+    width: 10px;
+    height: 10px;
+    border-radius: 999px;
+    background: #929bb1;
+    box-shadow: 0 0 0 2px #151b27;
+  }
+  [data-state="recording"] .launcher::after { background: #1673ff; }
+  [data-state="paused"] .launcher::after { background: #d0c8ff; }
+  [data-state="error"] .launcher::after { background: #e5485f; }
+  .dock {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    max-width: calc(100vw - 32px);
+    padding: 6px 6px 6px 12px;
+    border-radius: 999px;
+    color: #f4f3fc;
+    overflow: visible;
+  }
+  [data-open="false"] .dock, [data-open="true"] .launcher { display: none; }
+  .brand { display: flex; align-items: center; gap: 8px; min-width: 0; overflow: visible; }
+  .face { position: relative; flex: none; width: 28px; height: 28px; overflow: visible; }
+  .dock .mark { width: 28px; height: 28px; }
+  .word {
+    color: #f4f3fc;
+    font-size: 14px;
+    font-weight: 600;
+    letter-spacing: -0.03em;
+    line-height: 1;
+  }
+  .actions { display: flex; align-items: center; gap: 6px; }
+  .note {
+    position: fixed;
+    right: 16px;
+    bottom: 78px;
+    z-index: 1;
+    margin: 0;
+    padding: 4px 10px;
+    border-radius: 999px;
+    background: #151b27;
+    color: #ff9aa8;
+    font: 600 11px/1.3 "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+    pointer-events: none;
+  }
+  .note:empty { display: none; }
+  [data-shell]:has(.note:not(:empty)) .privacy { bottom: calc(100% + 48px); }
+  .eyes {
+    transform-box: view-box;
+    transform-origin: 0 0;
+    transition: transform 280ms cubic-bezier(0.22, 1, 0.36, 1);
+  }
+  .eyes[data-pose="left"] { transform: translate(-4.5%, 0.8%); }
+  .eyes[data-pose="right"] { transform: translate(4.5%, 0.8%); }
+  .eyes[data-pose="up"] { transform: translate(0, -3.5%); }
+  @media (prefers-reduced-motion: reduce) {
+    .eyes { transition: none; }
+    .eyes[data-pose] { transform: none; }
+    .speak:not([hidden]) .bubble { animation: none; }
+  }
+  .speak {
+    position: fixed;
+    right: 16px;
+    bottom: 76px;
+    z-index: 2;
+    width: max-content;
+    max-width: min(16rem, calc(100vw - 32px));
+    pointer-events: auto;
+    font-family: "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+  }
+  .speak[hidden] { display: none; }
+  .bubble {
+    position: relative;
+    padding: 0.6rem 0.7rem 0.55rem;
+    border: 1px solid #3d3590;
+    border-radius: 1rem;
+    background: #1b1a3f;
+    color: #c7cadc;
+    box-shadow: 0 16px 40px rgba(3, 5, 12, 0.45);
+    animation: bubble-in 320ms cubic-bezier(0.22, 1, 0.36, 1);
+  }
+  .bubble::after {
+    content: "";
+    position: absolute;
+    right: var(--tail, 22px);
+    bottom: -5px;
+    width: 9px;
+    height: 9px;
+    border-right: 1px solid #3d3590;
+    border-bottom: 1px solid #3d3590;
+    background: #1b1a3f;
+    transform: rotate(45deg);
+  }
+  .bubble .mark {
+    display: block;
+    width: 22px;
+    height: 22px;
+    margin: 0 0 0.35rem;
+  }
+  @keyframes bubble-in {
+    from { opacity: 0; transform: translateY(8px) scale(0.96); }
+    to { opacity: 1; transform: none; }
+  }
+  .bubble p {
+    margin: 0;
+    color: #c7cadc;
+    font-size: 0.8125rem;
+    font-weight: 400;
+    line-height: 1.45;
+  }
+  .privacy {
+    position: absolute;
+    left: auto;
+    right: 50%;
+    bottom: calc(100% + 18px);
+    z-index: 3;
+    width: min(16.5rem, calc(100vw - 24px));
+    max-width: min(16.5rem, calc(100vw - 24px));
+    pointer-events: auto;
+    font-family: "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+    transform: translateX(20px);
+  }
+  .privacy[hidden] { display: none; }
+  .privacy .bubble {
+    padding: 0.75rem 2.15rem 0.75rem 0.9rem;
+    border-radius: 16px;
+  }
+  .privacy .bubble::after {
+    right: var(--tail, 12px);
+    bottom: -5px;
+    width: 10px;
+    height: 10px;
+  }
+  @media (max-width: 560px) {
+    .word { display: none; }
+    .privacy {
+      position: fixed;
+      left: 12px;
+      right: 12px;
+      bottom: 76px;
+      width: auto;
+      max-width: none;
+      transform: none;
+    }
+    .privacy .bubble {
+      padding: 0.65rem 1.85rem 0.6rem 0.75rem;
+    }
+    .privacy .bubble p { font-size: 0.75rem; }
+  }
+  .privacy button.hide {
+    position: absolute;
+    top: 0.4rem;
+    right: 0.4rem;
+    width: 24px;
+    height: 24px;
+    border: 0;
+    background: transparent;
+    color: #c7cadc;
+  }
+  .privacy button.hide:hover:not(:disabled) { color: #f4f3fc; }
+  .choices { display: flex; gap: 6px; margin-top: 0.7rem; }
+  .speak button.choice {
+    width: auto;
+    height: auto;
+    min-height: 1.75rem;
+    padding: 0 0.7rem;
+    border-radius: 999px;
+    font: 600 0.75rem/1 "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+  }
+  .speak button.secondary {
+    border: 1px solid #3a4458;
+    background: transparent;
+    color: #f4f3fc;
+  }
+  .speak button.secondary:hover:not(:disabled) { border-color: #a596ff; color: #d0c8ff; }
+  .speak button.danger {
+    border: 0;
+    background: #e5485f;
+    color: #fff;
+  }
+  .speak button.danger:hover:not(:disabled) { color: #fff; background: color-mix(in srgb, #e5485f 88%, #fff); }
+</style>
+<div data-shell data-open="true" data-state="recording">
+  <button type="button" class="launcher" data-action="open" aria-label="Abrir controles da grava\xE7\xE3o">
+    ${mark("offscript-trail-launcher")}
+  </button>
+  <div class="dock" role="toolbar" aria-label="Controles da grava\xE7\xE3o">
+    <div class="brand">
+      <span class="face">
+        ${mark("offscript-trail-dock")}
+        <div class="privacy" data-privacy hidden>
+          <div class="bubble" role="status">
+            <button type="button" class="hide" data-action="privacy-hide" aria-label="Fechar aviso">${ICON.close}</button>
+            <p>Tudo vis\xEDvel na tela ser\xE1 gravado, inclusive o que for digitado \u2014 senha e dado sens\xEDvel tamb\xE9m.</p>
+          </div>
+        </div>
+      </span>
+      <span class="word">Offscript</span>
+    </div>
+    <div class="actions">
+      <button type="button" data-action="privacy-show" aria-label="Abrir aviso" title="Tudo vis\xEDvel na tela ser\xE1 gravado, inclusive o que for digitado" hidden>${ICON.speak}</button>
+      <button type="button" class="text record" data-action="record">Iniciar</button>
+      <button type="button" data-action="pause" aria-label="Pausar" title="Pausar">${ICON.pause}</button>
+      <button type="button" data-action="resume" aria-label="Retomar" title="Retomar">${ICON.play}</button>
+      <button type="button" class="text" data-action="new" title="Descarta o que foi gravado e volta ao in\xEDcio">Nova grava\xE7\xE3o</button>
+      <button type="button" class="text finish" data-action="stop" title="Encerra a coleta e envia o que foi gravado">Finalizar</button>
+      <button type="button" data-action="close" aria-label="Fechar" title="Fechar">${ICON.close}</button>
+    </div>
+  </div>
+  <div class="speak" data-confirm hidden>
+    <div class="bubble" role="dialog" aria-labelledby="offscript-confirm-title">
+      ${mark("offscript-trail-speak")}
+      <p id="offscript-confirm-title">Descartar esta grava\xE7\xE3o? O que foi gravado ser\xE1 ignorado.</p>
+      <div class="choices">
+        <button type="button" class="choice secondary" data-action="cancel">Cancelar</button>
+        <button type="button" class="choice danger" data-action="confirm">Descartar</button>
+      </div>
+    </div>
+  </div>
+  <p class="note" data-note></p>
+</div>
+`;
+var SUCCESS_TEMPLATE = `
+<style>
+  :host { color-scheme: dark; }
+  .success {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 14px;
+    border: 1px solid #377c65;
+    border-radius: 16px;
+    background: #152c25;
+    color: #dcfce7;
+    box-shadow: 0 12px 32px rgba(3, 5, 12, 0.35);
+    font: 500 13px/1.5 "Plus Jakarta Sans", ui-sans-serif, system-ui, sans-serif;
+  }
+  p { margin: 0; }
+  button {
+    flex: none;
+    display: grid;
+    place-items: center;
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    border: 0;
+    border-radius: 999px;
+    background: transparent;
+    color: inherit;
+    font: 20px/1 ui-sans-serif, system-ui, sans-serif;
+    cursor: pointer;
+  }
+  button:hover { background: #244a3c; }
+  button:focus-visible { outline: 2px solid #86efac; outline-offset: 2px; }
+</style>
+<div class="success">
+  <p role="status">Grava\xE7\xE3o enviada com sucesso!</p>
+  <button type="button" aria-label="Fechar confirma\xE7\xE3o">\xD7</button>
+</div>
+`;
+
 // src/core/OffscriptSDK.ts
-var MAX_LOG = 5e3;
 var Offscript = class {
-  constructor(config) {
+  constructor(config = {}) {
     this.bus = new Emitter();
     this.status = "idle";
     this.recorders = [];
     this.accepting = false;
     this.destroyed = false;
+    this.suspended = false;
+    this.events = [];
     this.recent = [];
     this.actionLog = [];
     this.contextLog = [];
-    this.eventCount = 0;
-    this.metrics = { emitMs: 0, emitted: 0, dropped: 0 };
+    this.sequence = 0;
+    this.pageId = uid("page_");
+    this.submitted = false;
     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 };
+    return { status: this.status, pending: this.submitted ? 0 : this.events.length, lastError: this.lastError };
+  }
+  capturesSensitiveValues() {
+    return this.config.privacy.captureSensitiveValues;
+  }
+  async init() {
+    this.assertAlive();
+    if (typeof window === "undefined") throw new OffscriptError("NOT_SUPPORTED", "O SDK requer um navegador");
+    this.initPromise ?? (this.initPromise = this.initializeDraft());
+    await this.initPromise;
+    if (this.restorePromise) await this.restorePromise;
+    if (this.config.controls && !this.controls) {
+      this.controls = new RecordingControls(this);
+      this.controls.mount();
+    }
   }
-  /** 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 initializeDraft() {
+    if (!this.config.persistenceKey) return;
+    this.store = await RecordingStore.open(this.config.persistenceKey);
+    await this.restoreDraft();
   }
-  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);
+  async restoreDraft() {
+    const saved = await this.store.load();
+    if (this.suspended) return;
+    this.clearRecording();
+    if (!saved) {
       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;
+      return;
+    }
+    this.events = saved.events;
+    this.sequence = saved.events[saved.events.length - 1]?.sequence ?? 0;
+    this.actionLog = saved.events.filter((event) => event.kind === "action").map((event) => event.data);
+    this.contextLog = saved.events.filter((event) => event.kind === "context").map((event) => event.data);
+    this.setStatus(saved.status);
+    if (saved.status === "stopped") {
+      this.payload = this.buildPayload();
+      return;
     }
+    this.accepting = saved.status === "recording";
+    this.attach();
+    await this.startRecorders();
+    if (saved.status === "paused") this.recorders.forEach((recorder) => recorder.pause?.());
+  }
+  save(operation) {
+    void operation.catch((error) => {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.lastError = { code: "LOCAL_STORAGE_FAILED", message: err.message };
+      this.bus.emit("error", err);
+    });
   }
-  async startRecording(opts) {
-    if (this.destroyed) throw new InvalidStateError("SDK destru\xEDdo");
+  startRecording() {
     if (this.startPromise) return this.startPromise;
-    const p = this.doStart(opts).finally(() => this.startPromise = void 0);
-    this.startPromise = p;
-    return p;
+    this.startPromise = this.doStart().finally(() => {
+      this.startPromise = void 0;
+    });
+    return this.startPromise;
   }
-  async doStart(opts) {
+  async doStart() {
     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) {
+    if (this.status === "recording" || this.status === "paused") return;
+    if (this.completePromise || this.stopPromise) throw new InvalidStateError("Finaliza\xE7\xE3o em andamento");
+    await this.store?.clear();
+    this.clearRecording();
     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;
-    }
+    await this.store?.setStatus("recording");
+    this.accepting = true;
+    this.attach();
+    this.emitLifecycle("recording-start");
+    await this.startRecorders();
+    this.setStatus("recording");
+    await this.store?.flush();
+    this.bus.emit("recordingStart", void 0);
   }
   async pauseRecording() {
+    this.assertAlive();
+    if (this.restorePromise) await this.restorePromise;
     if (this.status === "paused") return;
-    if (this.status !== "recording") throw new InvalidStateError(`N\xE3o \xE9 poss\xEDvel pausar no estado ${this.status}`);
+    if (this.status !== "recording") throw new InvalidStateError("Sem grava\xE7\xE3o ativa");
     this.actions?.flushAll();
-    this.emitLifecycle("pause", {}, "critical");
+    this.emitLifecycle("pause");
     this.accepting = false;
     this.recorders.forEach((r) => safe(() => r.pause?.()));
-    this.sessions.setStatus("paused");
     this.setStatus("paused");
-    void this.transport?.flush();
+    await this.store?.flush();
   }
   async resumeRecording() {
+    this.assertAlive();
+    if (this.restorePromise) await this.restorePromise;
     if (this.status === "recording") return;
-    if (this.status !== "paused") throw new InvalidStateError(`N\xE3o \xE9 poss\xEDvel retomar no estado ${this.status}`);
+    if (this.status !== "paused") throw new InvalidStateError("Grava\xE7\xE3o n\xE3o est\xE1 pausada");
     this.accepting = true;
-    this.sessions.setStatus("recording");
+    this.emitLifecycle("resume");
+    for (const r of this.recorders) await r.resume?.();
     this.setStatus("recording");
-    this.emitLifecycle("resume", {}, "critical");
-    for (const r of this.recorders) await Promise.resolve(safe(() => r.resume?.()));
+    await this.store?.flush();
   }
   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);
+    this.stopPromise = this.doStop().finally(() => {
+      this.stopPromise = void 0;
+    });
     return this.stopPromise;
   }
   async doStop() {
-    const session = this.sessions.session;
+    this.assertAlive();
+    if (this.restorePromise) await this.restorePromise;
+    if (this.startPromise) await this.startPromise;
+    if (this.payload) return this.payload;
+    if (this.status !== "recording" && this.status !== "paused") throw new InvalidStateError("Sem grava\xE7\xE3o ativa");
     this.setStatus("stopping");
-    if (this.status === "stopping") {
-      this.actions?.flushAll();
-      this.emitLifecycle("stop", { eventCount: this.eventCount }, "critical");
+    this.actions?.flushAll();
+    this.emitLifecycle("stop");
+    const recorders = this.recorders.splice(0).reverse();
+    this.lifecycle?.uninstall();
+    for (const recorder of recorders) {
+      if (!(recorder instanceof HTTPRecorder)) safe(() => recorder.stop());
+    }
+    for (const recorder of recorders) {
+      if (recorder instanceof HTTPRecorder) await recorder.drain();
     }
     this.accepting = false;
-    this.stopRecorders();
-    this.sessions.stopHeartbeat();
-    const { ok, pending } = await this.transport?.flushFinal() ?? { ok: true, pending: 0 };
-    let completed = false;
-    if (ok) {
+    this.rrweb = this.actions = this.context = void 0;
+    this.payload = this.buildPayload();
+    this.setStatus("stopped");
+    await this.store?.flush();
+    this.bus.emit("recordingEnd", this.payload);
+    return this.payload;
+  }
+  complete(options) {
+    this.assertAlive();
+    if (this.completePromise) return this.completePromise;
+    if (this.submitted) return Promise.resolve(this.response);
+    this.completePromise = this.doComplete(options).finally(() => {
+      this.completePromise = void 0;
+    });
+    return this.completePromise;
+  }
+  async doComplete({ endpoint, token }) {
+    const url = new URL(endpoint, location.href);
+    if (!["https:", "http:"].includes(url.protocol)) throw new ConfigError("Endpoint HTTP inv\xE1lido");
+    if (!token?.trim()) throw new ConfigError("Token obrigat\xF3rio para envio");
+    const payload = await this.stopRecording();
+    try {
+      const response = await fetch(url.href, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json", Authorization: `Bearer ${token.trim()}` },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) throw new OffscriptError("TRANSPORT_FAILED", `Falha ao enviar grava\xE7\xE3o: HTTP ${response.status}`, { status: response.status });
+      this.submitted = true;
+      await this.store?.clear();
+      const text = await response.text();
       try {
-        completed = await this.sessions.complete({ eventCount: this.eventCount, pages: this.sessions.pageCount });
-      } catch (e) {
-        this.bus.emit("error", e);
+        this.response = text ? JSON.parse(text) : null;
+      } catch {
+        this.response = text;
       }
+      this.lastError = void 0;
+      this.controls?.showSuccess();
+      return this.response;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.lastError = { code: err instanceof OffscriptError ? err.code : "INTERNAL", message: err.message };
+      this.bus.emit("error", err);
+      throw err;
     }
-    if (ok) await this.transport?.clearSession(session.sessionId);
-    this.transport?.stop();
+  }
+  async finishRecording() {
+    if (this.config.onComplete) return this.config.onComplete();
+    return this.stopRecording();
+  }
+  async discardRecording() {
+    this.assertAlive();
+    if (this.restorePromise) await this.restorePromise;
+    if (this.startPromise) await this.startPromise;
+    if (this.stopPromise) await this.stopPromise;
+    if (this.completePromise) throw new InvalidStateError("Envio em andamento");
+    this.accepting = false;
+    this.stopRecorders();
     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 = {}) {
+    await this.store?.clear();
+    this.clearRecording();
+    this.setStatus("idle");
+  }
+  async destroy() {
     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();
+    if (this.restorePromise) await this.restorePromise;
+    if (this.startPromise) await this.startPromise;
+    if (this.completePromise) await this.completePromise.catch(() => void 0);
+    if (this.stopPromise) await this.stopPromise;
+    this.accepting = false;
+    this.stopRecorders();
+    this.lifecycle?.uninstall();
+    this.controls?.unmount();
+    await this.store?.close();
     this.bus.clear();
+    this.clearRecording();
+    this.destroyed = true;
   }
-  /** 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 buildPlaywrightContract({
-      session: { sessionId: s.sessionId, executionId: s.executionId, testCaseId: s.testCaseId, platformId: s.platformId },
-      actions: this.actionLog,
-      contexts: this.contextLog.map((e) => e.data)
-    });
+    return buildPlaywrightContract({ actions: this.actionLog, contexts: this.contextLog });
   }
   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;
+    if (!this.accepting) return null;
+    this.rrweb?.recoverIfNeeded();
+    const sequence = ++this.sequence;
+    const timestamp = opts.at ?? Date.now();
+    const id = `${this.pageId}:${sequence}`;
+    let payload = data;
+    if (kind === "action") {
+      const action = { ...data, id, sequence, timestamp };
+      payload = action;
+      this.actionLog.push(action);
+      this.recent.push({ id, t: timestamp });
+      if (this.recent.length > 50) this.recent.shift();
     }
+    const related = ["http", "console", "error", "iframe"].includes(kind) ? this.correlate(timestamp) : void 0;
+    const event = {
+      id,
+      kind,
+      tabId: this.pageId,
+      pageId: this.pageId,
+      sequence,
+      timestamp,
+      relatedActionId: related?.id,
+      relatedActionDeltaMs: related ? timestamp - related.t : void 0,
+      data: payload
+    };
+    if (kind === "context") this.contextLog.push(data);
+    this.events.push(event);
+    if (this.store) this.save(this.store.append(event));
+    return event;
   }
   correlate(at) {
     for (let i = this.recent.length - 1; i >= 0; i--) {
@@ -2555,18 +2487,27 @@ var Offscript = class {
   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();
+        if (!this.store) return;
+        this.accepting = false;
+        this.stopRecorders();
+        this.suspended = true;
+        if (!this.restorePromise) this.store.checkpoint();
+      },
+      onPageShow: () => {
+        if (!this.suspended) return;
+        this.suspended = false;
+        this.setStatus("initializing");
+        this.restorePromise = this.restoreDraft().finally(() => {
+          this.restorePromise = void 0;
+        });
+        this.save(this.restorePromise);
       },
       onVisibility: (hidden) => {
-        if (hidden && this.accepting) {
-          this.actions?.flushAll();
-          void this.transport?.flush();
-        }
+        if (hidden) this.actions?.flushAll();
+      },
+      onConnectivity: () => {
       },
-      onConnectivity: (online) => this.transport?.setOnline(online),
       onNavigation: ({ from, to, kind }) => {
         if (!this.accepting) return;
         this.actions?.recordNavigation(from, to, kind);
@@ -2575,15 +2516,14 @@ var Offscript = class {
       }
     }));
     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.context) list.push(this.context = new ContextRecorder(this));
     if (r.actions) list.push(this.actions = new ActionRecorder(this));
-    if (r.http) list.push(new HTTPRecorder(this, this.config.apiUrl));
+    if (r.http) list.push(new HTTPRecorder(this));
     if (r.console || r.errors) list.push(new ErrorRecorder(this));
     if (r.iframes) list.push(new IframeRecorder(this));
     this.recorders = list;
@@ -2596,63 +2536,42 @@ var Offscript = class {
       }
     }
   }
+  buildPayload() {
+    return {
+      recording: this.events.filter((event) => event.kind !== "http"),
+      request: this.events.filter((event) => event.kind === "http"),
+      regression: this.exportPlaywrightData()
+    };
+  }
   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);
+  clearRecording() {
+    this.events = [];
+    this.actionLog = [];
+    this.contextLog = [];
+    this.recent = [];
+    this.sequence = 0;
+    this.pageId = uid("page_");
+    this.payload = void 0;
+    this.submitted = false;
+    this.response = void 0;
+    this.lastError = void 0;
+  }
+  assertAlive() {
+    if (this.destroyed) throw new InvalidStateError("SDK destru\xEDdo");
   }
   setStatus(to) {
     const from = this.status;
     if (from === to) return;
     this.status = to;
+    if (this.store && (to === "recording" || to === "paused" || to === "stopped")) this.save(this.store.setStatus(to));
     this.bus.emit("statusChange", { from, to });
   }
-  debug(...args) {
-    if (this.config.debug) console.debug("[offscript]", ...args);
-  }
 };
 Offscript.version = SDK_VERSION;
 
-export { AuthError, ConfigError, DEFAULT_PRIVACY, DEFAULT_RECORDING, DEFAULT_TRANSPORT, DataSanitizer, InvalidStateError, Offscript, OffscriptError, SessionDisabledError, SessionExpiredError, TransportError };
-//# sourceMappingURL=chunk-3OSCH7J2.js.map
-//# sourceMappingURL=chunk-3OSCH7J2.js.map
+export { ConfigError, DEFAULT_PRIVACY, DEFAULT_RECORDING, DataSanitizer, InvalidStateError, Offscript, OffscriptError };
+//# sourceMappingURL=chunk-XBXFGCUT.js.map
+//# sourceMappingURL=chunk-XBXFGCUT.js.map