@offscript/sdk 0.1.2 → 0.1.5

package/dist/{chunk-IBEPWI7S.js → chunk-XBXFGCUT.js}

@@ -1,4 +1,4 @@
-import { buildPlaywrightContract, SDK_VERSION, SCHEMA_VERSION, SelectorGenerator, ACTION_SCHEMA_VERSION } from './chunk-WUFW7TEL.js';
+import { buildPlaywrightContract, SDK_VERSION, SelectorGenerator, ACTION_SCHEMA_VERSION } from './chunk-6ROP37WI.js';
 
 // src/types/config.ts
 var DEFAULT_RECORDING = {
@@ -32,22 +32,7 @@ var DEFAULT_PRIVACY = {
   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
@@ -86,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;
@@ -307,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();
@@ -364,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 {
@@ -1278,7 +646,7 @@ function parseBrowser(ua) {
   }
   return {};
 }
-function collectContext(id, reason, appVersion, captureSensitiveValues = false) {
+function collectContext(reason, captureSensitiveValues = false) {
   const nav = navigator;
   const ua = nav.userAgent ?? "";
   let browser = parseBrowser(ua);
@@ -1302,18 +670,13 @@ function collectContext(id, reason, appVersion, captureSensitiveValues = false)
     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();
   }
@@ -1326,7 +689,7 @@ var ContextRecorder = class {
   }
   record(reason) {
     guard(this.sink, this.name, () => {
-      const data = collectContext(this.identity(), reason, this.sink.config.appVersion, this.sink.config.privacy.captureSensitiveValues);
+      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" });
@@ -1485,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 {
@@ -1510,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
@@ -1537,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;
@@ -1592,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) {
@@ -1609,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) {
@@ -1667,7 +1056,6 @@ var HTTPRecorder = class {
       }
       return origSend.call(this, body);
     };
-    open[XHR_PATCHED] = origOpen;
     proto.open = open;
     proto.setRequestHeader = setHeader;
     proto.send = send;
@@ -1689,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) {
@@ -1735,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) {
@@ -1984,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)));
@@ -2025,282 +1420,119 @@ 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;
-  }
-  hasTokenAvailable() {
-    return Boolean(this.token || readQueryToken());
-  }
-  // ---- 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) {
-    const queryToken = consumeQueryToken();
-    const sessionToken = opts?.sessionToken || this.token || queryToken;
-    if (!sessionToken || !opts.executionId || !opts.testCaseId)
-      throw new AuthError("sessionToken, executionId e testCaseId s\xE3o obrigat\xF3rios");
-    this.token = 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
-    });
-    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
+    this.status = status;
+    return this.write(["state"], (transaction) => {
+      transaction.objectStore("state").put(status, "status");
     });
-    return res;
-  }
-  /** Reidrata sessão persistida (reload/navegação MPA) após validar no backend. */
-  async resume(state) {
-    this.token = state.sessionToken;
-    const tabId = await resolveTabId(this.cfg.storagePrefix, state.tabId);
-    const res = await this.api.status(state.sessionId);
-    if (res.status === "expired") throw new SessionExpiredError();
-    if (res.status === "disabled") throw new SessionDisabledError();
-    if (res.sessionToken) this.token = res.sessionToken;
-    this.state = { ...state, tabId };
-    this.seq = tabId === state.tabId ? state.sequence : 0;
-    this.info = {
-      sessionId: state.sessionId,
-      executionId: state.executionId,
-      testCaseId: state.testCaseId,
-      platformId: state.platformId,
-      tabId,
-      pageId: uid("pg_"),
-      startedAt: Date.now()
-    };
-    this.persist(state.status, { sessionToken: this.token, expiresAt: res.expiresAt ?? state.expiresAt, pageCount: state.pageCount + 1, tabId });
-    return res;
-  }
-  startHeartbeat(onResult, onError, pending, status) {
-    this.stopHeartbeat();
-    const every = this.state?.heartbeatIntervalMs ?? this.cfg.heartbeatIntervalMs;
-    if (!every || every <= 0) return;
-    this.heartbeatTimer = setInterval(async () => {
-      if (!this.info) return;
-      try {
-        const r = await this.api.heartbeat(this.info.sessionId, {
-          tabId: this.info.tabId,
-          pageId: this.info.pageId,
-          status: status(),
-          pending: pending(),
-          lastSequence: this.seq
-        });
-        if (r.sessionToken) {
-          this.token = r.sessionToken;
-          this.persist(this.state?.status ?? "recording", { sessionToken: r.sessionToken, expiresAt: r.expiresAt });
-        }
-        onResult(r);
-      } catch (e) {
-        if (e instanceof AuthError || e instanceof SessionExpiredError) onError(e);
-      }
-    }, every);
   }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-    this.heartbeatTimer = void 0;
+  async clear() {
+    await this.write(["events", "state"], (transaction) => {
+      transaction.objectStore("events").clear();
+      transaction.objectStore("state").clear();
+    });
+    this.failure = void 0;
+    this.status = void 0;
+    this.uncommitted.clear();
+    sessionStorage.removeItem(this.checkpointKey);
   }
-  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;
+  /** 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()] }));
   }
-  reset() {
-    this.stopHeartbeat();
-    this.info = null;
-    this.state = null;
-    this.token = "";
-    this.seq = 0;
+  get checkpointKey() {
+    return `${this.database.name}-handoff`;
   }
-};
-function consumeQueryToken() {
-  if (typeof window === "undefined") return "";
-  try {
-    const token = readQueryToken();
-    if (!token) return "";
-    const url = new URL(window.location.href);
-    url.searchParams.delete("offscript_token");
-    window.history.replaceState(window.history.state, typeof document === "undefined" ? "" : document.title, `${url.pathname}${url.search}${url.hash}`);
-    return token;
-  } catch {
-    return "";
-  }
-}
-function readQueryToken() {
-  if (typeof window === "undefined") return "";
-  try {
-    return new URL(window.location.href).searchParams.get("offscript_token")?.trim() ?? "";
-  } catch {
-    return "";
+  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
+    controls: input.controls ?? true,
+    persistenceKey: input.persistenceKey,
+    onComplete: input.onComplete
   };
 }
 
@@ -2369,6 +1601,22 @@ var RecordingControls = class {
     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;
@@ -2420,15 +1668,15 @@ var RecordingControls = class {
       } else if (action === "close") {
         this.expanded = false;
         this.render();
-      } else if (action === "record") void this.run(() => this.sdk.startArmedRecording());
+      } 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.stopRecording());
+      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.startNewSession());
+        void this.run(() => this.sdk.discardRecording());
       } else if (action === "privacy-show") {
         this.privacyOpen = true;
         this.render();
@@ -2496,23 +1744,24 @@ var RecordingControls = class {
   }
   render() {
     this.place();
-    const status = this.sdk.getState().status;
+    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", !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 && live);
+    this.setEnabled("stop", !this.busy && canFinish);
     this.setEnabled("new", !this.busy && live);
   }
   paintPrivacy() {
@@ -2902,7 +2151,7 @@ var TEMPLATE = `
       <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 sess\xE3o</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>
@@ -2910,7 +2159,7 @@ var TEMPLATE = `
   <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 sess\xE3o? O que foi gravado ser\xE1 ignorado.</p>
+      <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>
@@ -2920,325 +2169,309 @@ var TEMPLATE = `
   <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 };
+    return { status: this.status, pending: this.submitted ? 0 : this.events.length, lastError: this.lastError };
   }
   capturesSensitiveValues() {
-    return this.config.privacy.captureSensitiveValues === true;
-  }
-  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 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.ensureControls();
-    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.lastStart = { testCaseId: opts.testCaseId, executionId: opts.executionId, sessionToken: opts.sessionToken };
+    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 {
-      const ctx = collectContext({ platformId: this.config.platformId, testCaseId: opts.testCaseId, executionId: opts.executionId }, "initial", this.config.appVersion, this.config.privacy.captureSensitiveValues);
-      await this.sessions.create(opts, { ...ctx, url: this.sanitizer.sanitizeUrl(ctx.url), referrer: void 0, title: void 0 });
-      const s = this.sessions.session;
-      await this.transport.start({ sessionId: s.sessionId, executionId: s.executionId, tabId: s.tabId });
-      this.attach();
-      this.accepting = true;
-      this.setStatus("recording");
-      this.emitLifecycle("session-start", { pageCount: 1 }, "critical");
-      await this.startRecorders();
-      this.sessions.startHeartbeat((r) => this.onHeartbeat(r.status), (e) => void this.onFatal(e), () => this.transport?.pending ?? 0, () => this.status);
-      this.bus.emit("sessionStart", s);
-      return s;
-    } catch (e) {
-      await this.teardown();
-      this.sessions.clearPersisted();
-      this.sessions.reset();
-      this.fail(e);
-      throw e;
-    }
-  }
-  async resumePersisted(state) {
-    this.setStatus("initializing");
-    try {
-      await this.sessions.resume(state);
-      const s = this.sessions.session;
-      await this.transport.start({ sessionId: s.sessionId, executionId: s.executionId, tabId: s.tabId });
-      this.attach();
-      this.accepting = state.status === "recording";
-      this.setStatus(state.status);
-      this.emitLifecycle("session-resume", { pageCount: this.sessions.pageCount }, "critical");
-      this.emitLifecycle("page-start", { navigationType: safe(() => performance.getEntriesByType("navigation")[0]?.type) }, "critical");
-      await this.startRecorders();
-      if (state.status === "paused") this.recorders.forEach((r) => r.pause?.());
-      this.actions?.recordPageLoad(safe(() => performance.getEntriesByType("navigation")[0]?.type), document.referrer);
-      this.sessions.startHeartbeat((r) => this.onHeartbeat(r.status), (e) => void this.onFatal(e), () => this.transport?.pending ?? 0, () => this.status);
-      const token = this.sessions.currentToken;
-      if (token) {
-        this.lastStart = { testCaseId: s.testCaseId, executionId: s.executionId, sessionToken: token };
-        this.armed ?? (this.armed = { testCaseId: s.testCaseId, sessionToken: token });
-      }
-      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;
-    }
-  }
-  /** Guarda caso de teste e token para o botão de gravar, sem abrir a sessão. */
-  armRecording(opts) {
-    this.armed = { testCaseId: opts.testCaseId, sessionToken: opts.sessionToken };
-  }
-  /** Abre a coleta com os dados armados, ou com os da última sessão. */
-  startArmedRecording() {
-    if ((this.status === "recording" || this.status === "paused") && this.sessions.session) return Promise.resolve(this.sessions.session);
-    return this.startRecording(this.freshStart());
-  }
-  /** Descarta a coleta atual e volta ao estado inicial, sem abrir outra. */
-  async startNewSession() {
-    if (this.status !== "recording" && this.status !== "paused") return;
-    await this.discardRecording();
-  }
-  freshStart() {
-    const base = this.armed ?? (this.lastStart ? { testCaseId: this.lastStart.testCaseId, sessionToken: this.lastStart.sessionToken } : void 0);
-    if (!base?.testCaseId || !base.sessionToken) throw new InvalidStateError("N\xE3o h\xE1 dados para iniciar a grava\xE7\xE3o");
-    return { testCaseId: base.testCaseId, sessionToken: base.sessionToken, executionId: uid("exec_") };
-  }
-  async discardRecording() {
-    const sessionId = this.sessions.session?.sessionId ?? "";
-    this.accepting = false;
-    this.stopRecorders();
-    this.sessions.stopHeartbeat();
-    this.transport?.stop();
-    if (sessionId) await this.transport?.clearSession(sessionId);
-    this.lifecycle?.uninstall();
-    this.sessions.clearPersisted();
-    this.sessions.reset();
-    this.setStatus("idle");
-    if (sessionId) this.bus.emit("sessionDiscard", { sessionId });
+    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();
+    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();
-    this.controls = void 0;
-    this.sessions.reset();
-    this.transport?.close();
+    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--) {
@@ -3254,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);
@@ -3274,16 +2516,14 @@ var Offscript = class {
       }
     }));
     this.lifecycle.install();
-    this.transport?.setOnline(typeof navigator === "undefined" ? true : navigator.onLine !== false);
   }
   async startRecorders() {
-    this.ensureControls();
     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;
@@ -3296,70 +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;
   }
-  ensureControls() {
-    if (!this.config.controls || typeof document === "undefined" || !this.sessions.hasTokenAvailable()) return;
-    safe(() => {
-      this.controls ?? (this.controls = new RecordingControls(this));
-      this.controls.mount();
-    });
-  }
-  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-IBEPWI7S.js.map
-//# sourceMappingURL=chunk-IBEPWI7S.js.map
+export { ConfigError, DEFAULT_PRIVACY, DEFAULT_RECORDING, DataSanitizer, InvalidStateError, Offscript, OffscriptError };
+//# sourceMappingURL=chunk-XBXFGCUT.js.map
+//# sourceMappingURL=chunk-XBXFGCUT.js.map