@loxel.dev/pharos-browser 0.6.0

package/dist/index-bc4bw3ba.js

@@ -0,0 +1,844 @@
+// src/privacy/mask.ts
+var MASK_TOKEN = "••••";
+function maskText(_text) {
+  return MASK_TOKEN;
+}
+
+// src/privacy/markers.ts
+var EXCLUDE_CLASS = "pharos-exclude";
+var MASK_CLASS = "pharos-mask";
+function hasMarkerAncestor(el, cls) {
+  let node = el;
+  while (node) {
+    if (node.classList?.contains(cls))
+      return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+function shouldExclude(el) {
+  return hasMarkerAncestor(el, EXCLUDE_CLASS);
+}
+function shouldMaskByMarker(el) {
+  return hasMarkerAncestor(el, MASK_CLASS);
+}
+
+// src/privacy/sensitivity.ts
+var SENSITIVE_INPUT_TYPES = new Set(["password", "email", "tel"]);
+var SENSITIVE_AUTOCOMPLETE = new Set([
+  "username",
+  "current-password",
+  "new-password",
+  "one-time-code",
+  "email",
+  "tel",
+  "given-name",
+  "family-name",
+  "name",
+  "street-address",
+  "address-line1",
+  "address-line2",
+  "address-line3",
+  "postal-code",
+  "cc-number",
+  "cc-exp",
+  "cc-csc",
+  "cc-name",
+  "bday",
+  "bday-day",
+  "bday-month",
+  "bday-year",
+  "sex"
+]);
+var SENSITIVE_WORDS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "otp",
+  "username",
+  "userid",
+  "email",
+  "mail",
+  "phone",
+  "tel",
+  "mobile",
+  "firstname",
+  "lastname",
+  "fullname",
+  "fname",
+  "lname",
+  "surname",
+  "maidenname",
+  "address",
+  "street",
+  "postcode",
+  "postalcode",
+  "zip",
+  "birthday",
+  "birthdate",
+  "dob",
+  "dateofbirth",
+  "ssn",
+  "socialsecurity",
+  "nationalid",
+  "taxid",
+  "creditcard",
+  "cardnumber",
+  "cvv",
+  "cvc",
+  "iban",
+  "passport",
+  "driverslicense"
+];
+var NAME_ATTRS = ["name", "id", "aria-label"];
+function normalize(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isSensitiveField(el) {
+  if (el.tagName.toLowerCase() === "input") {
+    const type = (el.getAttribute("type") ?? "text").toLowerCase();
+    if (SENSITIVE_INPUT_TYPES.has(type))
+      return true;
+  }
+  const autocomplete = el.getAttribute("autocomplete");
+  if (autocomplete) {
+    for (const token of autocomplete.toLowerCase().split(/\s+/)) {
+      if (SENSITIVE_AUTOCOMPLETE.has(token))
+        return true;
+    }
+  }
+  for (const attr of NAME_ATTRS) {
+    const raw = el.getAttribute(attr);
+    if (!raw)
+      continue;
+    const normalized = normalize(raw);
+    if (SENSITIVE_WORDS.some((word) => normalized.includes(word)))
+      return true;
+  }
+  return false;
+}
+
+// src/privacy/attributes.ts
+var URL_ATTRS = new Set([
+  "href",
+  "src",
+  "action",
+  "formaction",
+  "poster",
+  "xlink:href",
+  "data",
+  "ping",
+  "cite"
+]);
+var VALUE_BEARING_ATTRS = new Set(["value", "placeholder", "title", "alt", "aria-label"]);
+function scrubUrl(value) {
+  let url;
+  try {
+    url = new URL(value, document.baseURI);
+  } catch {
+    return MASK_TOKEN;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return MASK_TOKEN;
+  const wasAbsolute = /^[a-z][a-z0-9+.-]*:/i.test(value) || value.startsWith("//");
+  return wasAbsolute ? `${url.protocol}//${url.host}${url.pathname}` : url.pathname;
+}
+function scrubSrcset(value) {
+  const candidates = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (candidates.length === 0)
+    return MASK_TOKEN;
+  const scrubbed = [];
+  for (const candidate of candidates) {
+    const parts = candidate.split(/\s+/);
+    if (parts.length < 1 || parts.length > 2 || !parts[0])
+      return MASK_TOKEN;
+    const [url, descriptor] = parts;
+    const scrubbedUrl = scrubUrl(url);
+    scrubbed.push(descriptor ? `${scrubbedUrl} ${descriptor}` : scrubbedUrl);
+  }
+  return scrubbed.join(", ");
+}
+var CSS_URL_RE = /url\(\s*(['"]?)([^'")]*)\1\s*\)/gi;
+var UNTERMINATED_URL_RE = /url\((?![^)]*\))/i;
+var DECLARATION_RE = /^(\s*)([a-zA-Z-]+)(\s*:\s*)([\s\S]*?)(\s*)$/;
+function findStringEnd(text, start, quote) {
+  let i = start + 1;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote)
+      return i;
+    i++;
+  }
+  return -1;
+}
+function splitDeclarations(value) {
+  const declarations = [];
+  let current = "";
+  let i = 0;
+  while (i < value.length) {
+    const ch = value[i];
+    if (ch === '"' || ch === "'") {
+      const end = findStringEnd(value, i, ch);
+      if (end === -1) {
+        current += value.slice(i);
+        i = value.length;
+      } else {
+        current += value.slice(i, end + 1);
+        i = end + 1;
+      }
+    } else if (ch === ";") {
+      declarations.push(current);
+      current = "";
+      i++;
+    } else {
+      current += ch;
+      i++;
+    }
+  }
+  declarations.push(current);
+  return declarations;
+}
+var QUOTED_VALUE_ALLOWLIST = new Set([
+  "font-family",
+  "font",
+  "grid-template-areas",
+  "grid-template"
+]);
+function maskQuotedStrings(text, allowed) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (/^url\(/i.test(text.slice(i))) {
+      const closeIdx = text.indexOf(")", i);
+      if (closeIdx === -1) {
+        result += MASK_TOKEN;
+        return result;
+      }
+      result += text.slice(i, closeIdx + 1);
+      i = closeIdx + 1;
+      continue;
+    }
+    const ch = text[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      const closeIdx = findStringEnd(text, i, quote);
+      if (closeIdx === -1) {
+        result += MASK_TOKEN;
+        return result;
+      }
+      result += allowed ? text.slice(i, closeIdx + 1) : `${quote}${MASK_TOKEN}${quote}`;
+      i = closeIdx + 1;
+    } else {
+      result += ch;
+      i++;
+    }
+  }
+  return result;
+}
+function scrubDeclaration(declaration) {
+  const match = DECLARATION_RE.exec(declaration);
+  if (!match) {
+    return maskQuotedStrings(declaration, false);
+  }
+  const [, leadingWs, name, sep, rawValue, trailingWs] = match;
+  const allowed = QUOTED_VALUE_ALLOWLIST.has(name.trim().toLowerCase());
+  return `${leadingWs}${name}${sep}${maskQuotedStrings(rawValue, allowed)}${trailingWs}`;
+}
+function scrubStyle(value) {
+  const withUrls = /url\(/i.test(value) ? value.replace(CSS_URL_RE, (_match, quote, inner) => `url(${quote}${scrubUrl(inner)}${quote})`) : value;
+  const cut = withUrls.search(UNTERMINATED_URL_RE);
+  if (cut !== -1) {
+    const head = splitDeclarations(withUrls.slice(0, cut)).map(scrubDeclaration).join(";");
+    return `${head}${MASK_TOKEN}`;
+  }
+  return splitDeclarations(withUrls).map(scrubDeclaration).join(";");
+}
+function scrubAttribute(el, name, value) {
+  const attr = name.toLowerCase();
+  if (attr === "style")
+    return scrubStyle(value);
+  if (attr === "srcset")
+    return scrubSrcset(value);
+  if (URL_ATTRS.has(attr))
+    return scrubUrl(value);
+  if (isSensitiveField(el) && (VALUE_BEARING_ATTRS.has(attr) || attr.startsWith("data-"))) {
+    return MASK_TOKEN;
+  }
+  return value;
+}
+
+// src/privacy/policy.ts
+var NEVER_RECORDED_TAGS = new Set(["script"]);
+function isAlwaysMaskedInput(el) {
+  if (el.tagName.toLowerCase() !== "input")
+    return false;
+  const type = (el.getAttribute("type") ?? "text").toLowerCase();
+  return type === "password" || type === "hidden";
+}
+function decide(el) {
+  if (NEVER_RECORDED_TAGS.has(el.tagName.toLowerCase()))
+    return "exclude";
+  if (shouldExclude(el))
+    return "exclude";
+  if (isAlwaysMaskedInput(el))
+    return "mask";
+  if (shouldMaskByMarker(el))
+    return "mask";
+  if (isSensitiveField(el))
+    return "mask";
+  return "record";
+}
+function isEditableByAttribute(el) {
+  let node = el;
+  while (node) {
+    const raw = node.getAttribute("contenteditable");
+    if (raw !== null) {
+      const state = raw.toLowerCase();
+      if (state === "true" || state === "" || state === "plaintext-only")
+        return true;
+      if (state === "false")
+        return false;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+function masksValue(el) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "input" || tag === "textarea")
+    return true;
+  if (el.isContentEditable === true)
+    return true;
+  return isEditableByAttribute(el);
+}
+
+// src/replay/config.ts
+var MAX_BUFFER_BYTES = 30 * 1024 * 1024;
+var MIN_BUFFER_BYTES = 64 * 1024;
+var RECORDER_DEFAULTS = {
+  preRollMs: 30000,
+  postRollMs: 1e4,
+  pointerHz: 20
+};
+function clamp(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return fallback;
+  return Math.min(max, Math.max(min, value));
+}
+function clampMaxBytes(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return MAX_BUFFER_BYTES;
+  if (value <= 0)
+    return MIN_BUFFER_BYTES;
+  return Math.min(MAX_BUFFER_BYTES, value);
+}
+function resolveConfig(opts) {
+  const preRollMs = clamp(opts.preRollMs, RECORDER_DEFAULTS.preRollMs, 1000, 300000);
+  const postRollMs = clamp(opts.postRollMs, RECORDER_DEFAULTS.postRollMs, 0, 120000);
+  const pointerHz = clamp(opts.pointerHz, RECORDER_DEFAULTS.pointerHz, 1, 60);
+  const maxBytes = clampMaxBytes(opts.maxBytes);
+  return {
+    preRollMs,
+    postRollMs,
+    maxBytes,
+    pointerHz,
+    mousemoveWaitMs: Math.round(1000 / pointerHz),
+    checkpointIntervalMs: Math.max(1000, Math.round(preRollMs / 2))
+  };
+}
+
+// src/replay/interactions.ts
+var ACTIVATION_MODALITY_TTL_MS = 500;
+var ACTIVATION_EVENT_TAG = "pharos-activation";
+function resolveActivationMode(input) {
+  if (input.detail > 0)
+    return "pointer";
+  const fresh = input.modality !== null && input.at - input.modalityAt <= ACTIVATION_MODALITY_TTL_MS;
+  if (fresh && input.modality === "keyboard")
+    return "keyboard";
+  if (fresh && input.modality === "pointer")
+    return "pointer";
+  return "programmatic";
+}
+function attachInteractions(opts) {
+  const state = { modality: null, modalityAt: 0, pointerAt: Number.NEGATIVE_INFINITY, work: 0 };
+  let pointerIntervalMs = opts.pointerIntervalMs;
+  const onKeyDown = () => {
+    state.modality = "keyboard";
+    state.modalityAt = opts.now();
+    state.work += 1;
+  };
+  const onPointerDown = () => {
+    state.modality = "pointer";
+    state.modalityAt = opts.now();
+    state.work += 1;
+  };
+  const onPointerMove = () => {
+    const t = opts.now();
+    if (t - state.pointerAt < pointerIntervalMs)
+      return;
+    state.pointerAt = t;
+    state.modality = "pointer";
+    state.modalityAt = t;
+    state.work += 1;
+  };
+  const onClick = (event) => {
+    const detail = event.detail ?? 0;
+    opts.emit({
+      mode: resolveActivationMode({
+        modality: state.modality,
+        modalityAt: state.modalityAt,
+        at: opts.now(),
+        detail
+      })
+    });
+  };
+  opts.target.addEventListener("keydown", onKeyDown, true);
+  opts.target.addEventListener("pointerdown", onPointerDown, true);
+  opts.target.addEventListener("pointermove", onPointerMove, true);
+  opts.target.addEventListener("click", onClick, true);
+  return {
+    state,
+    setPointerIntervalMs(ms) {
+      pointerIntervalMs = ms;
+    },
+    detach() {
+      opts.target.removeEventListener("keydown", onKeyDown, true);
+      opts.target.removeEventListener("pointerdown", onPointerDown, true);
+      opts.target.removeEventListener("pointermove", onPointerMove, true);
+      opts.target.removeEventListener("click", onClick, true);
+    }
+  };
+}
+
+// src/replay/buffer.ts
+var EVENT_TYPE_FULL_SNAPSHOT = 2;
+var EVENT_TYPE_META = 4;
+function beginsWithSnapshot(events) {
+  if (events.length === 0)
+    return false;
+  if (events[0].type === EVENT_TYPE_FULL_SNAPSHOT)
+    return true;
+  return events[0].type === EVENT_TYPE_META && events[1]?.type === EVENT_TYPE_FULL_SNAPSHOT;
+}
+var MAX_PENDING_META_AGE_MS = 1000;
+function utf8Length(s) {
+  let bytes = 0;
+  for (let i = 0;i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code < 128) {
+      bytes += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319 && i + 1 < s.length) {
+      const low = s.charCodeAt(i + 1);
+      if (low >= 56320 && low <= 57343) {
+        bytes += 4;
+        i += 1;
+        continue;
+      }
+      bytes += 3;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function defaultSizeOf(event) {
+  return utf8Length(JSON.stringify(event));
+}
+
+class ReplayBuffer {
+  maxBytes;
+  preRollMs;
+  sizeOf;
+  onCeilingEviction;
+  onSegmentClosed;
+  segments = [];
+  pendingMeta = null;
+  newestTimestamp = 0;
+  totalBytes = 0;
+  evictedForAge = 0;
+  evictedForBytes = 0;
+  droppedBeforeFirstSnapshot = 0;
+  constructor(opts) {
+    this.maxBytes = opts.maxBytes;
+    this.preRollMs = opts.preRollMs;
+    this.sizeOf = opts.sizeOf ?? defaultSizeOf;
+    this.onCeilingEviction = opts.onCeilingEviction;
+    this.onSegmentClosed = opts.onSegmentClosed;
+  }
+  append(event) {
+    if (event.timestamp > this.newestTimestamp)
+      this.newestTimestamp = event.timestamp;
+    if (event.type === EVENT_TYPE_META) {
+      this.pendingMeta = event;
+      return;
+    }
+    if (event.type === EVENT_TYPE_FULL_SNAPSHOT) {
+      const meta = this.pendingMeta !== null && Math.abs(event.timestamp - this.pendingMeta.timestamp) <= MAX_PENDING_META_AGE_MS ? this.pendingMeta : null;
+      const events = meta ? [meta, event] : [event];
+      const bytes2 = events.reduce((sum, e) => sum + this.sizeOf(e), 0);
+      this.pendingMeta = null;
+      const closing = this.segments[this.segments.length - 1];
+      this.segments.push({ startedAt: event.timestamp, events, bytes: bytes2 });
+      this.totalBytes += bytes2;
+      this.evict();
+      if (closing)
+        this.onSegmentClosed?.([...closing.events], closing.startedAt);
+      return;
+    }
+    const current = this.segments[this.segments.length - 1];
+    if (!current) {
+      this.droppedBeforeFirstSnapshot += 1;
+      return;
+    }
+    const bytes = this.sizeOf(event);
+    current.events.push(event);
+    current.bytes += bytes;
+    this.totalBytes += bytes;
+    this.evict();
+  }
+  dropOldestSegment() {
+    const dropped = this.segments.shift();
+    if (dropped)
+      this.totalBytes -= dropped.bytes;
+  }
+  evict() {
+    while (this.segments.length > 1) {
+      const next = this.segments[1];
+      if (next.startedAt > this.newestTimestamp - this.preRollMs)
+        break;
+      this.dropOldestSegment();
+      this.evictedForAge += 1;
+    }
+    while (this.totalBytes > this.maxBytes && this.segments.length > 1) {
+      this.dropOldestSegment();
+      this.evictedForBytes += 1;
+      this.onCeilingEviction?.();
+    }
+  }
+  extract(triggeredAt, until) {
+    if (this.segments.length === 0)
+      return null;
+    const boundary = triggeredAt - this.preRollMs;
+    let start = 0;
+    for (let i = 0;i < this.segments.length; i++) {
+      if (this.segments[i].startedAt <= boundary)
+        start = i;
+      else
+        break;
+    }
+    const out = [];
+    for (let i = start;i < this.segments.length; i++) {
+      const segment = this.segments[i];
+      for (const event of segment.events) {
+        const isOpeningHead = i === start && (event.type === EVENT_TYPE_META || event.type === EVENT_TYPE_FULL_SNAPSHOT);
+        if (!isOpeningHead && event.timestamp > until)
+          continue;
+        out.push(event);
+      }
+    }
+    if (!beginsWithSnapshot(out))
+      return null;
+    return out;
+  }
+  currentSegment() {
+    const segment = this.segments[this.segments.length - 1];
+    if (!segment)
+      return null;
+    return { events: [...segment.events], startedAt: segment.startedAt };
+  }
+  clear() {
+    this.segments = [];
+    this.pendingMeta = null;
+    this.totalBytes = 0;
+    this.newestTimestamp = 0;
+    this.evictedForAge = 0;
+    this.evictedForBytes = 0;
+    this.droppedBeforeFirstSnapshot = 0;
+  }
+  stats() {
+    let events = 0;
+    for (const segment of this.segments)
+      events += segment.events.length;
+    return {
+      bytes: this.totalBytes,
+      segments: this.segments.length,
+      events,
+      evictedForAge: this.evictedForAge,
+      evictedForBytes: this.evictedForBytes,
+      droppedBeforeFirstSnapshot: this.droppedBeforeFirstSnapshot
+    };
+  }
+}
+
+// src/replay/drops.ts
+function emptyBuckets() {
+  return {
+    oversized: 0,
+    delivery: 0,
+    quota: 0,
+    storage: 0,
+    "no-snapshot": 0,
+    "fabricated-window": 0
+  };
+}
+function createDropLedger() {
+  let buckets = emptyBuckets();
+  return {
+    note(reason) {
+      buckets[reason] += 1;
+    },
+    total() {
+      let sum = 0;
+      for (const key of Object.keys(buckets))
+        sum += buckets[key];
+      return sum;
+    },
+    byReason() {
+      return { ...buckets };
+    },
+    reset() {
+      buckets = emptyBuckets();
+    }
+  };
+}
+
+// src/replay/upload.ts
+var TRANSPORT_MAX_BODY_BYTES = 8388608;
+var TRANSPORT_HEADER_ALLOWANCE = 65536;
+var MAX_WINDOW_BYTES = Math.floor((TRANSPORT_MAX_BODY_BYTES - TRANSPORT_HEADER_ALLOWANCE) * 3 / 4);
+function encodeRaw(w) {
+  return new TextEncoder().encode(JSON.stringify(w));
+}
+async function encodeWindow(w) {
+  if (typeof CompressionStream === "undefined") {
+    return { body: encodeRaw(w), compressed: false };
+  }
+  const stream = new CompressionStream("gzip");
+  const writer = stream.writable.getWriter();
+  writer.write(encodeRaw(w));
+  writer.close();
+  const gzipped = await new Response(stream.readable).arrayBuffer();
+  return { body: new Uint8Array(gzipped), compressed: true };
+}
+function toBase64(bytes) {
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0;i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function randomSessionId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `sess-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+async function postEnvelope(body, meta, target) {
+  const fetchImpl = target.fetchImpl ?? fetch;
+  const res = await fetchImpl(target.endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${target.appKey}`
+    },
+    body: JSON.stringify({ ...meta, blob: toBase64(body) })
+  });
+  return res.ok;
+}
+function envelopeMetaFor(window, sessionId, compressed, droppedWindows) {
+  return {
+    sessionId,
+    trigger: window.trigger,
+    degraded: window.degraded,
+    config: window.config,
+    compressed,
+    droppedWindows
+  };
+}
+async function encodeForUpload(window, compress) {
+  return compress === false ? { body: encodeRaw(window), compressed: false } : await encodeWindow(window);
+}
+function createUploadSink(opts) {
+  const sessionId = opts.sessionId && opts.sessionId.length > 0 ? opts.sessionId : randomSessionId();
+  const drops = opts.drops ?? createDropLedger();
+  const onFailure = async (window) => {
+    if (opts.onDeliveryFailure) {
+      try {
+        await opts.onDeliveryFailure(window);
+        return;
+      } catch {}
+    }
+    drops.note("delivery");
+  };
+  const uploadOne = async (window) => {
+    try {
+      const { body, compressed } = await encodeForUpload(window, opts.compress);
+      if (body.byteLength > MAX_WINDOW_BYTES) {
+        drops.note("oversized");
+        return;
+      }
+      const ok = await postEnvelope(body, envelopeMetaFor(window, sessionId, compressed, drops.total()), opts);
+      if (!ok)
+        await onFailure(window);
+    } catch {
+      await onFailure(window);
+    }
+  };
+  return (window) => {
+    const inflight = uploadOne(window);
+    opts.track?.(inflight);
+  };
+}
+
+// src/replay/persist.ts
+var DB_NAME = "pharos-replay";
+var DB_VERSION = 1;
+var STORE_NAME = "windows";
+var LOCAL_TTL_MS = 24 * 60 * 60 * 1000;
+var defaultDrops = createDropLedger();
+function quotaDroppedWindows() {
+  return defaultDrops.byReason().quota;
+}
+function resetQuotaDroppedWindows() {
+  defaultDrops.reset();
+}
+function defaultFactory() {
+  const factory = globalThis.indexedDB;
+  if (!factory) {
+    throw new Error("persist.ts: no IndexedDB available (pass an indexedDB factory explicitly)");
+  }
+  return factory;
+}
+function openDb(factory) {
+  return new Promise((resolve, reject) => {
+    const req = factory.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function addRecord(db, record) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const req = tx.objectStore(STORE_NAME).add(record);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+function getAllRecords(db) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const req = tx.objectStore(STORE_NAME).getAll();
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function deleteRecord(db, id) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const req = tx.objectStore(STORE_NAME).delete(id);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+function clearStore(db) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const req = tx.objectStore(STORE_NAME).clear();
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+function isQuotaExceeded(err) {
+  return err instanceof Object && err.name === "QuotaExceededError";
+}
+async function purgeExpired(db, now) {
+  const records = await getAllRecords(db);
+  const cutoff = now();
+  let purged = 0;
+  for (const rec of records) {
+    if (rec.id === undefined)
+      continue;
+    if (cutoff - rec.insertedAt > LOCAL_TTL_MS) {
+      await deleteRecord(db, rec.id);
+      purged += 1;
+    }
+  }
+  return purged;
+}
+async function persistWindow(body, meta, now = Date.now, indexedDB = defaultFactory(), drops = defaultDrops) {
+  const db = await openDb(indexedDB);
+  try {
+    await purgeExpired(db, now);
+    const record = { insertedAt: now(), body, meta };
+    try {
+      await addRecord(db, record);
+    } catch (err) {
+      if (!isQuotaExceeded(err))
+        throw err;
+      const existing = await getAllRecords(db);
+      if (existing.length > 0) {
+        const oldest = existing[0];
+        if (oldest.id !== undefined) {
+          await deleteRecord(db, oldest.id);
+          drops.note("quota");
+        }
+      }
+      await addRecord(db, record);
+    }
+  } finally {
+    db.close();
+  }
+}
+async function drainPersisted(send, now = Date.now, indexedDB = defaultFactory()) {
+  const db = await openDb(indexedDB);
+  try {
+    const records = await getAllRecords(db);
+    let drained = 0;
+    for (const rec of records) {
+      if (rec.id === undefined)
+        continue;
+      if (now() - rec.insertedAt > LOCAL_TTL_MS) {
+        await deleteRecord(db, rec.id);
+        continue;
+      }
+      let ok = false;
+      try {
+        ok = await send(rec.body, rec.meta);
+      } catch {
+        ok = false;
+      }
+      if (ok) {
+        await deleteRecord(db, rec.id);
+        drained += 1;
+      }
+    }
+    return drained;
+  } finally {
+    db.close();
+  }
+}
+async function clearPersisted(indexedDB = defaultFactory()) {
+  const db = await openDb(indexedDB);
+  try {
+    await clearStore(db);
+  } finally {
+    db.close();
+  }
+}
+
+export { MASK_TOKEN, maskText, EXCLUDE_CLASS, MASK_CLASS, shouldExclude, shouldMaskByMarker, isSensitiveField, scrubUrl, scrubAttribute, decide, masksValue, MAX_BUFFER_BYTES, RECORDER_DEFAULTS, resolveConfig, ACTIVATION_EVENT_TAG, attachInteractions, EVENT_TYPE_FULL_SNAPSHOT, EVENT_TYPE_META, beginsWithSnapshot, ReplayBuffer, createDropLedger, MAX_WINDOW_BYTES, encodeWindow, randomSessionId, postEnvelope, envelopeMetaFor, encodeForUpload, createUploadSink, LOCAL_TTL_MS, quotaDroppedWindows, resetQuotaDroppedWindows, isQuotaExceeded, persistWindow, drainPersisted, clearPersisted };