@loxel.dev/pharos-browser 0.6.0

package/dist/wire-992wvzs1.js

@@ -0,0 +1,926 @@
+import {
+  ACTIVATION_EVENT_TAG,
+  EVENT_TYPE_FULL_SNAPSHOT,
+  EVENT_TYPE_META,
+  EXCLUDE_CLASS,
+  MASK_CLASS,
+  MASK_TOKEN,
+  MAX_WINDOW_BYTES,
+  ReplayBuffer,
+  attachInteractions,
+  beginsWithSnapshot,
+  clearPersisted,
+  createDropLedger,
+  createUploadSink,
+  decide,
+  drainPersisted,
+  encodeForUpload,
+  envelopeMetaFor,
+  isQuotaExceeded,
+  maskText,
+  masksValue,
+  persistWindow,
+  postEnvelope,
+  randomSessionId,
+  resetQuotaDroppedWindows,
+  resolveConfig,
+  scrubAttribute,
+  scrubUrl
+} from "./index-bc4bw3ba.js";
+import"./index-c3taa3cg.js";
+
+// src/replay/recorder.ts
+import { record } from "rrweb";
+
+// src/replay/budget.ts
+var LONG_TASK_MS = 50;
+var ESCALATION_COOLDOWN_MS = 5000;
+var RECOVERY_AFTER_MS = 30000;
+var MAX_DEGRADATION_LEVEL = 3;
+var CEILING_RECORD_COOLDOWN_MS = 1e4;
+var CHECKPOINT_MULTIPLIER = [1, 2, 4, 4];
+var POINTER_MULTIPLIER = [1, 1, 1, 4];
+function createBudget(opts) {
+  let level = 0;
+  let lastEscalationAt = Number.NEGATIVE_INFINITY;
+  let lastLongTaskAt = Number.NEGATIVE_INFINITY;
+  let lastCeilingRecordAt = Number.NEGATIVE_INFINITY;
+  let openCeilingRun = null;
+  const log = [];
+  const checkpointIntervalMs = () => opts.config.checkpointIntervalMs * CHECKPOINT_MULTIPLIER[level];
+  const mousemoveWaitMs = () => opts.config.mousemoveWaitMs * POINTER_MULTIPLIER[level];
+  const record = (reason) => {
+    const entry = {
+      at: opts.now(),
+      level,
+      reason,
+      checkpointIntervalMs: checkpointIntervalMs(),
+      mousemoveWaitMs: mousemoveWaitMs(),
+      occurrences: 1
+    };
+    log.push(entry);
+    openCeilingRun = reason === "memory-ceiling" ? entry : null;
+    return entry;
+  };
+  return {
+    level: () => level,
+    checkpointIntervalMs,
+    mousemoveWaitMs,
+    noteLongTask(durationMs) {
+      if (durationMs < LONG_TASK_MS)
+        return false;
+      const at = opts.now();
+      lastLongTaskAt = at;
+      if (level >= MAX_DEGRADATION_LEVEL)
+        return false;
+      if (at - lastEscalationAt < ESCALATION_COOLDOWN_MS)
+        return false;
+      lastEscalationAt = at;
+      level += 1;
+      record("long-task");
+      return true;
+    },
+    noteCeilingEviction() {
+      const at = opts.now();
+      if (openCeilingRun && at - lastCeilingRecordAt < CEILING_RECORD_COOLDOWN_MS) {
+        openCeilingRun.occurrences += 1;
+        return;
+      }
+      lastCeilingRecordAt = at;
+      record("memory-ceiling");
+    },
+    maybeRecover() {
+      if (level === 0)
+        return false;
+      if (opts.now() - lastLongTaskAt < RECOVERY_AFTER_MS)
+        return false;
+      level -= 1;
+      record("recovery");
+      return true;
+    },
+    records: () => log.map((entry) => ({ ...entry }))
+  };
+}
+function observeLongTasks(budget, onEscalate) {
+  const Ctor = globalThis.PerformanceObserver;
+  if (typeof Ctor !== "function")
+    return () => {};
+  let observer;
+  try {
+    observer = new Ctor((list) => {
+      let changed = false;
+      for (const entry of list.getEntries()) {
+        if (budget.noteLongTask(entry.duration))
+          changed = true;
+      }
+      if (changed)
+        onEscalate();
+    });
+    observer.observe({ type: "longtask", buffered: false });
+  } catch {
+    return () => {};
+  }
+  return () => {
+    try {
+      observer.disconnect();
+    } catch {}
+  };
+}
+
+// src/replay/privacy-hooks.ts
+var RRWEB_INTERNAL_ATTRS = new Set([
+  "rr_width",
+  "rr_height",
+  "rr_scrollLeft",
+  "rr_scrollTop",
+  "rr_dataURL",
+  "_cssText"
+]);
+var RENAMED_CONTENT_ATTRS = new Map([["rr_src", "src"]]);
+function shouldMaskValueOf(el) {
+  if (decide(el) !== "record")
+    return true;
+  return masksValue(el);
+}
+function isStyleDiff(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var SERIALIZED_ELEMENT = 2;
+var SOURCE_MUTATION = 0;
+var SOURCE_INPUT = 5;
+function shouldMaskTextOf(el) {
+  if (!el)
+    return true;
+  return shouldMaskValueOf(el);
+}
+function maskTextHook(text, el) {
+  return shouldMaskTextOf(el) ? maskText(text) : text;
+}
+function maskInputHook(text, _el) {
+  return maskText(text);
+}
+function scrubAttributeValue(el, name, value) {
+  const rule = RENAMED_CONTENT_ATTRS.get(name) ?? name;
+  if (rule === "style" && isStyleDiff(value))
+    return scrubStyleDiff(el, value);
+  if (typeof value !== "string")
+    return value;
+  if (rule.toLowerCase() === "value" && shouldMaskValueOf(el))
+    return MASK_TOKEN;
+  return scrubAttribute(el, rule, value);
+}
+function scrubStyleDiff(el, diff) {
+  const out = {};
+  for (const [property, value] of Object.entries(diff)) {
+    if (typeof value === "string") {
+      out[property] = scrubStyleValue(el, property, value);
+    } else if (Array.isArray(value) && typeof value[0] === "string") {
+      out[property] = [scrubStyleValue(el, property, value[0]), value[1]];
+    } else {
+      out[property] = value;
+    }
+  }
+  return out;
+}
+function scrubStyleValue(el, property, value) {
+  const prefix = `${property}:`;
+  const scrubbed = scrubAttribute(el, "style", `${prefix}${value}`);
+  if (scrubbed === null)
+    return MASK_TOKEN;
+  return scrubbed.startsWith(prefix) ? scrubbed.slice(prefix.length) : MASK_TOKEN;
+}
+var inertDocuments = new WeakMap;
+function inertDocumentFor(doc) {
+  const cached = inertDocuments.get(doc);
+  if (cached)
+    return cached;
+  let inert;
+  try {
+    inert = doc.implementation.createHTMLDocument("");
+  } catch {
+    return null;
+  }
+  inertDocuments.set(doc, inert);
+  return inert;
+}
+function surrogateElement(tagName, attributes, doc) {
+  const inert = inertDocumentFor(doc);
+  if (!inert)
+    return null;
+  let surrogate;
+  try {
+    surrogate = inert.createElement(tagName);
+  } catch {
+    try {
+      surrogate = inert.createElement("span");
+    } catch {
+      return null;
+    }
+  }
+  for (const [name, value] of Object.entries(attributes)) {
+    if (typeof value !== "string")
+      continue;
+    if (RRWEB_INTERNAL_ATTRS.has(name))
+      continue;
+    try {
+      surrogate.setAttribute(name, value);
+    } catch {}
+  }
+  return surrogate;
+}
+var EXCLUDED_ELEMENT_KEPT_ATTRS = new Set([
+  "class",
+  "rr_width",
+  "rr_height",
+  "rr_scrollLeft",
+  "rr_scrollTop"
+]);
+function excludeSerializedNode(node) {
+  if (node.attributes) {
+    for (const name of Object.keys(node.attributes)) {
+      if (EXCLUDED_ELEMENT_KEPT_ATTRS.has(name))
+        continue;
+      delete node.attributes[name];
+    }
+  }
+  node.childNodes = [];
+}
+function scrubSerializedNode(node, doc) {
+  if (node.type === SERIALIZED_ELEMENT && node.attributes && node.tagName) {
+    const surrogate = surrogateElement(node.tagName, node.attributes, doc);
+    if (surrogate && decide(surrogate) === "exclude") {
+      excludeSerializedNode(node);
+      return;
+    }
+    for (const [name, value] of Object.entries(node.attributes)) {
+      if (RRWEB_INTERNAL_ATTRS.has(name))
+        continue;
+      if (!surrogate) {
+        delete node.attributes[name];
+        continue;
+      }
+      const scrubbed = scrubAttributeValue(surrogate, name, value);
+      if (scrubbed === null)
+        delete node.attributes[name];
+      else
+        node.attributes[name] = scrubbed;
+    }
+  }
+  if (node.childNodes) {
+    for (const child of node.childNodes)
+      scrubSerializedNode(child, doc);
+  }
+}
+function scrubEventAttributes(event, ctx) {
+  const e = event;
+  const data = e.data;
+  if (!data)
+    return event;
+  const node = data.node;
+  if (node && typeof node === "object")
+    scrubSerializedNode(node, ctx.doc);
+  if (data.source === SOURCE_INPUT && typeof data.text === "string") {
+    const live = ctx.resolveNode(data.id);
+    const el = live && live.nodeType === 1 ? live : null;
+    data.text = el ? scrubAttributeValue(el, "value", data.text) : MASK_TOKEN;
+  }
+  if (data.source !== SOURCE_MUTATION)
+    return event;
+  const adds = data.adds;
+  if (Array.isArray(adds)) {
+    for (const add of adds) {
+      if (add?.node)
+        scrubSerializedNode(add.node, ctx.doc);
+    }
+  }
+  const attributes = data.attributes;
+  if (Array.isArray(attributes)) {
+    for (let i = attributes.length - 1;i >= 0; i--) {
+      const entry = attributes[i];
+      const live = ctx.resolveNode(entry.id);
+      if (!live || live.nodeType !== 1) {
+        attributes.splice(i, 1);
+        continue;
+      }
+      const el = live;
+      if (decide(el) === "exclude") {
+        attributes.splice(i, 1);
+        continue;
+      }
+      for (const [name, value] of Object.entries(entry.attributes)) {
+        if (RRWEB_INTERNAL_ATTRS.has(name))
+          continue;
+        entry.attributes[name] = scrubAttributeValue(el, name, value);
+      }
+    }
+  }
+  return event;
+}
+
+// src/replay/triggers.ts
+var TRIGGER_MAX_WINDOW_EXTENSION_MS = 30000;
+function contained(fn) {
+  try {
+    fn();
+  } catch {}
+}
+function beginsBeforeTrigger(events, triggeredAt) {
+  return events[0].timestamp <= triggeredAt;
+}
+function createTriggerCoordinator(opts) {
+  let pending = null;
+  let timer = null;
+  const noteDrop = (reason) => {
+    if (!opts.onDrop)
+      return;
+    contained(() => opts.onDrop(reason));
+  };
+  const clear = () => {
+    if (timer !== null) {
+      opts.clearTimer(timer);
+      timer = null;
+    }
+  };
+  const flush = (unloaded) => {
+    if (!pending)
+      return;
+    clear();
+    const current = pending;
+    pending = null;
+    const flushedAt = opts.now();
+    const events = opts.buffer.extract(current.at, flushedAt);
+    if (!events) {
+      noteDrop("no-snapshot");
+      return;
+    }
+    if (!beginsBeforeTrigger(events, current.at)) {
+      noteDrop("fabricated-window");
+      return;
+    }
+    let degraded = [];
+    contained(() => {
+      degraded = opts.degraded();
+    });
+    const replayWindow = {
+      events,
+      trigger: {
+        kind: current.kind,
+        ...current.name !== undefined ? { name: current.name } : {},
+        at: current.at,
+        occurrences: current.occurrences,
+        flushedAt,
+        unloaded
+      },
+      degraded,
+      config: opts.config
+    };
+    contained(() => opts.sink(replayWindow));
+  };
+  const schedule = () => {
+    if (!pending)
+      return;
+    const deadline = Math.min(opts.now() + opts.config.postRollMs, pending.at + TRIGGER_MAX_WINDOW_EXTENSION_MS);
+    const delay = deadline - opts.now();
+    if (delay <= 0) {
+      flush(false);
+      return;
+    }
+    timer = opts.setTimer(() => {
+      timer = null;
+      flush(false);
+    }, delay);
+  };
+  return {
+    trigger(source) {
+      if (pending) {
+        pending.occurrences += 1;
+        clear();
+        schedule();
+        return;
+      }
+      pending = {
+        kind: source.kind,
+        ...source.name !== undefined ? { name: source.name } : {},
+        at: opts.now(),
+        occurrences: 1
+      };
+      schedule();
+    },
+    flushNow(unloaded) {
+      flush(unloaded);
+    },
+    cancel() {
+      clear();
+      pending = null;
+    },
+    pending() {
+      return pending !== null;
+    },
+    checkpoint(events, startedAt, unloaded) {
+      if (!beginsWithSnapshot(events)) {
+        noteDrop("no-snapshot");
+        return;
+      }
+      const flushedAt = opts.now();
+      let degraded = [];
+      contained(() => {
+        degraded = opts.degraded();
+      });
+      const replayWindow = {
+        events,
+        trigger: { kind: "checkpoint", at: startedAt, occurrences: 1, flushedAt, unloaded },
+        degraded,
+        config: opts.config
+      };
+      contained(() => opts.sink(replayWindow));
+    }
+  };
+}
+
+// src/replay/recorder.ts
+function noop() {}
+function defaultScheduleIdle(cb) {
+  const ric = globalThis.requestIdleCallback;
+  if (typeof ric === "function")
+    ric(() => cb(), { timeout: 2000 });
+  else
+    setTimeout(cb, 0);
+}
+function buildRecordOptions(input) {
+  return {
+    emit: input.emit,
+    blockClass: EXCLUDE_CLASS,
+    maskTextClass: MASK_CLASS,
+    maskTextSelector: "*",
+    maskAllInputs: true,
+    maskTextFn: maskTextHook,
+    maskInputFn: maskInputHook,
+    checkoutEveryNms: input.checkoutEveryNms,
+    recordAfter: "DOMContentLoaded",
+    sampling: {
+      mousemove: input.mousemoveWaitMs,
+      mouseInteraction: true,
+      scroll: 150,
+      input: "last"
+    },
+    recordCanvas: false,
+    inlineImages: false,
+    collectFonts: false
+  };
+}
+function scrubMetaHref(event) {
+  if (event.type !== EVENT_TYPE_META)
+    return;
+  const data = event.data;
+  if (!data || typeof data.href !== "string")
+    return;
+  data.href = scrubUrl(data.href);
+}
+var active = null;
+function inertHandle(config) {
+  return {
+    config,
+    stop() {},
+    trigger() {},
+    flushNow() {},
+    stats: () => ({
+      snapshots: 0,
+      bufferBytes: 0,
+      segments: 0,
+      interactionWork: 0,
+      degradationLevel: 0
+    })
+  };
+}
+function startRecording(opts) {
+  const config = resolveConfig(opts);
+  if (active !== null)
+    return inertHandle(config);
+  const ownership = {};
+  active = ownership;
+  const now = opts.now ?? (() => Date.now());
+  const setTimer = opts.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
+  const clearTimer = opts.clearTimer ?? ((handle) => clearTimeout(handle));
+  const scheduleIdle = opts.scheduleIdle ?? defaultScheduleIdle;
+  const doc = opts.doc ?? document;
+  const target = opts.target ?? doc;
+  const lifecycleTarget = opts.lifecycleTarget ?? opts.doc?.defaultView ?? globalThis;
+  const budget = createBudget({ config, now });
+  const buffer = new ReplayBuffer({
+    maxBytes: config.maxBytes,
+    preRollMs: config.preRollMs,
+    onCeilingEviction: () => budget.noteCeilingEviction(),
+    onSegmentClosed: (events, startedAt) => {
+      if (lastUnloadShip !== null && lastUnloadShip.startedAt === startedAt) {
+        const unchanged = lastUnloadShip.eventCount === events.length;
+        lastUnloadShip = null;
+        if (unchanged)
+          return;
+      }
+      coordinator.checkpoint(events, startedAt, false);
+    }
+  });
+  const coordinator = createTriggerCoordinator({
+    buffer,
+    sink: opts.sink,
+    onDrop: opts.onWindowDropped,
+    config,
+    degraded: () => budget.records(),
+    now,
+    setTimer,
+    clearTimer
+  });
+  let stopped = false;
+  let snapshots = 0;
+  let stopRrweb;
+  let checkpointTimer = null;
+  let appliedMousemoveWaitMs = config.mousemoveWaitMs;
+  let detachLongTasks = noop;
+  let detachLifecycle = noop;
+  let lastUnloadShip = null;
+  const onEmit = (event) => {
+    if (stopped)
+      return;
+    const e = event;
+    if (e.type === EVENT_TYPE_FULL_SNAPSHOT)
+      snapshots += 1;
+    scrubMetaHref(e);
+    buffer.append(scrubEventAttributes(e, { doc, resolveNode: (id) => record.mirror.getNode(id) }));
+  };
+  const startSession = () => {
+    stopRrweb = record(buildRecordOptions({
+      emit: onEmit,
+      checkoutEveryNms: budget.checkpointIntervalMs() * 2,
+      mousemoveWaitMs: appliedMousemoveWaitMs
+    }));
+    if (typeof stopRrweb === "function")
+      return true;
+    teardown();
+    return false;
+  };
+  const tracker = attachInteractions({
+    target,
+    now,
+    pointerIntervalMs: config.mousemoveWaitMs,
+    emit: (payload) => {
+      if (stopped)
+        return;
+      try {
+        record.addCustomEvent(ACTIVATION_EVENT_TAG, payload);
+      } catch {}
+    }
+  });
+  const teardown = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    if (checkpointTimer !== null) {
+      clearTimer(checkpointTimer);
+      checkpointTimer = null;
+    }
+    detachLongTasks();
+    detachLifecycle();
+    tracker.detach();
+    stopRrweb?.();
+    stopRrweb = undefined;
+    coordinator.cancel();
+    buffer.clear();
+    if (active === ownership)
+      active = null;
+  };
+  const applyBudget = () => {
+    const wait = budget.mousemoveWaitMs();
+    if (wait === appliedMousemoveWaitMs || stopped)
+      return;
+    appliedMousemoveWaitMs = wait;
+    tracker.setPointerIntervalMs(wait);
+    stopRrweb?.();
+    startSession();
+  };
+  const scheduleCheckpoint = () => {
+    if (stopped)
+      return;
+    checkpointTimer = setTimer(() => {
+      checkpointTimer = null;
+      if (stopped)
+        return;
+      scheduleIdle(() => {
+        if (stopped)
+          return;
+        try {
+          record.takeFullSnapshot(true);
+        } catch {}
+      });
+      budget.maybeRecover();
+      applyBudget();
+      scheduleCheckpoint();
+    }, budget.checkpointIntervalMs());
+  };
+  const started = startSession();
+  const onPageHidden = () => {
+    if (stopped)
+      return;
+    coordinator.flushNow(true);
+    const current = buffer.currentSegment();
+    if (current) {
+      const unchanged = lastUnloadShip !== null && lastUnloadShip.startedAt === current.startedAt && lastUnloadShip.eventCount === current.events.length;
+      if (!unchanged) {
+        lastUnloadShip = { startedAt: current.startedAt, eventCount: current.events.length };
+        coordinator.checkpoint(current.events, current.startedAt, true);
+      }
+    }
+  };
+  const onVisibilityChange = () => {
+    if (doc.visibilityState !== "hidden")
+      return;
+    onPageHidden();
+  };
+  const attachLifecycle = () => {
+    if (typeof lifecycleTarget?.addEventListener !== "function")
+      return noop;
+    lifecycleTarget.addEventListener("pagehide", onPageHidden);
+    lifecycleTarget.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      lifecycleTarget.removeEventListener("pagehide", onPageHidden);
+      lifecycleTarget.removeEventListener("visibilitychange", onVisibilityChange);
+    };
+  };
+  scheduleCheckpoint();
+  if (started) {
+    detachLongTasks = observeLongTasks(budget, applyBudget);
+    detachLifecycle = attachLifecycle();
+  }
+  return {
+    config,
+    stop() {
+      teardown();
+    },
+    trigger(source) {
+      if (stopped)
+        return;
+      coordinator.trigger(source);
+    },
+    flushNow() {
+      if (stopped)
+        return;
+      coordinator.flushNow(true);
+    },
+    stats() {
+      const s = buffer.stats();
+      return {
+        snapshots,
+        bufferBytes: s.bytes,
+        segments: s.segments,
+        interactionWork: tracker.state.work,
+        degradationLevel: budget.level()
+      };
+    }
+  };
+}
+
+// src/replay/wire.ts
+var SESSION_STORAGE_KEY = "pharos-replay-session";
+function defaultSessionStorage() {
+  try {
+    return globalThis.sessionStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveSessionId(explicit, storage) {
+  if (explicit !== undefined && explicit.length > 0)
+    return explicit;
+  try {
+    const stored = storage?.getItem(SESSION_STORAGE_KEY);
+    if (typeof stored === "string" && stored.length > 0)
+      return stored;
+  } catch {}
+  const fresh = randomSessionId();
+  try {
+    storage?.setItem(SESSION_STORAGE_KEY, fresh);
+  } catch {}
+  return fresh;
+}
+var SESSION_DROPS_KEY = "pharos-replay-drops";
+function readCarriedDrops(storage, sessionId) {
+  try {
+    const raw = storage?.getItem(SESSION_DROPS_KEY);
+    if (typeof raw !== "string" || raw.length === 0)
+      return 0;
+    const parsed = JSON.parse(raw);
+    if (parsed === null || parsed.sessionId !== sessionId)
+      return 0;
+    const n = parsed.total;
+    if (typeof n !== "number" || !Number.isFinite(n) || n < 0)
+      return 0;
+    return Math.floor(n);
+  } catch {
+    return 0;
+  }
+}
+function createDurableDropLedger(storage, sessionId) {
+  const inner = createDropLedger();
+  let carried = readCarriedDrops(storage, sessionId);
+  const writeThrough = () => {
+    try {
+      storage?.setItem(SESSION_DROPS_KEY, JSON.stringify({ sessionId, total: carried + inner.total() }));
+    } catch {}
+  };
+  return {
+    note(reason) {
+      inner.note(reason);
+      writeThrough();
+    },
+    total: () => carried + inner.total(),
+    byReason: () => inner.byReason(),
+    reset() {
+      inner.reset();
+      carried = 0;
+      try {
+        storage?.removeItem(SESSION_DROPS_KEY);
+      } catch {}
+    }
+  };
+}
+function startReplayUpload(opts) {
+  const {
+    sessionId: explicitSessionId,
+    compress,
+    endpoint,
+    appKey,
+    fetchImpl,
+    indexedDB: injectedIdb,
+    sessionStorage: injectedStorage,
+    ...recorderOptions
+  } = opts;
+  const storage = injectedStorage === undefined ? defaultSessionStorage() : injectedStorage;
+  const sessionId = resolveSessionId(explicitSessionId, storage);
+  const drops = createDurableDropLedger(storage, sessionId);
+  const target = { endpoint, appKey, ...fetchImpl ? { fetchImpl } : {} };
+  const now = opts.now ?? (() => Date.now());
+  const doc = opts.doc ?? globalThis.document;
+  const lifecycleTarget = opts.lifecycleTarget ?? opts.doc?.defaultView ?? globalThis;
+  let stopped = false;
+  const inflight = new Set;
+  const track = (p) => {
+    const settledP = p.catch(() => {
+      return;
+    });
+    inflight.add(settledP);
+    settledP.then(() => {
+      inflight.delete(settledP);
+    });
+  };
+  const drainInflight = async () => {
+    while (inflight.size > 0)
+      await Promise.all([...inflight]);
+  };
+  const idb = () => {
+    if (injectedIdb)
+      return injectedIdb;
+    try {
+      return globalThis.indexedDB ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const uploadSink = createUploadSink({
+    endpoint,
+    appKey,
+    ...fetchImpl ? { fetchImpl } : {},
+    ...compress !== undefined ? { compress } : {},
+    sessionId,
+    drops,
+    track,
+    onDeliveryFailure: (window) => persistForLater(window)
+  });
+  const persistForLater = async (window) => {
+    let handingToStorage = false;
+    try {
+      const factory = idb();
+      if (!factory) {
+        drops.note("storage");
+        return;
+      }
+      const { body, compressed } = await encodeForUpload(window, compress);
+      if (stopped)
+        return;
+      if (body.byteLength > MAX_WINDOW_BYTES) {
+        drops.note("oversized");
+        return;
+      }
+      handingToStorage = true;
+      await persistWindow(body, envelopeMetaFor(window, sessionId, compressed, drops.total()), now, factory, drops);
+    } catch (err) {
+      if (!handingToStorage)
+        drops.note("delivery");
+      else if (isQuotaExceeded(err))
+        drops.note("quota");
+      else
+        drops.note("storage");
+    }
+  };
+  const sendPersisted = async (body, meta) => {
+    return await postEnvelope(body, meta, target);
+  };
+  const sink = (window) => {
+    if (stopped)
+      return;
+    if (window.trigger.unloaded) {
+      track(persistForLater(window));
+      return;
+    }
+    uploadSink(window);
+  };
+  let draining = false;
+  const drainNow = () => {
+    if (stopped || draining)
+      return;
+    const factory = idb();
+    if (!factory)
+      return;
+    draining = true;
+    track(drainPersisted(sendPersisted, now, factory).finally(() => {
+      draining = false;
+    }));
+  };
+  const onVisible = () => {
+    if (stopped)
+      return;
+    if (doc?.visibilityState === "hidden")
+      return;
+    drainNow();
+  };
+  const attachDrainOnVisible = () => {
+    if (typeof lifecycleTarget?.addEventListener !== "function")
+      return () => {
+        return;
+      };
+    lifecycleTarget.addEventListener("visibilitychange", onVisible);
+    return () => {
+      lifecycleTarget.removeEventListener("visibilitychange", onVisible);
+    };
+  };
+  const onOnline = () => {
+    if (stopped)
+      return;
+    drainNow();
+  };
+  const attachDrainOnOnline = () => {
+    if (typeof lifecycleTarget?.addEventListener !== "function")
+      return () => {
+        return;
+      };
+    lifecycleTarget.addEventListener("online", onOnline);
+    return () => {
+      lifecycleTarget.removeEventListener("online", onOnline);
+    };
+  };
+  const handle = startRecording({
+    ...recorderOptions,
+    sink,
+    onWindowDropped: (reason) => {
+      drops.note(reason);
+    }
+  });
+  drainNow();
+  const detachDrainOnVisible = attachDrainOnVisible();
+  const detachDrainOnOnline = attachDrainOnOnline();
+  return {
+    get config() {
+      return handle.config;
+    },
+    sessionId,
+    drops: () => drops,
+    settled: drainInflight,
+    trigger: (source) => handle.trigger(source),
+    flushNow: () => handle.flushNow(),
+    stats: () => handle.stats(),
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      handle.stop();
+      detachDrainOnVisible();
+      detachDrainOnOnline();
+      const already = [...inflight];
+      track((async () => {
+        await Promise.all(already);
+        const f = idb();
+        if (f)
+          await clearPersisted(f);
+        drops.reset();
+        resetQuotaDroppedWindows();
+        try {
+          storage?.removeItem(SESSION_STORAGE_KEY);
+        } catch {}
+      })());
+    }
+  };
+}
+export {
+  SESSION_DROPS_KEY,
+  SESSION_STORAGE_KEY,
+  resolveSessionId,
+  startReplayUpload
+};