@guidelytech/sdk-core 0.2.0 → 0.4.0

package/dist/recorder.cjs

@@ -0,0 +1,766 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/recorder.ts
+var recorder_exports = {};
+__export(recorder_exports, {
+  ReplayController: () => ReplayController,
+  recorder: () => recorder,
+  startRecorder: () => startRecorder
+});
+module.exports = __toCommonJS(recorder_exports);
+var import_record = require("@rrweb/record");
+var import_rrweb_plugin_console_record = require("@rrweb/rrweb-plugin-console-record");
+
+// src/network.ts
+var import_runtime = require("@guidelytech/shared/runtime");
+var MAX_BODY_CHARS = 10 * 1024;
+var MAX_REQUESTS_PER_PAGE = 500;
+var BATCH_SIZE = 20;
+var BATCH_MS = 1e3;
+var BODY_TIMEOUT_MS = 2e3;
+var REDACTED = "[redacted]";
+var requestCount = 0;
+var perfCutoff = 0;
+var now = () => Date.now();
+function redactUrl(raw, base = typeof location !== "undefined" ? location.href : "http://localhost/") {
+  try {
+    const u = new URL(raw, base);
+    u.searchParams.forEach((_v, k) => {
+      if (import_runtime.SENSITIVE_PARAM_PATTERN.test(k)) u.searchParams.set(k, REDACTED);
+    });
+    return u.toString().replace(/%5Bredacted%5D/g, REDACTED);
+  } catch {
+    return String(raw);
+  }
+}
+function maskJson(value, depth = 0) {
+  if (depth > 20 || !value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v) => maskJson(v, depth + 1));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = import_runtime.SENSITIVE_PARAM_PATTERN.test(k) ? REDACTED : maskJson(v, depth + 1);
+  return out;
+}
+function cap(text, max) {
+  return text.length > max ? `${text.slice(0, max)}[truncated]` : text;
+}
+function formatBody(body, contentType) {
+  if (body == null || body === "") return void 0;
+  const ct = (contentType || "").toLowerCase();
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return formatBody(body.toString(), "application/x-www-form-urlencoded");
+  if (typeof body !== "string") return "[binary]";
+  if (ct && !/^text\/|json|x-www-form-urlencoded/.test(ct)) return "[binary]";
+  if (ct.includes("x-www-form-urlencoded")) {
+    const params = new URLSearchParams(body);
+    params.forEach((_v, k) => {
+      if (import_runtime.SENSITIVE_PARAM_PATTERN.test(k)) params.set(k, REDACTED);
+    });
+    return cap(params.toString().replace(/%5Bredacted%5D/g, REDACTED), MAX_BODY_CHARS);
+  }
+  if (ct.includes("json") || !ct && /^\s*[[{]/.test(body)) {
+    try {
+      return cap(JSON.stringify(maskJson(JSON.parse(body))), MAX_BODY_CHARS);
+    } catch {
+    }
+  }
+  return cap(body, MAX_BODY_CHARS);
+}
+function formatHeaders(entries) {
+  const out = {};
+  for (const [k, v] of entries) {
+    const name = k.toLowerCase();
+    out[name] = import_runtime.SENSITIVE_HEADER_PATTERN.test(name) ? REDACTED : String(v);
+  }
+  return out;
+}
+function headerEntries(h) {
+  if (!h) return [];
+  if (Array.isArray(h)) return h.map(([k, v]) => [String(k), String(v)]);
+  if (typeof h.forEach === "function") {
+    const out = [];
+    h.forEach((v, k) => out.push([k, v]));
+    return out;
+  }
+  return Object.entries(h).map(([k, v]) => [k, String(v)]);
+}
+function byteSize(data) {
+  if (typeof data === "string") return typeof TextEncoder !== "undefined" ? new TextEncoder().encode(data).length : data.length;
+  if (data instanceof ArrayBuffer) return data.byteLength;
+  if (ArrayBuffer.isView(data)) return data.byteLength;
+  if (typeof Blob !== "undefined" && data instanceof Blob) return data.size;
+  return 0;
+}
+function frameData(data, size) {
+  if (typeof data !== "string") return `[binary ${size} B]`;
+  let text = data;
+  try {
+    if (/^\s*[[{]/.test(text)) text = JSON.stringify(maskJson(JSON.parse(text)));
+  } catch {
+  }
+  return cap(text, import_runtime.WS_MAX_MESSAGE_BYTES);
+}
+var RESOURCE_TYPES = { script: "script", link: "stylesheet", css: "stylesheet", img: "image", image: "image", audio: "media", video: "media", track: "media", beacon: "beacon", navigation: "document", iframe: "document", frame: "document" };
+function startNetworkCapture(win, opts, emit) {
+  let active = true;
+  const startedAt = now();
+  let requests = [];
+  let messages = [];
+  let droppedRequests = 0;
+  let droppedMessages = 0;
+  let timer = null;
+  const recent = [];
+  const cleanups = [];
+  let apiPrefix = "";
+  try {
+    if (opts.apiUrl) apiPrefix = `${new URL(opts.apiUrl).origin}/api/v1/sdk/`;
+  } catch {
+  }
+  const excluded = (url) => /^(data|blob|about|chrome-extension):/i.test(url) || !!apiPrefix && url.replace(/^ws(s?):/i, "http$1:").startsWith(apiPrefix) || /\/guidely-recorder(\.min)?\.js(\?|$)/.test(url);
+  const flush = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    if (!requests.length && !messages.length && !droppedRequests && !droppedMessages) return;
+    const payload = {};
+    if (requests.length) payload.requests = requests;
+    if (messages.length) payload.messages = messages;
+    if (droppedRequests || droppedMessages) payload.dropped = { ...droppedRequests ? { requests: droppedRequests } : {}, ...droppedMessages ? { messages: droppedMessages } : {} };
+    requests = [];
+    messages = [];
+    droppedRequests = 0;
+    droppedMessages = 0;
+    try {
+      emit(payload);
+    } catch {
+    }
+  };
+  const schedule = () => {
+    if (requests.length + messages.length >= BATCH_SIZE) flush();
+    else timer ?? (timer = setTimeout(flush, BATCH_MS));
+  };
+  const push = (req, counted = false) => {
+    if (!active) return false;
+    if (!counted) {
+      if (requestCount >= MAX_REQUESTS_PER_PAGE) {
+        droppedRequests += 1;
+        schedule();
+        return false;
+      }
+      requestCount += 1;
+    }
+    let out = req;
+    if (opts.mask) {
+      try {
+        out = opts.mask({ ...req });
+      } catch {
+        out = null;
+      }
+    }
+    if (!out) return false;
+    requests.push(out);
+    schedule();
+    return true;
+  };
+  const finish = (req, fields) => {
+    Object.assign(req, fields);
+    req.endTime = now();
+    req.durationMs = req.endTime - req.startTime;
+  };
+  const remember = (req) => {
+    recent.push(req);
+    if (recent.length > 100) recent.shift();
+  };
+  const origFetch = win.fetch;
+  if (typeof origFetch === "function") {
+    const patched = function(input, init) {
+      const p = origFetch.call(this === void 0 || this === patched ? win : this, input, init);
+      if (!active) return p;
+      try {
+        const isReq = typeof Request !== "undefined" && input instanceof Request;
+        const rawUrl = isReq ? input.url : String(input instanceof URL ? input.href : input);
+        const url = redactUrl(rawUrl);
+        if (excluded(url) || excluded(rawUrl)) return p;
+        const req = { id: (0, import_runtime.randomId)(12), type: "fetch", method: String(init?.method || (isReq ? input.method : "GET")).toUpperCase(), url, startTime: now() };
+        if (opts.payloads) {
+          const headers = headerEntries(init?.headers ?? (isReq ? input.headers : void 0));
+          req.requestHeaders = formatHeaders(headers);
+          const body = formatBody(init?.body, req.requestHeaders["content-type"] ?? (typeof init?.body === "string" ? "text/plain" : void 0));
+          if (body !== void 0) req.requestBody = body;
+        }
+        remember(req);
+        p.then(
+          (res) => {
+            try {
+              finish(req, { status: res.status });
+              if (!opts.payloads) return void push(req);
+              req.responseHeaders = formatHeaders(headerEntries(res.headers));
+              const ct = res.headers.get("content-type");
+              if (!ct || !/^text\/(?!event-stream)|json|x-www-form-urlencoded/i.test(ct) || !res.body) {
+                if (ct && res.body) req.responseBody = "[binary]";
+                return void push(req);
+              }
+              const reader = res.clone().body.getReader();
+              const decoder = new TextDecoder();
+              let text = "";
+              const done = () => {
+                req.responseBody = formatBody(text, ct);
+                push(req);
+              };
+              const t = setTimeout(() => void reader.cancel().catch(() => void 0), BODY_TIMEOUT_MS);
+              const read = () => reader.read().then(({ done: end, value }) => {
+                if (value) text += decoder.decode(value, { stream: true });
+                if (end) return;
+                if (text.length > MAX_BODY_CHARS * 4) return void reader.cancel().catch(() => void 0);
+                return read();
+              });
+              read().catch(() => void 0).then(() => {
+                clearTimeout(t);
+                done();
+              });
+            } catch {
+            }
+          },
+          (err) => {
+            try {
+              finish(req, { status: 0, error: err instanceof Error && err.name === "AbortError" ? "aborted" : String(err?.message || err) });
+              push(req);
+            } catch {
+            }
+          }
+        );
+      } catch {
+      }
+      return p;
+    };
+    win.fetch = patched;
+    cleanups.push(() => {
+      if (win.fetch === patched) win.fetch = origFetch;
+    });
+  }
+  const XHR = win.XMLHttpRequest;
+  if (XHR?.prototype) {
+    const proto = XHR.prototype;
+    const { open, send, setRequestHeader } = proto;
+    const state = /* @__PURE__ */ new WeakMap();
+    const pOpen = function(method, url, ...rest) {
+      try {
+        if (active) state.set(this, { method: String(method).toUpperCase(), url: String(url), headers: [] });
+      } catch {
+      }
+      return open.call(this, method, url, ...rest);
+    };
+    const pSetHeader = function(name, value) {
+      try {
+        state.get(this)?.headers.push([name, value]);
+      } catch {
+      }
+      return setRequestHeader.call(this, name, value);
+    };
+    const pSend = function(body) {
+      try {
+        const s = state.get(this);
+        const url = s ? redactUrl(s.url) : "";
+        if (active && s && !excluded(url) && !excluded(s.url)) {
+          const req = { id: (0, import_runtime.randomId)(12), type: "xhr", method: s.method, url, startTime: now() };
+          if (opts.payloads) {
+            req.requestHeaders = formatHeaders(s.headers);
+            const b = formatBody(body, req.requestHeaders["content-type"] ?? (typeof body === "string" ? "text/plain" : void 0));
+            if (b !== void 0) req.requestBody = b;
+          }
+          remember(req);
+          let ended = false;
+          const end = (error) => () => {
+            if (ended) return;
+            ended = true;
+            try {
+              finish(req, { status: error ? 0 : this.status, ...error ? { error } : {} });
+              if (opts.payloads && !error) {
+                const raw = this.getAllResponseHeaders() || "";
+                req.responseHeaders = formatHeaders(raw.trim().split(/[\r\n]+/).filter(Boolean).map((line) => [line.slice(0, line.indexOf(":")).trim(), line.slice(line.indexOf(":") + 1).trim()]));
+                const ct = this.getResponseHeader("content-type");
+                const type = this.responseType;
+                const text = type === "" || type === "text" ? this.responseText : type === "json" ? JSON.stringify(this.response) : null;
+                const formatted = text == null ? this.response ? "[binary]" : void 0 : formatBody(text, ct ?? (type === "json" ? "application/json" : "text/plain"));
+                if (formatted !== void 0) req.responseBody = formatted;
+              }
+              push(req);
+            } catch {
+            }
+          };
+          this.addEventListener("load", end());
+          this.addEventListener("error", end("network error"));
+          this.addEventListener("abort", end("aborted"));
+          this.addEventListener("timeout", end("timeout"));
+        }
+      } catch {
+      }
+      return send.call(this, body);
+    };
+    proto.open = pOpen;
+    proto.setRequestHeader = pSetHeader;
+    proto.send = pSend;
+    cleanups.push(() => {
+      if (proto.open === pOpen) proto.open = open;
+      if (proto.setRequestHeader === pSetHeader) proto.setRequestHeader = setRequestHeader;
+      if (proto.send === pSend) proto.send = send;
+    });
+  }
+  const WS = win.WebSocket;
+  if (typeof WS === "function") {
+    const track = (ws, rawUrl) => {
+      const url = redactUrl(rawUrl);
+      if (excluded(url)) return;
+      const req = { id: (0, import_runtime.randomId)(12), type: "websocket", method: "GET", url, startTime: now() };
+      const totals = { sent: 0, received: 0, sentBytes: 0, receivedBytes: 0, recorded: 0 };
+      let dropped = false;
+      let counted = false;
+      const emitConn = (fields) => {
+        if (dropped || !active) return;
+        Object.assign(req, fields, { messages: { ...totals } });
+        dropped = !push({ ...req }, counted);
+        counted = true;
+      };
+      const frame = (dir, data) => {
+        try {
+          const size = byteSize(data);
+          if (dir === "send") {
+            totals.sent += 1;
+            totals.sentBytes += size;
+          } else {
+            totals.received += 1;
+            totals.receivedBytes += size;
+          }
+          if (dropped || !active) return;
+          if (totals.recorded >= import_runtime.WS_MAX_MESSAGES_PER_SOCKET) {
+            droppedMessages += 1;
+            return schedule();
+          }
+          totals.recorded += 1;
+          const m = { socketId: req.id, dir, time: now(), size };
+          if (typeof data !== "string") m.binary = true;
+          if (opts.payloads) m.data = frameData(data, size);
+          messages.push(m);
+          schedule();
+        } catch {
+        }
+      };
+      const nativeSend = ws.send;
+      ws.send = function(data) {
+        const r = nativeSend.call(this, data);
+        frame("send", data);
+        return r;
+      };
+      ws.addEventListener("open", () => emitConn({ protocol: ws.protocol || void 0 }));
+      ws.addEventListener("message", (e) => frame("recv", e.data));
+      let errored = false;
+      ws.addEventListener("error", () => {
+        errored = true;
+      });
+      ws.addEventListener("close", (e) => {
+        const endTime = now();
+        emitConn({ endTime, durationMs: endTime - req.startTime, closeCode: e.code, closeReason: e.reason || void 0, ...errored || e.code === 1006 ? { error: "connection error" } : {} });
+      });
+    };
+    const Patched = class extends WS {
+      constructor(url, protocols) {
+        super(url, protocols);
+        try {
+          if (active) track(this, String(url instanceof URL ? url.href : url));
+        } catch {
+        }
+      }
+      static [Symbol.hasInstance](x) {
+        return x instanceof WS;
+      }
+    };
+    Object.defineProperty(Patched, "name", { value: WS.name });
+    win.WebSocket = Patched;
+    cleanups.push(() => {
+      if (win.WebSocket === Patched) win.WebSocket = WS;
+    });
+  }
+  const PO = win.PerformanceObserver;
+  if (typeof PO === "function") {
+    const origin = win.performance?.timeOrigin ?? startedAt - (win.performance?.now?.() ?? 0);
+    const cutoff = perfCutoff;
+    const seen = /* @__PURE__ */ new Set();
+    const onEntries = (list) => {
+      for (const e of list.getEntries()) {
+        try {
+          const start = Math.round(origin + e.startTime);
+          const key = `${e.entryType}|${e.name}|${e.startTime}`;
+          if (start < cutoff || seen.has(key)) continue;
+          seen.add(key);
+          const url = redactUrl(e.name);
+          if (excluded(url) || excluded(e.name)) continue;
+          const status = e.responseStatus;
+          const timing = { transferSize: e.transferSize, responseSize: e.decodedBodySize, ...status ? { status } : {} };
+          if (e.initiatorType === "fetch" || e.initiatorType === "xmlhttprequest") {
+            const match = recent.find((r) => r.url === url && Math.abs(r.startTime - start) <= 50);
+            if (match) Object.assign(match, { transferSize: timing.transferSize, responseSize: timing.responseSize }, match.status === void 0 && status ? { status } : {});
+            continue;
+          }
+          const type = e.entryType === "navigation" ? "document" : /\.(woff2?|ttf|otf|eot)(\?|$)/i.test(e.name) ? "font" : RESOURCE_TYPES[e.initiatorType] ?? "other";
+          push({ id: (0, import_runtime.randomId)(12), type, method: "GET", url, startTime: start, endTime: Math.round(origin + e.responseEnd), durationMs: Math.round(e.duration), ...timing });
+        } catch {
+        }
+      }
+    };
+    for (const type of ["resource", "navigation"]) {
+      try {
+        const po = new PO(onEntries);
+        po.observe({ type, buffered: true });
+        cleanups.push(() => po.disconnect());
+      } catch {
+      }
+    }
+  }
+  return {
+    flush,
+    stop: () => {
+      if (!active) return;
+      flush();
+      active = false;
+      perfCutoff = now();
+      cleanups.splice(0).forEach((fn) => {
+        try {
+          fn();
+        } catch {
+        }
+      });
+    }
+  };
+}
+function networkRecordPlugin(opts) {
+  let capture = null;
+  return {
+    plugin: {
+      name: import_runtime.NETWORK_PLUGIN,
+      options: {},
+      observer: (cb, win) => {
+        if (capture || win !== (typeof window !== "undefined" ? window : win)) return () => {
+        };
+        const c = startNetworkCapture(win, opts, cb);
+        capture = c;
+        return () => {
+          c.stop();
+          if (capture === c) capture = null;
+        };
+      }
+    },
+    flush: () => capture?.flush()
+  };
+}
+
+// src/replay.ts
+var import_runtime3 = require("@guidelytech/shared/runtime");
+
+// src/http.ts
+function backoffMs(attempt, baseMs = 1e3, maxMs = 3e4) {
+  return Math.min(maxMs, baseMs * 2 ** Math.max(0, attempt));
+}
+
+// src/replay.ts
+var UNLOAD_MAX_BYTES = 60 * 1024;
+async function gzip(text) {
+  const stream = new Blob([text]).stream().pipeThrough(new CompressionStream("gzip"));
+  return new Response(stream).blob();
+}
+var ReplayController = class {
+  constructor(opts) {
+    __publicField(this, "opts", opts);
+    __publicField(this, "windowId", (0, import_runtime3.randomId)(16));
+    __publicField(this, "handle", null);
+    __publicField(this, "sessionId", null);
+    __publicField(this, "configKey", "");
+    __publicField(this, "buffer", null);
+    __publicField(this, "queue", []);
+    __publicField(this, "queuedBytes", 0);
+    __publicField(this, "seqs", /* @__PURE__ */ new Map());
+    __publicField(this, "interval", null);
+    __publicField(this, "retryTimer", null);
+    __publicField(this, "attempt", 0);
+    __publicField(this, "uploading", false);
+    __publicField(this, "flushing", null);
+    __publicField(this, "destroyed", false);
+  }
+  /** True while rrweb is recording. */
+  isRecording() {
+    return !!this.handle;
+  }
+  /** The session currently being recorded, if any. */
+  get activeSessionId() {
+    return this.sessionId;
+  }
+  /** Starts (or keeps) recording for `sessionId`. Restarts when the session or settings changed. */
+  start(sessionId, config) {
+    if (this.destroyed) return;
+    const key = JSON.stringify(config);
+    if (this.sessionId === sessionId && this.configKey === key && this.handle) return;
+    this.stop();
+    this.handle = this.opts.startRecorder({ ...config, emit: (e) => this.push(sessionId, e), onError: this.opts.onError });
+    if (!this.handle) return;
+    this.sessionId = sessionId;
+    this.configKey = key;
+    this.interval = setInterval(() => void this.flush(), this.opts.flushIntervalMs ?? 5e3);
+  }
+  /** Stops recording. Buffered events are uploaded unless `discard` (consent withdrawn, authoring). */
+  stop(options = {}) {
+    const handle = this.handle;
+    this.handle = null;
+    this.sessionId = null;
+    this.configKey = "";
+    if (this.interval) clearInterval(this.interval);
+    this.interval = null;
+    handle?.stop();
+    if (options.discard) {
+      this.buffer = null;
+      this.queue = [];
+      this.queuedBytes = 0;
+    } else void this.flush();
+  }
+  /** Adds an rrweb custom event (Guidely event markers) while recording. */
+  addCustomEvent(tag, payload) {
+    this.handle?.addCustomEvent(tag, payload);
+  }
+  push(sessionId, event) {
+    let json;
+    try {
+      json = JSON.stringify(event);
+    } catch {
+      return;
+    }
+    if (this.buffer && this.buffer.sessionId !== sessionId) this.seal();
+    const chunk = this.buffer ?? (this.buffer = { sessionId, meta: this.opts.meta(), events: [], bytes: 0 });
+    chunk.events.push(json);
+    chunk.bytes += json.length;
+    if (chunk.bytes > (this.opts.maxBufferBytes ?? 1e6)) void this.flush();
+  }
+  /** Moves the buffer to the upload queue, dropping the oldest chunks above the backlog cap. */
+  seal() {
+    const chunk = this.buffer;
+    this.buffer = null;
+    if (!chunk || !chunk.events.length) return;
+    this.queue.push(chunk);
+    this.queuedBytes += chunk.bytes;
+    const max = this.opts.maxQueuedBytes ?? 5e6;
+    while (this.queuedBytes > max && this.queue.length > 1) {
+      const i = this.uploading ? 1 : 0;
+      const [dropped] = this.queue.splice(i, 1);
+      if (dropped) this.queuedBytes -= dropped.bytes;
+    }
+  }
+  nextSeq(chunk) {
+    if (chunk.seq === void 0) {
+      const seq = this.seqs.get(chunk.sessionId) ?? 0;
+      this.seqs.set(chunk.sessionId, seq + 1);
+      chunk.seq = seq;
+    }
+    return chunk.seq;
+  }
+  body(chunk) {
+    const head = JSON.stringify({ sessionId: chunk.sessionId, windowId: this.windowId, seq: this.nextSeq(chunk), ...chunk.meta });
+    return `${head.slice(0, -1)},"events":[${chunk.events.join(",")}]}`;
+  }
+  remove(chunk) {
+    const i = this.queue.indexOf(chunk);
+    if (i >= 0) {
+      this.queue.splice(i, 1);
+      this.queuedBytes -= chunk.bytes;
+    }
+  }
+  /** Uploads the buffer and the backlog, one chunk at a time; retries with backoff on failure. */
+  flush() {
+    this.seal();
+    if (this.retryTimer || !this.queue.length) return Promise.resolve();
+    if (this.flushing) return this.flushing.then(() => this.flush());
+    return this.flushing = this.drain().finally(() => {
+      this.flushing = null;
+    });
+  }
+  async drain() {
+    this.uploading = true;
+    try {
+      while (this.queue.length) {
+        const chunk = this.queue[0];
+        const result = await this.send(chunk);
+        if (result === "retry") {
+          this.attempt += 1;
+          if (!this.destroyed && this.attempt < 6) {
+            this.retryTimer = setTimeout(() => {
+              this.retryTimer = null;
+              void this.flush();
+            }, backoffMs(this.attempt - 1));
+          } else this.attempt = 0;
+          return;
+        }
+        this.attempt = 0;
+        this.remove(chunk);
+        if (result === "disabled") {
+          for (const c of this.queue.slice()) if (c.sessionId === chunk.sessionId) this.remove(c);
+          this.opts.onDisabled(chunk.sessionId);
+        }
+      }
+    } finally {
+      this.uploading = false;
+    }
+  }
+  async send(chunk) {
+    const f = this.opts.fetch();
+    if (!f) return "drop";
+    try {
+      const json = this.body(chunk);
+      let body = json;
+      let enc;
+      if (typeof CompressionStream === "function") {
+        try {
+          body = await gzip(json);
+          enc = "gzip";
+        } catch {
+          body = json;
+        }
+      }
+      const size = typeof body === "string" ? body.length : body.size;
+      const res = await f(this.opts.url({ enc }), { method: "POST", body, headers: { "Content-Type": "text/plain" }, keepalive: size < UNLOAD_MAX_BYTES, credentials: "omit", mode: "cors" });
+      if (res.ok) {
+        const data = await res.json().catch(() => null);
+        return data?.disabled ? "disabled" : "ok";
+      }
+      return res.status >= 400 && res.status < 500 && res.status !== 429 ? "drop" : "retry";
+    } catch {
+      return "retry";
+    }
+  }
+  /**
+   * Page is being hidden / unloaded: sends whatever is buffered synchronously as uncompressed JSON
+   * (`sendBeacon` up to 60KB, keepalive fetch otherwise), splitting chunks that never went out.
+   */
+  flushOnHide() {
+    this.handle?.flush?.();
+    this.seal();
+    const pending = this.queue.slice(this.uploading ? 1 : 0);
+    for (const chunk of pending) {
+      const parts = chunk.seq === void 0 ? splitChunk(chunk, UNLOAD_MAX_BYTES - 2048) : [chunk];
+      let sent = true;
+      for (const part of parts) {
+        if (!this.sendNow(this.body(part))) {
+          sent = false;
+          break;
+        }
+        if (part !== chunk) {
+          chunk.events.splice(0, part.events.length);
+          chunk.bytes -= part.bytes;
+          this.queuedBytes -= part.bytes;
+        }
+      }
+      if (!sent) break;
+      this.remove(chunk);
+    }
+  }
+  sendNow(json) {
+    const url = this.opts.url({});
+    try {
+      if (json.length <= UNLOAD_MAX_BYTES && typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" && navigator.sendBeacon(url, new Blob([json], { type: "text/plain;charset=UTF-8" }))) return true;
+      const f = this.opts.fetch();
+      if (!f || json.length > 64 * 1024) return false;
+      void f(url, { method: "POST", body: json, headers: { "Content-Type": "text/plain" }, keepalive: true, credentials: "omit", mode: "cors" }).catch(() => void 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Stops recording and uploads what is left; no retries afterwards. */
+  destroy() {
+    this.stop();
+    this.destroyed = true;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+};
+function splitChunk(chunk, max) {
+  if (chunk.bytes <= max) return [chunk];
+  const parts = [];
+  let cur = null;
+  for (const e of chunk.events) {
+    if (!cur || cur.bytes + e.length > max && cur.events.length) parts.push(cur = { sessionId: chunk.sessionId, meta: chunk.meta, events: [], bytes: 0 });
+    cur.events.push(e);
+    cur.bytes += e.length;
+  }
+  return parts;
+}
+
+// src/recorder.ts
+function startRecorder(options) {
+  const onError = (err) => {
+    try {
+      options.onError?.(err);
+    } catch {
+    }
+    return true;
+  };
+  try {
+    const network = options.network ? networkRecordPlugin(options.network) : null;
+    const plugins = [];
+    if (options.recordConsole) plugins.push((0, import_rrweb_plugin_console_record.getRecordConsolePlugin)({ level: ["error", "warn", "info", "log"], lengthThreshold: 200 }));
+    if (network) plugins.push(network.plugin);
+    const stop = (0, import_record.record)({
+      emit: (event) => options.emit(event),
+      maskAllInputs: true,
+      maskTextSelector: options.maskTextSelector || void 0,
+      blockSelector: options.blockSelector || void 0,
+      slimDOMOptions: { script: true, comment: true, headFavicon: true, headWhitespace: true, headMetaSocial: true, headMetaRobots: true, headMetaHttpEquiv: true, headMetaVerification: true, headMetaAuthorship: true, headMetaDescKeywords: true },
+      sampling: { mousemove: 50, scroll: 150, input: "last" },
+      inlineStylesheet: true,
+      recordCanvas: false,
+      collectFonts: false,
+      inlineImages: false,
+      plugins,
+      errorHandler: onError
+    });
+    if (!stop) return null;
+    return {
+      stop: () => {
+        try {
+          stop();
+        } catch (err) {
+          onError(err);
+        }
+      },
+      addCustomEvent: (tag, payload) => {
+        try {
+          import_record.record.addCustomEvent(tag, payload);
+        } catch {
+        }
+      },
+      flush: () => network?.flush()
+    };
+  } catch (err) {
+    onError(err);
+    return null;
+  }
+}
+var recorder = { startRecorder, createReplay: (options) => new ReplayController({ ...options, startRecorder }) };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReplayController,
+  recorder,
+  startRecorder
+});
+//# sourceMappingURL=recorder.cjs.map