@maple-dev/browser 0.11.1 → 0.13.0

package/dist/replay-session-BuUOwHnI.mjs

@@ -0,0 +1,906 @@
+import { B as withStartedTraceId, F as BLOCK_SELECTOR, I as safeEmit, L as truncateText, N as warnDropped, O as postSessionBlob, R as activeTraceId, T as gzipStored, U as consentRevokedAt, X as scrubUrl, Y as isJsonObject, Z as mayUseStorage, _ as markReplayTriggered, b as patchMethod, d as startEventSink, g as markReplayHalted, h as markActivity, j as reserveKeepalive, k as postSessionMeta, m as isReplayHalted, n as getObservedTraceIds, o as startSessionLifecycle, r as publishSessionSink, v as nextChunkSeq, w as gzip } from "./sink-Ji0J42ul.mjs";
+import { b as clearPendingChunk, y as PENDING_CHUNK_KEY } from "./src-JUynR8Jc.mjs";
+import { t as installConsoleCapture } from "./console-iNhlufZV.mjs";
+import { record } from "rrweb";
+//#region ../browser-session/src/replay/capture/network.ts
+/** Only text is worth keeping; a body that is an image or a stream is not read. */
+const TEXT_CONTENT = /^(text\/|application\/(json|xml|x-www-form-urlencoded|[\w.+-]+\+(json|xml)))/i;
+/** Text, but never finished: reading a clone would hold the connection open after the app cancels. */
+const STREAMING_CONTENT = /^text\/event-stream/i;
+/** A slow body is given up on rather than kept in memory for as long as it trickles. */
+const BODY_READ_TIMEOUT_MS = 5e3;
+const isReadableText = (contentType) => TEXT_CONTENT.test(contentType) && !STREAMING_CONTENT.test(contentType);
+/** Patterns match the full URL, as documented: a relative `fetch("/api")` is resolved against the page. */
+const absoluteUrl = (url) => {
+	try {
+		return new URL(url, location.href).href;
+	} catch {
+		return url;
+	}
+};
+const matchesUrl = (url, patterns) => patterns.some((pattern) => {
+	if (typeof pattern === "string") return url.includes(pattern);
+	if (!(pattern instanceof RegExp)) return false;
+	pattern.lastIndex = 0;
+	return pattern.test(url);
+});
+/**
+* JSON keys and form fields whose values are credentials whatever the app
+* calls them: tokens, secrets, passwords, API keys, cookies, auth headers.
+*/
+const CREDENTIAL_KEY = /token|secret|pass(word|wd|phrase|code)|(^|[-_])(pwd|pass)([-_]|$)|authori[sz]ation|(^|[-_])auth([-_]|$)|api[-_]?key|cookie|credential|private[-_]?key|access[-_]?key|(^|[-_])(otp|cvv|cvc|ssn)([-_]|$)|card[-_]?number/i;
+/** A JSON member: a string key and its string (possibly cut off) or bare value. */
+const JSON_MEMBER = /"((?:[^"\\]|\\.)*)"(\s*:\s*)("(?:[^"\\]|\\.)*"?|[^\s,}\]"{[]+)/g;
+/** A form field: `key=value`, at the start or after `&`. */
+const FORM_FIELD = /(^|&)([^=&]*)=([^&]*)/g;
+const REDACTED = "[REDACTED]";
+/**
+* Blank the values of credential-looking keys in a JSON or form body. Works on
+* a prefix too: a body cut mid-value still loses the value.
+*/
+function redactCredentials(body) {
+	return redactJson(body) ?? redactText(body);
+}
+/** The text passes: JSON members and form fields, on a whole body or one string value. */
+function redactText(body) {
+	return body.replace(JSON_MEMBER, (member, key, colon) => CREDENTIAL_KEY.test(key) ? `"${key}"${colon}"${REDACTED}"` : member).replace(FORM_FIELD, (field, lead, key) => CREDENTIAL_KEY.test(safeDecode(key)) ? `${lead}${key}=${REDACTED}` : field);
+}
+/**
+* A whole JSON body, walked: a credential key loses its value even when that
+* value is an object or array, which the member regex cannot see into.
+*/
+function redactJson(body) {
+	if (body.length > 1048576) return void 0;
+	const start = body.trimStart()[0];
+	if (start !== "{" && start !== "[") return void 0;
+	try {
+		return JSON.stringify(JSON.parse(body, (key, value) => key !== "" && CREDENTIAL_KEY.test(key) ? REDACTED : typeof value === "string" ? redactText(value) : value));
+	} catch {
+		return;
+	}
+}
+function safeDecode(text) {
+	try {
+		return decodeURIComponent(text.replace(/\+/g, " "));
+	} catch {
+		return text;
+	}
+}
+const cut = (text, maxLength) => truncateText(redactCredentials(text), maxLength, "…");
+/**
+* Capture fetch + XHR requests as session events, tagged with the active trace
+* id so each request links to its backend trace. `ignoreUrl` skips Maple's own
+* ingest endpoints (otherwise capturing the session-events POST would loop).
+* `bodies`, when set, keeps text request/response bodies of the URLs it lists,
+* with credential-looking values blanked.
+*
+* Teardown leaves a wrapper something else installed on top of in place, inert
+* (see `patchMethod`), so an app's own interceptor keeps working.
+*/
+function installNetworkCapture(emit, ignoreUrl, bodies) {
+	const hooks = {
+		wantsBody: (url) => bodies !== void 0 && matchesUrl(absoluteUrl(url), bodies.urls),
+		bodyAttrs: (request, response) => ({
+			...request && bodies?.requestBodies !== false ? { "request.body": cut(request, bodies?.maxLength ?? 0) } : void 0,
+			...response && bodies ? { "response.body": cut(response, bodies.maxLength) } : void 0
+		}),
+		maxLength: bodies?.maxLength ?? 0,
+		record: (url, method, status, start, traceId, error, extra, end = performance.now()) => {
+			if (ignoreUrl(url)) return;
+			const attrs = {
+				...extra,
+				...error ? { error } : void 0
+			};
+			safeEmit(emit, {
+				type: "network",
+				net: {
+					method,
+					url,
+					status,
+					durationMs: Math.round(end - start)
+				},
+				traceId,
+				...Object.keys(attrs).length > 0 ? { attrs } : void 0
+			});
+		}
+	};
+	if (typeof window === "undefined") return () => {};
+	const uninstall = [];
+	if (typeof window.fetch === "function") uninstall.push(patchMethod(window, "fetch", hooks, wrapFetch));
+	const XHR = window.XMLHttpRequest;
+	if (XHR && typeof XHR.prototype.open === "function" && typeof XHR.prototype.send === "function") {
+		uninstall.push(patchMethod(XHR.prototype, "open", hooks, wrapXhrOpen));
+		uninstall.push(patchMethod(XHR.prototype, "send", hooks, wrapXhrSend));
+	}
+	return () => {
+		for (const off of uninstall) off();
+	};
+}
+function wrapFetch(original, hooks) {
+	return async (input, init) => {
+		const live = hooks();
+		if (!live) return original(input, init);
+		const url = requestUrl(input);
+		const method = requestMethod(input, init);
+		const ambientTraceId = activeTraceId();
+		const start = performance.now();
+		let traceId = ambientTraceId;
+		try {
+			const call = withStartedTraceId(() => original(input, init));
+			traceId = call.traceId ?? ambientTraceId;
+			const res = await call.result;
+			if (!live.wantsBody(url)) {
+				live.record(url, method, res.status, start, traceId);
+				return res;
+			}
+			const requestBody = typeof init?.body === "string" ? init.body : void 0;
+			const done = performance.now();
+			const contentType = res.headers.get("content-type") ?? "";
+			(isReadableText(contentType) ? readPrefix(res.clone(), live.maxLength) : Promise.resolve(void 0)).catch(() => void 0).then((responseBody) => live.record(url, method, res.status, start, traceId, void 0, live.bodyAttrs(requestBody, responseBody), done));
+			return res;
+		} catch (error) {
+			live.record(url, method, 0, start, traceId, String(error));
+			throw error;
+		}
+	};
+}
+function wrapXhrOpen(original, hooks) {
+	return function(method, url, ...rest) {
+		const call = () => original.apply(this, [
+			method,
+			url,
+			...rest
+		]);
+		if (!hooks()) return call();
+		const meta = xhrMeta(this);
+		meta.__mapleMethod = String(method).toUpperCase();
+		meta.__mapleUrl = String(url);
+		const started = withStartedTraceId(call);
+		meta.__mapleTraceId = started.traceId;
+		return started.result;
+	};
+}
+function wrapXhrSend(original, hooks) {
+	return function(...args) {
+		const live = hooks();
+		if (!live) return original.apply(this, args);
+		const meta = xhrMeta(this);
+		const start = performance.now();
+		let traceId = meta.__mapleTraceId ?? activeTraceId();
+		const url = meta.__mapleUrl ?? "";
+		const requestBody = typeof args[0] === "string" ? args[0] : void 0;
+		this.addEventListener("loadend", () => {
+			const extra = live.wantsBody(url) ? live.bodyAttrs(requestBody, xhrResponseText(this)) : void 0;
+			live.record(url, meta.__mapleMethod ?? "GET", this.status, start, traceId, void 0, extra);
+		});
+		const call = withStartedTraceId(() => original.apply(this, args));
+		traceId = call.traceId ?? traceId;
+		return call.result;
+	};
+}
+/**
+* Up to `maxLength` characters of a response body (one more, so `cut` marks it
+* cut), then the stream is cancelled: a large payload is never read in full.
+*/
+async function readPrefix(response, maxLength) {
+	const reader = response.body?.getReader();
+	if (!reader) return void 0;
+	const decoder = new TextDecoder();
+	let text = "";
+	const deadline = Date.now() + BODY_READ_TIMEOUT_MS;
+	while (text.length <= maxLength) {
+		const remaining = deadline - Date.now();
+		const chunk = remaining > 0 ? await readWithin(reader, remaining) : void 0;
+		if (!chunk) {
+			reader.cancel().catch(() => {});
+			return text || void 0;
+		}
+		if (chunk.done) return text + decoder.decode();
+		text += decoder.decode(chunk.value, { stream: true });
+	}
+	reader.cancel().catch(() => {});
+	return text;
+}
+/** One read, or `undefined` if nothing arrives within `ms`. */
+function readWithin(reader, ms) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(void 0), ms);
+	});
+	return Promise.race([reader.read(), timeout]).finally(() => clearTimeout(timer));
+}
+/** A text or JSON XHR response, as text; the browser already holds it, so this only slices. */
+function xhrResponseText(xhr) {
+	if (!isReadableText(xhr.getResponseHeader("content-type") ?? "")) return void 0;
+	if (xhr.responseType === "" || xhr.responseType === "text") return xhr.responseText;
+	if (xhr.responseType === "json") try {
+		return JSON.stringify(xhr.response);
+	} catch {
+		return;
+	}
+}
+/** The request with the fields capture keeps on it; all optional, so any request is one. */
+const xhrMeta = (xhr) => xhr;
+function requestUrl(input) {
+	if (typeof input === "string") return input;
+	if (input instanceof URL) return input.href;
+	return input.url;
+}
+function requestMethod(input, init) {
+	return (init?.method ?? (typeof input === "object" && "method" in input ? input.method : void 0) ?? "GET").toUpperCase();
+}
+//#endregion
+//#region ../browser-session/src/replay/events.ts
+/**
+* Install the capture modules that turn console output and network requests
+* into distilled session events.
+*
+* Navigation, errors and interactions are deliberately absent: the sink
+* installs those itself (see `startBaselineCapture`), because page views, error
+* counts and click counts have to be counted even when replay is unsampled —
+* and a second listener here would double-count every one of them.
+*/
+function startEventCapture(config, sessionId) {
+	const sink = startEventSink(config, sessionId);
+	const emit = sink.emit;
+	const uninstall = [installConsoleCapture(emit, { maskText: config.maskAllText }), installNetworkCapture(emit, sink.ignoreUrl, config.maskAllText || !config.networkBodies ? void 0 : {
+		...config.networkBodies,
+		requestBodies: !config.maskAllInputs
+	})];
+	return {
+		stop: () => {
+			for (const off of uninstall) off();
+		},
+		flush: sink.flush
+	};
+}
+//#endregion
+//#region ../browser-session/src/replay/record.ts
+function isRrwebEvent(value) {
+	return isJsonObject(value) && typeof value.type === "number" && typeof value.timestamp === "number";
+}
+const FULL_SNAPSHOT = 2;
+const META = 4;
+const INCREMENTAL = 3;
+const SOURCE_MOUSE_INTERACTION = 2;
+const MOUSE_CLICK = 2;
+/**
+* IncrementalSource values only a person produces: MouseMove, MouseInteraction,
+* Scroll, Input, TouchMove, Drag. Mutations, console and network are not
+* activity: a polling dashboard nobody looks at must still go idle.
+*/
+const USER_INPUT_SOURCES = /* @__PURE__ */ new Set([
+	1,
+	2,
+	3,
+	5,
+	6,
+	12
+]);
+const FLUSH_INTERVAL_MS = 5e3;
+const FLUSH_BYTES = 102400;
+const CHECKOUT_EVERY_MS = 3e5;
+const MAX_BUFFER_BYTES = 4194304;
+/** Ceiling on chunk bodies still uploading; a slow network otherwise holds every flush in memory. */
+const MAX_INFLIGHT_BYTES = 2097152;
+/** A lost chunk is repaired with a fresh snapshot, at most this often: each one stalls the main thread. */
+const MIN_RESNAPSHOT_MS = 1e4;
+/** Pause after ingest asks for a retry (429, 5xx), doubling per answer in a row up to the cap. */
+const RETRY_BACKOFF_MS = 5e3;
+const MAX_RETRY_BACKOFF_MS = 6e4;
+/** Snapshots over the buffer cap before recording gives up on the session's DOM. */
+const MAX_OVERSIZED_SNAPSHOTS = 3;
+function warnExhausted(sessionId) {
+	console.warn(`[maple] session replay ${sessionId} reached its maximum recorded size; recording stopped for this session (metadata and events continue)`);
+}
+function warnOversized(sessionId) {
+	console.warn(`[maple] session replay ${sessionId} stopped: the page's DOM snapshot is larger than ${MAX_BUFFER_BYTES} bytes (metadata and events continue)`);
+}
+let lastDropWarnAt = 0;
+function warnBufferDropped(bytes, limit) {
+	const now = Date.now();
+	if (now - lastDropWarnAt < 3e4) return;
+	lastDropWarnAt = now;
+	console.warn(`[maple] session replay buffer exceeded ${limit} bytes (dropping ${bytes} buffered bytes; recording continues from the next full snapshot)`);
+}
+/** Whether a person produced `event`: only that keeps a session from going idle. */
+function isUserInput(event) {
+	if (event.type !== INCREMENTAL || !isJsonObject(event.data)) return false;
+	const source = event.data.source;
+	return typeof source === "number" && USER_INPUT_SOURCES.has(source);
+}
+function isClick(event) {
+	return event.type === INCREMENTAL && isJsonObject(event.data) && event.data.source === SOURCE_MOUSE_INTERACTION && event.data.type === MOUSE_CLICK;
+}
+/** The meta event carries the page URL the player shows in its address bar. */
+function scrubMetaHref(event) {
+	if (event.type === META && isJsonObject(event.data) && typeof event.data.href === "string") event.data.href = scrubUrl(event.data.href);
+}
+/**
+* Whether `event` belongs to `sessionId`. User input resolves idle rotation
+* (the rotation listener stops this recorder and starts the next one, so the
+* event that discovered it is left out); anything else is kept only while the
+* session is live, so it neither revives nor rotates an idle one. The answer
+* for passive events is reused for a second: mutations arrive in bursts.
+*/
+function sessionGate(sessionId) {
+	let checkedAt = Number.NEGATIVE_INFINITY;
+	let live = true;
+	return (event) => {
+		if (isUserInput(event)) {
+			const active = markActivity("input");
+			checkedAt = Number.NEGATIVE_INFINITY;
+			return !active || active.id === sessionId;
+		}
+		const now = Date.now();
+		if (now - checkedAt >= 1e3) {
+			checkedAt = now;
+			const stored = markActivity("passive");
+			live = stored === void 0 || stored?.id === sessionId;
+		}
+		return live;
+	};
+}
+/** Input types rrweb consults `maskInputFn` for. `select` only when masking all: it also hides the selection. */
+const MASKABLE_INPUTS = [
+	"color",
+	"date",
+	"datetime-local",
+	"email",
+	"month",
+	"number",
+	"range",
+	"search",
+	"tel",
+	"text",
+	"time",
+	"url",
+	"week",
+	"textarea",
+	"password",
+	"hidden"
+];
+/** Autocomplete tokens of fields masked whatever `maskAllInputs` says. */
+const SECRET_AUTOCOMPLETE = /^(cc-.+|one-time-code|current-password|new-password)$/;
+/**
+* Whether an input's value is a secret on any page: passwords, hidden inputs
+* (CSRF tokens, OAuth state) and card or one-time-code fields. rrweb masks
+* only `type=password` on its own, and not even hidden inputs under `maskAllInputs`.
+*/
+function isSecretInput(element) {
+	const type = ("type" in element && typeof element.type === "string" ? element.type : "").toLowerCase();
+	if (type === "password" || type === "hidden") return true;
+	if (element.hasAttribute("data-rr-is-password")) return true;
+	return (element.getAttribute("autocomplete") ?? "").toLowerCase().split(/\s+/).some((token) => SECRET_AUTOCOMPLETE.test(token));
+}
+/** rrweb input masking: everything under `maskAllInputs`, otherwise only secrets. */
+function inputMaskOptions(config) {
+	const maskInputOptions = {};
+	for (const type of MASKABLE_INPUTS) maskInputOptions[type] = true;
+	if (config.maskAllInputs) maskInputOptions.select = true;
+	return {
+		maskInputOptions,
+		maskInputFn: (text, element) => config.maskAllInputs || isSecretInput(element) ? "*".repeat(text.length) : text
+	};
+}
+/** rrweb options shared by both recorders. */
+function recordOptions(config) {
+	return {
+		...inputMaskOptions(config),
+		blockSelector: BLOCK_SELECTOR,
+		...config.maskAllText ? { maskTextSelector: "*" } : void 0,
+		errorHandler: (error) => {
+			warnDropped("replay recording", error);
+			return true;
+		},
+		...canvasOptions(config)
+	};
+}
+const MAX_PENDING_AGE_MS = 6e5;
+const PAGE_STARTED_AT = Date.now();
+/** How long a stored chunk that found the keepalive budget full waits before its one re-attempt. */
+const KEEPALIVE_RETRY_MS = 1e3;
+function isPendingChunk(value) {
+	return isJsonObject(value) && typeof value.sessionId === "string" && typeof value.chunkSeq === "number" && typeof value.isCheckpoint === "boolean" && typeof value.eventCount === "number" && typeof value.durationMs === "number" && typeof value.body === "string" && typeof value.createdAt === "number" && typeof value.target === "string";
+}
+/** Endpoint plus an FNV-1a hash of the key, so the key itself is not stored. */
+function targetOf(config) {
+	let hash = 2166136261;
+	for (const char of config.ingestKey ?? "") hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+	return `${config.endpoint}|${hash >>> 0}`;
+}
+function readPending() {
+	if (!mayUseStorage()) return void 0;
+	try {
+		const parsed = JSON.parse(window.sessionStorage.getItem("maple.replay.pending") ?? "null");
+		return isPendingChunk(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Keep `chunk` unless one is already waiting. False when it was not kept
+* (storage blocked or full): it is then only as durable as its upload.
+*/
+function storePending(chunk) {
+	if (!mayUseStorage()) return false;
+	try {
+		if (readPending()) return false;
+		window.sessionStorage.setItem(PENDING_CHUNK_KEY, JSON.stringify(chunk));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Remove the stored chunk if it is `meta`'s, reporting whether it was. Whoever
+* removes it sends it, so a seq is posted once: ingest appends an index row per POST.
+*/
+function takePending(meta) {
+	const chunk = readPending();
+	return chunk?.sessionId === meta.sessionId && chunk.chunkSeq === meta.chunkSeq && clearPendingChunk();
+}
+/** Send the chunk an earlier flush left behind, if it is still this recorder's to send; otherwise drop it. */
+function sendPendingChunk(config, sessionId) {
+	const chunk = readPending();
+	if (!chunk) return;
+	if (chunk.target === targetOf(config) && chunk.createdAt > consentRevokedAt() && (chunk.createdAt >= PAGE_STARTED_AT || chunk.sessionId === sessionId && Date.now() - chunk.createdAt <= MAX_PENDING_AGE_MS)) compressAndPost(config, chunk, chunk.body, false, true, chunk.createdAt);
+	else clearPendingChunk();
+}
+/**
+* Claim a seq and upload one chunk. The seq is monotonic across reloads
+* (persisted on the session record), so a refresh continues the sequence
+* instead of overwriting the previous load's blobs.
+*/
+function uploadChunk(config, sessionId, body, chunk, keepalive) {
+	const chunkSeq = nextChunkSeq(sessionId);
+	if (chunkSeq === void 0) return Promise.resolve("dropped");
+	const meta = {
+		sessionId,
+		chunkSeq,
+		...chunk
+	};
+	const sentNow = keepalive ? postBeforeUnload(config, meta, body) : void 0;
+	if (sentNow) return sentNow;
+	const cutAt = Date.now();
+	return compressAndPost(config, meta, body, keepalive, keepalive && storePending({
+		...meta,
+		body,
+		createdAt: cutAt,
+		target: targetOf(config)
+	}), cutAt);
+}
+/**
+* The most of the shared keepalive budget a chunk takes on the way out, so the
+* session row, events and spans issued alongside it keep room.
+*/
+const UNLOAD_CHUNK_MAX_BYTES = 24576;
+/**
+* Post a chunk from a page that may be going away, uncompressed, before anything
+* awaits: `CompressionStream` never resolves on a document being torn down, and
+* a stored copy only reaches ingest if this tab shows the site again. Without
+* this a visit shorter than one flush interval uploaded no recording at all.
+* Undefined when the chunk is too large, which leaves it to the stored path.
+*/
+function postBeforeUnload(config, meta, body) {
+	if (body.length > UNLOAD_CHUNK_MAX_BYTES) return void 0;
+	const gzipped = gzipStored(new TextEncoder().encode(body));
+	if (gzipped.byteLength > UNLOAD_CHUNK_MAX_BYTES) return void 0;
+	const release = reserveKeepalive(true, gzipped.byteLength);
+	if (!release) return void 0;
+	release();
+	return postSessionBlob(config, meta, gzipped, true);
+}
+async function compressAndPost(config, meta, body, keepalive, stored, cutAt) {
+	let gzipped;
+	try {
+		gzipped = await gzip(new TextEncoder().encode(body));
+	} catch (error) {
+		warnDropped("chunk compression", error);
+		return "dropped";
+	}
+	if (consentRevokedAt() >= cutAt) return "handed-off";
+	if (stored) {
+		if (keepalive) {
+			const release = reserveKeepalive(true, gzipped.byteLength);
+			if (release) release();
+			else await new Promise((resolve) => setTimeout(resolve, KEEPALIVE_RETRY_MS));
+		}
+		if (!takePending(meta)) return "handed-off";
+	}
+	return postSessionBlob(config, meta, gzipped, keepalive);
+}
+const emptyBuffer = () => ({
+	parts: [],
+	types: [],
+	timestamps: [],
+	bytes: 0
+});
+function sliceBuffer(buffer, start, end = buffer.parts.length) {
+	const parts = buffer.parts.slice(start, end);
+	return {
+		parts,
+		types: buffer.types.slice(start, end),
+		timestamps: buffer.timestamps.slice(start, end),
+		bytes: parts.reduce((sum, part) => sum + part.length, 0)
+	};
+}
+const NOOP_RECORDER = {
+	stop: () => {},
+	flush: async () => {},
+	getClickCount: () => 0
+};
+function startRecording(config, sessionId) {
+	sendPendingChunk(config, sessionId);
+	if (isReplayHalted(sessionId)) return NOOP_RECORDER;
+	let buffer = emptyBuffer();
+	/** After a lost batch the stream has a gap: nothing is kept until the next snapshot's Meta. */
+	let awaitingSnapshot = false;
+	let inflightBytes = 0;
+	let oversizedSnapshots = 0;
+	let clickCount = 0;
+	let stopped = false;
+	let halted = false;
+	let resnapshotTimer;
+	let lastResnapshotAt = Number.NEGATIVE_INFINITY;
+	/** Uploads wait until then after ingest asked for a retry; the buffer keeps filling meanwhile. */
+	let retryAt = 0;
+	let retriesInARow = 0;
+	const isHidden = () => typeof document !== "undefined" && document.visibilityState === "hidden";
+	const takeResnapshot = () => {
+		resnapshotTimer = void 0;
+		if (halted || !awaitingSnapshot) return;
+		if (inflightBytes > MAX_INFLIGHT_BYTES / 2 || isHidden() || Date.now() < retryAt) {
+			resnapshotTimer = setTimeout(takeResnapshot, Math.max(MIN_RESNAPSHOT_MS, retryAt - Date.now()));
+			return;
+		}
+		lastResnapshotAt = Date.now();
+		try {
+			record.takeFullSnapshot(true);
+		} catch {}
+	};
+	/** Drop everything buffered and reopen the stream at a fresh snapshot, rate-limited. */
+	const dropAndResnapshot = () => {
+		buffer = emptyBuffer();
+		awaitingSnapshot = true;
+		if (resnapshotTimer !== void 0) return;
+		const wait = Math.max(0, lastResnapshotAt + MIN_RESNAPSHOT_MS - Date.now());
+		resnapshotTimer = setTimeout(takeResnapshot, wait);
+	};
+	/**
+	* A chunk did not reach ingest, so later incremental events would apply to
+	* nodes the player never built. Keep the buffer from its latest snapshot if
+	* it has one; otherwise drop it and take a fresh snapshot.
+	*/
+	const onChunkLost = () => {
+		if (halted || stopped) return;
+		const metaAt = buffer.types.lastIndexOf(META);
+		if (metaAt >= 0) buffer = sliceBuffer(buffer, metaAt);
+		else dropAndResnapshot();
+	};
+	const halt = (warn) => {
+		if (halted) return;
+		warn(sessionId);
+		markReplayHalted(sessionId);
+		haltCapture();
+	};
+	const flush = async (keepalive = false) => {
+		if (stopped || halted || !keepalive && Date.now() < retryAt) return;
+		const cut = buffer.types.at(-1) === META ? buffer.parts.length - 1 : buffer.parts.length;
+		if (cut === 0) return;
+		const sending = sliceBuffer(buffer, 0, cut);
+		buffer = sliceBuffer(buffer, cut);
+		const body = `[${sending.parts.join(",")}]`;
+		if (!keepalive && inflightBytes + body.length > MAX_INFLIGHT_BYTES) {
+			warnBufferDropped(body.length, MAX_INFLIGHT_BYTES);
+			dropAndResnapshot();
+			return;
+		}
+		const first = sending.timestamps[0] ?? 0;
+		const last = sending.timestamps.at(-1) ?? first;
+		inflightBytes += body.length;
+		let outcome;
+		try {
+			outcome = await uploadChunk(config, sessionId, body, {
+				isCheckpoint: sending.types.includes(FULL_SNAPSHOT),
+				eventCount: sending.parts.length,
+				durationMs: Math.max(0, last - first)
+			}, keepalive);
+		} finally {
+			inflightBytes -= body.length;
+		}
+		if (outcome === "accepted") retriesInARow = 0;
+		else if (outcome !== "handed-off" && outcome !== "refused" && outcome !== "exhausted") {
+			retriesInARow++;
+			retryAt = Date.now() + Math.min(MAX_RETRY_BACKOFF_MS, RETRY_BACKOFF_MS * 2 ** (retriesInARow - 1));
+		}
+		if (outcome === "refused") haltCapture();
+		else if (outcome === "exhausted") halt(warnExhausted);
+		else if (outcome !== "accepted" && outcome !== "handed-off") onChunkLost();
+	};
+	let haltCapture = () => {};
+	const belongs = sessionGate(sessionId);
+	const stop = record({
+		emit: (event) => {
+			if (!isRrwebEvent(event) || !belongs(event)) return;
+			scrubMetaHref(event);
+			if (isClick(event)) clickCount++;
+			let json;
+			try {
+				json = JSON.stringify(event);
+			} catch {
+				return;
+			}
+			if (awaitingSnapshot && event.type !== META) return;
+			awaitingSnapshot = false;
+			if (buffer.bytes + json.length > MAX_BUFFER_BYTES) {
+				warnBufferDropped(buffer.bytes + json.length, MAX_BUFFER_BYTES);
+				if (event.type !== FULL_SNAPSHOT) {
+					dropAndResnapshot();
+					return;
+				}
+				buffer = emptyBuffer();
+				awaitingSnapshot = true;
+				oversizedSnapshots++;
+				if (oversizedSnapshots >= MAX_OVERSIZED_SNAPSHOTS) halt(warnOversized);
+				return;
+			}
+			buffer.parts.push(json);
+			buffer.types.push(event.type);
+			buffer.timestamps.push(event.timestamp);
+			buffer.bytes += json.length;
+			if (buffer.bytes >= FLUSH_BYTES && event.type !== META) flush();
+		},
+		...recordOptions(config),
+		checkoutEveryNms: CHECKOUT_EVERY_MS
+	});
+	let idleHandle;
+	const scheduleFlush = () => {
+		if (isHidden()) return;
+		if (typeof requestIdleCallback === "function") idleHandle = requestIdleCallback(() => {
+			idleHandle = void 0;
+			flush();
+		}, { timeout: 2e3 });
+		else flush();
+	};
+	const flushTimer = setInterval(scheduleFlush, FLUSH_INTERVAL_MS);
+	haltCapture = () => {
+		if (halted) return;
+		halted = true;
+		clearInterval(flushTimer);
+		if (resnapshotTimer !== void 0) clearTimeout(resnapshotTimer);
+		resnapshotTimer = void 0;
+		if (idleHandle !== void 0 && typeof cancelIdleCallback === "function") {
+			cancelIdleCallback(idleHandle);
+			idleHandle = void 0;
+		}
+		buffer = emptyBuffer();
+		stop?.();
+	};
+	return {
+		stop: () => {
+			stopped = true;
+			haltCapture();
+		},
+		flush,
+		getClickCount: () => clickCount
+	};
+}
+/** rrweb options for `<canvas>` capture: sampled frames as WebP, off unless asked for. */
+function canvasOptions(config) {
+	if (config.maskAllText || !config.canvasFps || config.canvasFps <= 0) return void 0;
+	return {
+		recordCanvas: true,
+		sampling: { canvas: config.canvasFps },
+		dataURLOptions: {
+			type: "image/webp",
+			quality: .6
+		}
+	};
+}
+/**
+* Buffer mode checks out often, so the retained window stays near a minute. A
+* checkout is a full DOM snapshot, so it is skipped while hidden or when nothing changed.
+*/
+const BUFFER_CHECKOUT_MS = 3e4;
+const NOOP_BUFFERED = {
+	drain: async () => {},
+	stop: () => {},
+	getClickCount: () => 0
+};
+/**
+* Record into memory only: the segments since the second-to-last checkout, so
+* 30-60s of replay, and nothing is uploaded until `drain()`. For sessions that
+* keep a replay only when an error happens.
+*/
+function startBufferedRecording(config, sessionId) {
+	if (isReplayHalted(sessionId)) return NOOP_BUFFERED;
+	let segments = [];
+	let bytes = 0;
+	let clickCount = 0;
+	let stopped = false;
+	let oversizedSnapshots = 0;
+	/** Incremental events since the last snapshot: an idle page needs no new one. */
+	let changedSinceSnapshot = 0;
+	const belongs = sessionGate(sessionId);
+	let stopRecord;
+	const stop = () => {
+		stopped = true;
+		clearInterval(checkoutTimer);
+		segments = [];
+		bytes = 0;
+		stopRecord?.();
+	};
+	stopRecord = record({
+		emit: (event) => {
+			if (stopped || !isRrwebEvent(event) || !belongs(event)) return;
+			scrubMetaHref(event);
+			if (isClick(event)) clickCount++;
+			let json;
+			try {
+				json = JSON.stringify(event);
+			} catch {
+				return;
+			}
+			if (event.type === META) {
+				segments.push({
+					parts: [],
+					bytes: 0,
+					first: event.timestamp,
+					last: event.timestamp,
+					playable: false
+				});
+				while (segments.length > 2) bytes -= segments.shift()?.bytes ?? 0;
+				changedSinceSnapshot = 0;
+			} else if (event.type === INCREMENTAL) changedSinceSnapshot++;
+			const segment = segments.at(-1);
+			if (!segment) return;
+			if (event.type === FULL_SNAPSHOT) {
+				segment.playable = segment.parts.length === 1;
+				if (json.length > MAX_BUFFER_BYTES && ++oversizedSnapshots >= MAX_OVERSIZED_SNAPSHOTS) {
+					warnOversized(sessionId);
+					markReplayHalted(sessionId);
+					stop();
+					return;
+				}
+			}
+			segment.parts.push(json);
+			segment.bytes += json.length;
+			segment.last = event.timestamp;
+			bytes += json.length;
+			while (bytes > MAX_BUFFER_BYTES && segments.length > 0) bytes -= segments.shift()?.bytes ?? 0;
+		},
+		...recordOptions(config)
+	});
+	const checkoutTimer = setInterval(() => {
+		if (stopped || changedSinceSnapshot === 0) return;
+		const current = segments.at(-1);
+		if (!(current === void 0 || current.bytes > MAX_BUFFER_BYTES / 2) && typeof document !== "undefined" && document.visibilityState === "hidden") return;
+		try {
+			record.takeFullSnapshot(true);
+		} catch {}
+	}, BUFFER_CHECKOUT_MS);
+	return {
+		drain: async (keepalive = false) => {
+			const pending = segments.filter((segment) => segment.playable);
+			segments = [];
+			bytes = 0;
+			if (stopped) return;
+			if ((await Promise.all(pending.map((segment) => uploadChunk(config, sessionId, `[${segment.parts.join(",")}]`, {
+				isCheckpoint: true,
+				eventCount: segment.parts.length,
+				durationMs: Math.max(0, segment.last - segment.first)
+			}, keepalive)))).includes("exhausted")) {
+				warnExhausted(sessionId);
+				markReplayHalted(sessionId);
+			}
+		},
+		stop,
+		getClickCount: () => clickCount
+	};
+}
+//#endregion
+//#region ../browser-session/src/session/replay-session.ts
+/**
+* Start recording the current browser session. Publishes the session sink,
+* posts an `active` metadata row, and installs visibility handlers:
+* hidden → flush + `ended` row (with observed trace ids), capture kept running;
+* visible → re-resolve the session (rotating if idle-expired, which restarts
+* capture under the new id) and post a fresh `active` row. `pagehide`, consent
+* revoke and a tab hidden past the idle timeout stop capture. Metadata versions
+* are monotonic per session, so the latest row always wins on the backend.
+*
+* Returns undefined outside a browser. Sampling is the caller's decision.
+*/
+function startReplaySession(options) {
+	if (typeof window === "undefined") return void 0;
+	const engineConfig = {
+		endpoint: options.endpoint.replace(/\/$/, ""),
+		ingestKey: options.ingestKey,
+		sdk: options.sdk,
+		maskAllInputs: options.maskAllInputs,
+		maskAllText: options.maskAllText,
+		getIdentity: options.getIdentity,
+		canvasFps: options.canvasFps,
+		networkBodies: options.networkBodies
+	};
+	let recorder;
+	let buffered;
+	let events;
+	let publishedSessionId;
+	const buffering = options.mode === "buffer";
+	let triggered = !buffering;
+	/** Clicks the buffered recorder saw before a trigger replaced it. */
+	let clicksBeforeTrigger = 0;
+	const publish = (sessionId) => {
+		if (publishedSessionId === sessionId) return;
+		publishedSessionId = sessionId;
+		publishSessionSink(sessionId);
+	};
+	const startStreaming = (sessionId) => {
+		recorder = startRecording(engineConfig, sessionId);
+		events = startEventCapture(engineConfig, sessionId);
+	};
+	const lifecycle = startSessionLifecycle({
+		...options,
+		getTraceIds: getObservedTraceIds
+	}, {
+		recorded: () => triggered,
+		buffered: () => buffering,
+		post: (row, keepalive) => {
+			postSessionMeta(engineConfig, row, keepalive);
+		},
+		clicksSinceStart: () => clicksBeforeTrigger + (recorder?.getClickCount() ?? buffered?.getClickCount() ?? 0),
+		onStart: (record) => {
+			publish(record.id);
+			clicksBeforeTrigger = 0;
+			if (triggered) startStreaming(record.id);
+			else buffered = startBufferedRecording(engineConfig, record.id);
+		},
+		onSuspend: ({ flush, keepalive }) => {
+			const stoppingRecorder = recorder;
+			const stoppingEvents = events;
+			recorder = void 0;
+			events = void 0;
+			buffered?.stop();
+			buffered = void 0;
+			const flushed = flush ? Promise.all([stoppingRecorder?.flush(keepalive), stoppingEvents?.flush(keepalive)]).then(() => {}) : void 0;
+			stoppingRecorder?.stop();
+			stoppingEvents?.stop();
+			return flushed;
+		},
+		onPause: async ({ keepalive }) => {
+			await Promise.all([recorder?.flush(keepalive), events?.flush(keepalive)]);
+		},
+		onSessionChange: (sessionId) => {
+			triggered = !buffering;
+			publish(sessionId);
+			options.onSessionChange?.(sessionId);
+		}
+	});
+	if (!lifecycle) return void 0;
+	return {
+		get sessionId() {
+			return lifecycle.sessionId;
+		},
+		announce: lifecycle.announce,
+		shutdown: lifecycle.shutdown,
+		trigger: async () => {
+			if (triggered) return;
+			triggered = true;
+			const sessionId = lifecycle.sessionId;
+			markReplayTriggered(sessionId);
+			const pending = buffered;
+			buffered = void 0;
+			if (!pending) return;
+			clicksBeforeTrigger = pending.getClickCount();
+			const drained = pending.drain();
+			pending.stop();
+			startStreaming(sessionId);
+			lifecycle.announce();
+			await drained;
+		}
+	};
+}
+//#endregion
+export { startReplaySession };