@faststats/web 0.13.0 → 0.13.2

package/dist/replay.js

@@ -1,10 +1,10 @@
-import { a as resolveBaseUrl, n as URLS, o as sanitizeUrl, t as sendData } from "./chunks/send-data-C76HbZ8d.js";
-import { a as touchActivity, c as setStorageItem, n as getSessionContext, o as getStorageItem, r as onSessionRotated, t as createId } from "./chunks/session-manager-DUpF3mi3.js";
-import { t as getAnonymousId } from "./chunks/identifiers-DOtve3E5.js";
+import { a as resolveBaseUrl, c as trackerExtension, n as URLS, o as sanitizeUrl, t as sendData } from "./chunks/send-data-BCVUgwry.js";
+import { a as touchActivity, n as getSessionContext, o as getStorageItem, r as onSessionRotated, s as setStorageItem, t as createId } from "./chunks/session-manager-DBWYTyfd.js";
+import { t as getAnonymousId } from "./chunks/identifiers-BHYhM7DM.js";
 import { record } from "@rrweb/record";
 import { getRecordConsolePlugin } from "@rrweb/rrweb-plugin-console-record";
 import { getRecordNetworkPlugin } from "@rrweb/rrweb-plugin-network-record";
-//#region src/replay-mutation-throttler.ts
+// src/replay-mutation-throttler.ts
 const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3;
 const MUTATION_SOURCE_TYPE = 0;
 const MAX_TRACKED_NODES = 1e4;
@@ -51,8 +51,7 @@ var ReplayMutationThrottler = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/replay-sequence.ts
+// src/replay-sequence.ts
 const counters = /* @__PURE__ */ new Map();
 function sameRecording(counter, context) {
 	return counter?.sessionId === context.sessionId && counter.windowId === context.windowId;
@@ -91,227 +90,336 @@ function nextReplaySequence(siteKey, context, cookieless) {
 	if (!cookieless) setStorageItem("sessionStorage", sequenceKey(siteKey), JSON.stringify(counter));
 	return sequence;
 }
-//#endregion
-//#region src/replay.ts
-const MAX_TIMEOUT_MS = 2147483647;
-const DEFAULT_MAX_QUEUE_SIZE_BYTES = 2097152;
-const DEFAULT_MAX_BATCH_SIZE_BYTES = 921600;
-const KEEPALIVE_LIMIT_BYTES = 61440;
-const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 57344;
+// src/replay-uploader.ts
 const RETRY_BASE_DELAY_MS = 2e3;
 const RETRY_MAX_ATTEMPTS = 5;
 const RETRY_COOLDOWN_MS = 3e5;
-const VIEW_META_EVENT_TYPE = 5;
-const RRWEB_EVENT_FULL_SNAPSHOT = 2;
-const RRWEB_EVENT_META = 4;
-const REPLAY_SEQUENTIAL_ID_KEY = "_faststatsSeqId";
+const KEEPALIVE_LIMIT_BYTES = 61440;
 const textEncoder = new TextEncoder();
-const eventSizeCache = /* @__PURE__ */ new WeakMap();
-const batchSizeCache = /* @__PURE__ */ new WeakMap();
+const sizeCache = /* @__PURE__ */ new WeakMap();
+/** UTF-8 size of `value` as JSON, cached since queued values never change. */
+function jsonBytes(value) {
+	let size = sizeCache.get(value);
+	if (size === void 0) {
+		size = textEncoder.encode(JSON.stringify(value)).byteLength;
+		sizeCache.set(value, size);
+	}
+	return size;
+}
+function retryDelay(attempt) {
+	if (attempt >= RETRY_MAX_ATTEMPTS) return RETRY_COOLDOWN_MS;
+	const ceiling = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+	return Math.round(ceiling * (.5 + Math.random() * .5));
+}
 async function gzip(json) {
 	const stream = new Blob([json]).stream().pipeThrough(new CompressionStream("gzip"));
 	return new Uint8Array(await new Response(stream).arrayBuffer());
 }
-function boundedInteger(value, fallback, min, max) {
-	if (value === void 0 || !Number.isFinite(value) || value < min) return fallback;
-	return Math.min(Math.trunc(value), max);
+var ReplayUploader = class {
+	options;
+	queue = [];
+	/** Bytes of every queued batch, which count against the replay budget. */
+	bytes = 0;
+	sending;
+	lowLatency = false;
+	retryTimer;
+	attempt = 0;
+	constructor(options) {
+		this.options = options;
+	}
+	get length() {
+		return this.queue.length;
+	}
+	add(batch) {
+		this.queue.push(batch);
+		this.bytes += jsonBytes(batch);
+	}
+	clear() {
+		this.queue.length = 0;
+		this.bytes = 0;
+		this.cancelRetry();
+	}
+	cancelRetry() {
+		clearTimeout(this.retryTimer);
+		this.retryTimer = void 0;
+		this.attempt = 0;
+	}
+	/** Runs a scheduled retry now, keeping the backoff of earlier failures. */
+	retryNow() {
+		clearTimeout(this.retryTimer);
+		this.retryTimer = void 0;
+		if (this.attempt === RETRY_MAX_ATTEMPTS) this.attempt = 0;
+		return this.send(false);
+	}
+	/** Sends the queue in order. Waits out a scheduled retry instead. */
+	send(lowLatency) {
+		if (!this.sending && (!this.queue.length || this.retryTimer)) return Promise.resolve();
+		this.lowLatency ||= lowLatency;
+		this.sending ??= this.drain();
+		return this.sending;
+	}
+	/**
+	* Hands every batch to the browser at once, newest first, since the page may
+	* be gone before an awaited request settles. Resending a batch that is
+	* already in flight is idempotent on the server.
+	*/
+	sendAll() {
+		for (const batch of [...this.queue].reverse()) this.post(batch, true).then((sent) => sent && this.remove(batch));
+	}
+	async drain() {
+		try {
+			for (let batch = this.queue[0]; batch; batch = this.queue[0]) {
+				if (!await this.post(batch, this.lowLatency)) {
+					this.options.log(`Failed to send replay batch ${batch.sequence}`);
+					if (this.options.canRetry()) this.scheduleRetry();
+					return;
+				}
+				this.attempt = 0;
+				this.remove(batch);
+			}
+		} finally {
+			this.sending = void 0;
+			this.lowLatency = false;
+		}
+	}
+	scheduleRetry() {
+		this.attempt = Math.min(this.attempt + 1, RETRY_MAX_ATTEMPTS);
+		const delay = retryDelay(this.attempt);
+		this.options.log(`Retrying replay delivery in ${delay}ms`);
+		this.retryTimer = setTimeout(() => void this.retryNow(), delay);
+	}
+	remove(batch) {
+		const index = this.queue.indexOf(batch);
+		if (index < 0) return;
+		this.queue.splice(index, 1);
+		this.bytes -= jsonBytes(batch);
+		this.options.log(`Sent replay batch ${batch.sequence}`);
+	}
+	async post(batch, lowLatency) {
+		const json = JSON.stringify(batch);
+		const keepalive = lowLatency && jsonBytes(batch) <= KEEPALIVE_LIMIT_BYTES;
+		let data = json;
+		let contentType = "application/json";
+		let query = "";
+		if (!lowLatency && this.options.compress) try {
+			data = await gzip(json);
+			contentType = "application/octet-stream";
+			query = "?encoding=gzip";
+		} catch {
+			this.options.log("Compression failed, using uncompressed");
+		}
+		return sendData({
+			url: `${this.options.endpoint}${query}`,
+			data,
+			contentType,
+			debug: this.options.debug,
+			debugPrefix: "[Replay]",
+			useBeacon: keepalive,
+			keepalive,
+			settleRejected: true
+		});
+	}
+};
+// src/replay.ts
+const MAX_TIMEOUT_MS = 2147483647;
+const LOW_LATENCY_BATCH_BYTES = 57344;
+const LIMITS = {
+	flushInterval: [
+		5e3,
+		1,
+		MAX_TIMEOUT_MS
+	],
+	maxEvents: [
+		1e3,
+		1,
+		1e5
+	],
+	maxBatchSizeBytes: [
+		921600,
+		1,
+		33554432
+	],
+	maxLowLatencyBatchSizeBytes: [
+		LOW_LATENCY_BATCH_BYTES,
+		1,
+		LOW_LATENCY_BATCH_BYTES
+	],
+	maxPendingBatches: [
+		30,
+		1,
+		1e3
+	],
+	maxQueueSizeBytes: [
+		2097152,
+		1,
+		33554432
+	],
+	minReplayLengthMs: [
+		3e3,
+		0,
+		MAX_TIMEOUT_MS
+	]
+};
+const RRWEB_FULL_SNAPSHOT = 2;
+const RRWEB_META = 4;
+const RRWEB_CUSTOM = 5;
+const SEQUENCE_KEY = "_faststatsSeqId";
+function limits(options) {
+	const entries = Object.entries(LIMITS).map(([name, [fallback, min, max]]) => {
+		const value = options[name];
+		return [name, value === void 0 || !Number.isFinite(value) || value < min ? fallback : Math.min(Math.trunc(value), max)];
+	});
+	return Object.fromEntries(entries);
+}
+/** Splits events into chunks of at most `maxBytes`, keeping oversized ones whole. */
+function chunk(events, maxBytes) {
+	const chunks = [];
+	let current = [];
+	let size = 0;
+	for (const event of events) {
+		const bytes = jsonBytes(event) + 1;
+		if (!current.length || size + bytes > maxBytes) {
+			current = [];
+			chunks.push(current);
+			size = 0;
+		}
+		current.push(event);
+		size += bytes;
+	}
+	return chunks;
 }
 function sessionReplay(options = {}) {
-	return {
-		name: "session-replay",
-		setup(context) {
-			const tracker = new ReplayTracker({
-				...options,
-				siteKey: context.siteKey,
-				baseUrl: context.baseUrl,
-				debug: context.debug,
-				trackHash: context.trackHash,
-				cookieless: context.isCookieless()
-			});
-			context.on("pageChange", ({ url }) => tracker.trackPageChange(url));
-			context.on("pageHide", ({ persisted, terminal }) => tracker.onPageHidden(persisted, terminal));
-			context.on("pageShow", ({ persisted }) => tracker.onPageShow(persisted));
-			context.on("consentChange", ({ cookieless }) => tracker.setCookielessMode(cookieless));
-			tracker.start();
-			return ({ discard }) => tracker.stop(discard);
-		}
-	};
+	return trackerExtension("session-replay", (context) => new ReplayTracker({
+		...options,
+		...context
+	}), (tracker, context) => {
+		context.on("pageChange", ({ url }) => tracker.trackPageChange(url));
+		context.on("pageShow", ({ persisted }) => tracker.onPageShow(persisted));
+	});
 }
 var ReplayTracker = class {
 	options;
-	endpoint;
-	compress;
-	flushInterval;
-	maxEvents;
-	maxBatchSizeBytes;
-	maxLowLatencyBatchSizeBytes;
-	maxPendingBatches;
-	maxQueueSizeBytes;
-	minReplayLengthMs;
-	events = [];
-	pending = [];
-	queuedEventsSizeBytes = 0;
-	pendingSizeBytes = 0;
-	viewId = createId();
-	viewUrl = "";
-	chunkStartedAt = 0;
+	limits;
+	uploader;
+	throttler;
+	cookieless;
 	started = false;
-	disposed = false;
-	startTime = 0;
-	intervalId = null;
-	flushTask = null;
-	retryTask = null;
-	retryAttempt = 0;
-	minLengthFlushTask = null;
+	overflowed = false;
 	stopRecording;
-	activeSessionId = "";
-	sending = false;
-	queuedFlush = null;
-	unsubscribeRotation;
-	lastCookielessMode;
-	needsFinalization = false;
-	initialFlushPending = true;
+	stopFollowing;
+	intervalTimer;
+	flushTimer;
+	minLengthTimer;
+	viewId = createId();
+	viewUrl = "";
+	session;
+	streamStart = 0;
+	chunkStart = 0;
+	sequence = 0;
+	events = [];
+	eventBytes = 0;
 	resumed = false;
-	overflowed = false;
-	replayEventSequence = 0;
-	mutationThrottler;
+	unfinalized = false;
 	constructor(options) {
 		this.options = options;
-		this.lastCookielessMode = options.cookieless ?? false;
-		this.endpoint = `${resolveBaseUrl(options.baseUrl)}${URLS.replay}`;
-		this.compress = (options.compress ?? true) && typeof window !== "undefined" && "CompressionStream" in window;
-		this.flushInterval = boundedInteger(options.flushInterval, 5e3, 1, MAX_TIMEOUT_MS);
-		this.maxEvents = boundedInteger(options.maxEvents, 1e3, 1, 1e5);
-		this.maxBatchSizeBytes = boundedInteger(options.maxBatchSizeBytes, DEFAULT_MAX_BATCH_SIZE_BYTES, 1, 33554432);
-		this.maxLowLatencyBatchSizeBytes = boundedInteger(options.maxLowLatencyBatchSizeBytes, DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES, 1, DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES);
-		this.maxPendingBatches = boundedInteger(options.maxPendingBatches, 30, 1, 1e3);
-		this.maxQueueSizeBytes = boundedInteger(options.maxQueueSizeBytes, DEFAULT_MAX_QUEUE_SIZE_BYTES, 1, 33554432);
-		this.minReplayLengthMs = boundedInteger(options.minReplayLengthMs, 3e3, 0, MAX_TIMEOUT_MS);
-		this.mutationThrottler = options.mutationThrottle?.enabled === false ? null : new ReplayMutationThrottler(options.mutationThrottle);
-	}
-	log(...args) {
-		if (this.options.debug) console.log("[Replay]", ...args);
-	}
-	sessionContext() {
-		return getSessionContext(this.options.siteKey, this.lastCookielessMode);
-	}
-	sanitize(url) {
-		return sanitizeUrl(url, this.options.trackHash ?? false);
-	}
-	clearFlushTimers() {
-		if (this.flushTask) clearTimeout(this.flushTask);
-		if (this.retryTask) clearTimeout(this.retryTask);
-		if (this.minLengthFlushTask) clearTimeout(this.minLengthFlushTask);
-		this.flushTask = null;
-		this.retryTask = null;
-		this.retryAttempt = 0;
-		this.minLengthFlushTask = null;
-	}
-	dropEvents() {
-		this.events.length = 0;
-		this.queuedEventsSizeBytes = 0;
-	}
-	clearQueues() {
-		this.needsFinalization = false;
-		this.dropEvents();
-		this.pending.length = 0;
-		this.pendingSizeBytes = 0;
-	}
-	finalizeSession(context, flushReason) {
-		if (!this.needsFinalization) return;
-		const batch = this.createBatch([], context, true, flushReason);
-		if (batch) this.enqueueBatch(batch);
-	}
-	setCookielessMode(cookieless) {
-		if (this.lastCookielessMode === cookieless) return;
-		this.lastCookielessMode = cookieless;
-		if (this.started) this.subscribeToSessionRotation();
-		this.clearQueues();
-		this.clearFlushTimers();
-		const context = this.sessionContext();
-		this.activeSessionId = context.sessionId;
-		this.resetSessionTiming(context);
-		this.beginReplayStream();
+		this.cookieless = options.cookieless ?? false;
+		this.limits = limits(options);
+		this.uploader = new ReplayUploader({
+			endpoint: `${resolveBaseUrl(options.baseUrl)}${URLS.replay}`,
+			compress: (options.compress ?? true) && typeof window !== "undefined" && "CompressionStream" in window,
+			debug: options.debug,
+			canRetry: () => this.started,
+			log: (...details) => this.log(...details)
+		});
+		this.throttler = options.mutationThrottle?.enabled === false ? null : new ReplayMutationThrottler(options.mutationThrottle);
 	}
 	start() {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
-		this.disposed = false;
-		this.initialFlushPending = true;
 		this.overflowed = false;
-		this.replayEventSequence = 0;
 		this.viewId = createId();
 		this.viewUrl = this.sanitize(window.location.href);
-		const context = this.sessionContext();
-		this.activeSessionId = context.sessionId;
-		this.resetSessionTiming(context);
-		this.subscribeToSessionRotation();
+		this.beginStream(this.currentSession());
+		this.followSession();
 		this.beginRecording();
-		this.intervalId = setInterval(() => this.requestFlush("interval"), this.flushInterval);
+		this.intervalTimer = setInterval(() => this.requestFlush("interval"), this.limits.flushInterval);
 		this.log("Recording started");
 	}
+	stop(discard = false) {
+		if (!this.started) return;
+		this.started = false;
+		this.stopFollowing?.();
+		this.stopRecording?.();
+		this.stopRecording = void 0;
+		clearInterval(this.intervalTimer);
+		clearTimeout(this.flushTimer);
+		clearTimeout(this.minLengthTimer);
+		this.flushTimer = void 0;
+		this.uploader.cancelRetry();
+		if (discard) {
+			this.dropEvents();
+			this.uploader.clear();
+			this.log("Recording discarded");
+			return;
+		}
+		this.finish("stop");
+		this.log("Recording stopped");
+	}
+	/** Nothing captured under the old identity may be sent under the new one. */
+	setCookielessMode(cookieless) {
+		if (this.cookieless === cookieless) return;
+		this.cookieless = cookieless;
+		clearTimeout(this.flushTimer);
+		this.flushTimer = void 0;
+		this.uploader.clear();
+		this.dropEvents();
+		this.unfinalized = false;
+		if (!this.started) return;
+		this.beginStream(this.currentSession());
+		this.followSession();
+		this.takeFullSnapshot();
+	}
 	trackPageChange(url) {
 		if (!this.started) return;
 		this.viewId = createId();
-		const href = this.sanitize(url ?? window.location.href);
-		this.viewUrl = href;
+		this.viewUrl = this.sanitize(url ?? window.location.href);
 		this.onEvent({
-			type: VIEW_META_EVENT_TYPE,
+			type: RRWEB_CUSTOM,
 			timestamp: Date.now(),
 			data: {
 				tag: "faststats:view",
 				payload: {
-					href,
+					href: this.viewUrl,
 					viewId: this.viewId
 				}
 			}
 		});
 	}
 	onPageHidden(persisted = false, terminal = false) {
-		if (persisted) return;
-		if (terminal) {
-			this.requestTerminalFlush("pageHidden");
-			return;
-		}
-		this.flush(true, false, "pageHidden");
+		if (persisted || !this.started) return;
+		if (terminal) this.finish("pageHidden");
+		else this.flush("pageHidden", true);
 	}
 	onPageShow(persisted = false) {
 		if (!persisted || !this.started) return;
-		if (this.pending.length > 0) this.flush(false, false, "pageShow");
+		this.uploader.retryNow();
 	}
-	recordingPlugins() {
-		const plugins = [];
-		if (this.options.recordConsole === true) plugins.push(getRecordConsolePlugin({
-			level: this.options.consoleLevel ?? [
-				"error",
-				"warn",
-				"info",
-				"log"
-			],
-			lengthThreshold: this.options.consoleLengthThreshold ?? 200,
-			stringifyOptions: {
-				numOfKeysLimit: 25,
-				depthOfLimit: 3,
-				stringLengthLimit: this.options.consoleStringLengthLimit ?? 500
-			}
-		}));
-		if (this.options.recordNetwork === true) {
-			const options = this.options.networkOptions;
-			const base = resolveBaseUrl(this.options.baseUrl);
-			const endpoints = new Set(Object.values(URLS).map((path) => {
-				const url = new URL(`${base}${path}`, window.location.href);
-				return `${url.origin}${url.pathname}`;
-			}));
-			plugins.push(getRecordNetworkPlugin({
-				...options,
-				transformRequestFn: (request) => {
-					const url = new URL(request.name, window.location.href);
-					if (endpoints.has(`${url.origin}${url.pathname}`)) return;
-					return options?.transformRequestFn ? options.transformRequestFn(request) : request;
-				}
-			}));
-		}
-		return plugins;
+	log(...details) {
+		if (this.options.debug) console.log("[Replay]", ...details);
+	}
+	sanitize(url) {
+		return sanitizeUrl(url, this.options.trackHash ?? false);
+	}
+	currentSession() {
+		return getSessionContext(this.options.siteKey, this.cookieless);
+	}
+	followSession() {
+		this.stopFollowing?.();
+		this.stopFollowing = onSessionRotated(this.options.siteKey, this.cookieless, (_prev, next) => {
+			if (!this.started) return;
+			this.rotate(next);
+			if (this.uploader.length) queueMicrotask(() => void this.flush("sessionRotate"));
+		});
 	}
 	beginRecording() {
 		this.stopRecording = record({
@@ -349,46 +457,42 @@ var ReplayTracker = class {
 			plugins: this.recordingPlugins()
 		});
 	}
-	stop(discard = false) {
-		if (!this.started) return;
-		this.started = false;
-		this.disposed = true;
-		this.unsubscribeRotation?.();
-		this.unsubscribeRotation = void 0;
-		this.stopRecording?.();
-		this.stopRecording = void 0;
-		if (this.intervalId) clearInterval(this.intervalId);
-		this.clearFlushTimers();
-		this.intervalId = null;
-		if (discard) {
-			this.clearQueues();
-			this.log("Recording discarded");
-			return;
+	recordingPlugins() {
+		const plugins = [];
+		if (this.options.recordConsole === true) plugins.push(getRecordConsolePlugin({
+			level: this.options.consoleLevel ?? [
+				"error",
+				"warn",
+				"info",
+				"log"
+			],
+			lengthThreshold: this.options.consoleLengthThreshold ?? 200,
+			stringifyOptions: {
+				numOfKeysLimit: 25,
+				depthOfLimit: 3,
+				stringLengthLimit: this.options.consoleStringLengthLimit ?? 500
+			}
+		}));
+		if (this.options.recordNetwork === true) {
+			const options = this.options.networkOptions;
+			const base = resolveBaseUrl(this.options.baseUrl);
+			const route = (url) => {
+				const { origin, pathname } = new URL(url, window.location.href);
+				return origin + pathname;
+			};
+			const endpoints = new Set(Object.values(URLS).map((path) => route(base + path)));
+			plugins.push(getRecordNetworkPlugin({
+				...options,
+				transformRequestFn: (request) => {
+					if (endpoints.has(route(request.name))) return;
+					const transform = options?.transformRequestFn;
+					return transform ? transform(request) : request;
+				}
+			}));
 		}
-		this.requestTerminalFlush("stop");
-		this.log("Recording stopped");
+		return plugins;
 	}
-	onSessionRotated(prev, next) {
-		if (!this.started) return;
-		this.applySessionRotation(prev, next);
-		if (this.pending.length > 0) queueMicrotask(() => void this.flush(false, false, "sessionRotate"));
-	}
-	subscribeToSessionRotation() {
-		this.unsubscribeRotation?.();
-		this.unsubscribeRotation = onSessionRotated(this.options.siteKey, this.lastCookielessMode, (prev, next) => this.onSessionRotated(prev, next));
-	}
-	applySessionRotation(prev, next) {
-		if (this.activeSessionId === next.sessionId) return;
-		if (this.hasReachedMinLength()) this.enqueueEventsIfReady(prev, "sessionRotate");
-		else this.dropEvents();
-		this.finalizeSession(prev, "sessionRotate");
-		this.needsFinalization = false;
-		this.activeSessionId = next.sessionId;
-		this.resetSessionTiming(next);
-		this.beginReplayStream();
-	}
-	beginReplayStream() {
-		this.replayEventSequence = 0;
+	takeFullSnapshot() {
 		const stopRecording = this.stopRecording;
 		if (!stopRecording) return;
 		try {
@@ -397,7 +501,6 @@ var ReplayTracker = class {
 			this.stopRecording = void 0;
 			try {
 				stopRecording();
-				this.replayEventSequence = 0;
 				this.beginRecording();
 			} catch (restartError) {
 				this.log("Failed to restart replay stream", {
@@ -407,262 +510,139 @@ var ReplayTracker = class {
 			}
 		}
 	}
-	resetSessionTiming(next) {
-		if (this.minLengthFlushTask) clearTimeout(this.minLengthFlushTask);
-		this.minLengthFlushTask = null;
-		this.resumed = hasReplaySequence(this.options.siteKey, next, this.lastCookielessMode);
-		this.startTime = Date.now();
-		this.chunkStartedAt = Date.now();
-		this.initialFlushPending = true;
+	stopCapture(reason) {
+		this.log(reason);
+		this.overflowed = true;
+		this.stopRecording?.();
+		this.stopRecording = void 0;
 	}
 	onEvent = (event) => {
 		if (this.overflowed) return;
-		let capturedEvent = event;
-		if (event.type === RRWEB_EVENT_META) {
-			const data = event.data;
-			if (typeof data.href === "string") capturedEvent = {
-				...event,
-				data: {
-					...data,
-					href: this.sanitize(data.href)
-				}
-			};
-		}
-		if (capturedEvent.type === RRWEB_EVENT_FULL_SNAPSHOT) this.mutationThrottler?.reset();
-		else {
-			const throttled = this.mutationThrottler?.throttle(capturedEvent);
-			if (this.mutationThrottler && !throttled) return;
-			if (throttled) capturedEvent = throttled;
+		const { data } = event;
+		if (event.type === RRWEB_META && typeof data?.href === "string") event = {
+			...event,
+			data: {
+				...data,
+				href: this.sanitize(data.href)
+			}
+		};
+		if (event.type === RRWEB_FULL_SNAPSHOT) this.throttler?.reset();
+		else if (this.throttler) {
+			const throttled = this.throttler.throttle(event);
+			if (!throttled) return;
+			event = throttled;
 		}
-		const sequencedEvent = {
-			...capturedEvent,
-			[REPLAY_SEQUENTIAL_ID_KEY]: ++this.replayEventSequence
+		const sequenced = {
+			...event,
+			[SEQUENCE_KEY]: ++this.sequence
 		};
-		const eventBytes = this.eventSizeBytes(sequencedEvent);
-		if (this.pendingSizeBytes + this.queuedEventsSizeBytes + eventBytes > this.maxQueueSizeBytes) {
+		const bytes = jsonBytes(sequenced) + 1;
+		if (this.uploader.bytes + this.eventBytes + bytes > this.limits.maxQueueSizeBytes) {
 			this.stopCapture("Replay buffer limit reached");
 			return;
 		}
-		this.events.push(sequencedEvent);
-		this.queuedEventsSizeBytes += eventBytes;
-		let reason;
-		if (this.events.length >= this.maxEvents) reason = "maxEvents";
-		else if (this.queuedEventsSizeBytes >= this.maxBatchSizeBytes) reason = "maxBytes";
-		if (reason) this.requestFlush(reason);
-		else this.scheduleMinLengthFlush();
+		this.events.push(sequenced);
+		this.eventBytes += bytes;
+		if (this.events.length >= this.limits.maxEvents) this.requestFlush("maxEvents");
+		else if (this.eventBytes >= this.limits.maxBatchSizeBytes) this.requestFlush("maxBytes");
 	};
-	requestTerminalFlush(reason) {
-		if (!this.hasReachedMinLength()) {
-			this.dropEvents();
-			this.needsFinalization = false;
-			this.log(`Recording too short (${Date.now() - this.startTime}ms), discarding events`);
-			if (this.pending.length === 0) return;
-		}
-		this.flush(true, true, reason);
+	beginStream(session) {
+		this.session = session;
+		this.dropEvents();
+		this.sequence = 0;
+		this.unfinalized = false;
+		this.resumed = hasReplaySequence(this.options.siteKey, session, this.cookieless);
+		this.streamStart = this.chunkStart = Date.now();
+		clearTimeout(this.minLengthTimer);
+		if (this.started && !this.reachedMinLength()) this.minLengthTimer = setTimeout(() => this.requestFlush("minLength"), this.limits.minReplayLengthMs);
+	}
+	rotate(next) {
+		if (next.sessionId === this.session.sessionId) return;
+		this.batchEvents("sessionRotate");
+		this.endStream("sessionRotate");
+		this.beginStream(next);
+		this.takeFullSnapshot();
+	}
+	reachedMinLength() {
+		return this.resumed || Date.now() - this.streamStart >= this.limits.minReplayLengthMs;
 	}
-	hasReachedMinLength() {
-		return this.resumed || this.minReplayLengthMs <= 0 || Date.now() - this.startTime >= this.minReplayLengthMs;
+	dropEvents() {
+		this.events = [];
+		this.eventBytes = 0;
 	}
 	requestFlush(reason) {
-		if (this.flushTask || this.events.length === 0) return;
-		if (this.minLengthFlushTask) {
-			clearTimeout(this.minLengthFlushTask);
-			this.minLengthFlushTask = null;
-		}
-		this.flushTask = setTimeout(() => {
-			this.flushTask = null;
-			this.flush(false, false, reason);
-		}, 0);
-	}
-	scheduleMinLengthFlush() {
-		if (!this.initialFlushPending || this.events.length === 0 || this.minReplayLengthMs <= 0) return;
-		if (this.hasReachedMinLength()) {
-			this.initialFlushPending = false;
-			this.requestFlush("minLength");
-			return;
+		if (this.flushTimer || !this.events.length) return;
+		this.flushTimer = setTimeout(() => {
+			this.flushTimer = void 0;
+			this.flush(reason);
+		});
+	}
+	async flush(reason, lowLatency = false) {
+		if (this.events.length) {
+			this.rotate(touchActivity(this.options.siteKey, this.cookieless));
+			this.batchEvents(reason, lowLatency);
 		}
-		if (this.minLengthFlushTask) return;
-		this.minLengthFlushTask = setTimeout(() => {
-			this.minLengthFlushTask = null;
-			this.initialFlushPending = false;
-			this.requestFlush("minLength");
-		}, this.minReplayLengthMs - (Date.now() - this.startTime));
-	}
-	enqueueEventsIfReady(context, flushReason, maxBatchSizeBytes = this.maxBatchSizeBytes) {
-		if (this.events.length === 0) return;
-		if (!this.hasReachedMinLength()) {
-			this.scheduleMinLengthFlush();
-			return;
+		await this.uploader.send(lowLatency);
+	}
+	finish(reason) {
+		if (this.reachedMinLength()) {
+			if (this.events.length) this.rotate(touchActivity(this.options.siteKey, this.cookieless));
+			this.batchEvents(reason, true);
+			this.endStream(reason);
+		} else {
+			this.log(`Recording too short (${Date.now() - this.streamStart}ms), discarding events`);
+			this.dropEvents();
 		}
-		for (const events of this.takeEventBatches(maxBatchSizeBytes)) {
-			if (this.pending.length >= this.maxPendingBatches) {
+		this.uploader.sendAll();
+	}
+	batchEvents(reason, lowLatency = false) {
+		if (!this.events.length || !this.reachedMinLength()) return;
+		const maxBytes = lowLatency ? this.limits.maxLowLatencyBatchSizeBytes : this.limits.maxBatchSizeBytes;
+		const events = this.events;
+		this.dropEvents();
+		for (const batch of chunk(events, maxBytes)) {
+			if (this.uploader.length >= this.limits.maxPendingBatches) {
 				this.stopCapture("Replay queue limit reached");
-				break;
+				return;
 			}
-			const batch = this.createBatch(events, context, false, flushReason);
-			if (!batch) break;
-			this.enqueueBatch(batch);
+			if (!this.enqueue(batch, reason)) return;
 		}
-		this.queuedEventsSizeBytes = 0;
-	}
-	takeEventBatches(maxBatchSizeBytes) {
-		const batches = [];
-		let current = [];
-		let currentSize = 0;
-		for (const event of this.events.splice(0)) {
-			const eventSize = this.eventSizeBytes(event);
-			if (current.length > 0 && currentSize + eventSize > maxBatchSizeBytes) {
-				batches.push(current);
-				current = [];
-				currentSize = 0;
-			}
-			current.push(event);
-			currentSize += eventSize;
-		}
-		if (current.length > 0) batches.push(current);
-		return batches;
 	}
-	createBatch(events, context, isFinal, flushReason) {
-		const identifier = getAnonymousId(this.options.siteKey, this.lastCookielessMode);
-		const sequence = nextReplaySequence(this.options.siteKey, context, this.lastCookielessMode);
+	endStream(reason) {
+		if (this.unfinalized) this.enqueue([], reason, true);
+	}
+	enqueue(events, reason, isFinal = false) {
+		const { siteKey } = this.options;
+		const { sessionId, windowId, sessionStart } = this.session;
+		const sequence = nextReplaySequence(siteKey, this.session, this.cookieless);
 		if (sequence === void 0) {
 			this.stopCapture("Replay sequence state is invalid or exhausted");
-			return;
+			return false;
 		}
-		const chunkStartedAt = this.chunkStartedAt;
+		const identifier = getAnonymousId(siteKey, this.cookieless);
+		const chunkStartedAt = this.chunkStart;
 		const now = Date.now();
-		this.chunkStartedAt = now;
-		return {
-			token: this.options.siteKey,
-			sessionId: context.sessionId,
-			windowId: context.windowId,
+		this.chunkStart = now;
+		this.unfinalized = !isFinal;
+		this.uploader.add({
+			token: siteKey,
+			sessionId,
+			windowId,
 			viewId: this.viewId,
-			sessionStart: context.sessionStart,
+			sessionStart,
 			chunkStartedAt,
 			chunkEndedAt: now,
 			...identifier ? { identifier } : {},
-			batchId: `${context.sessionId}-${sequence}-${chunkStartedAt}`,
+			batchId: `${sessionId}-${sequence}-${chunkStartedAt}`,
 			sequence,
 			sequenceContractVersion: 1,
 			timestamp: now,
-			url: this.viewUrl || this.sanitize(window.location.href),
+			url: this.viewUrl,
 			...isFinal ? { isFinal: true } : {},
-			flushReason,
+			flushReason: reason,
 			events
-		};
-	}
-	eventSizeBytes(event) {
-		let size = eventSizeCache.get(event);
-		if (size === void 0) {
-			size = textEncoder.encode(JSON.stringify(event)).byteLength + 1;
-			eventSizeCache.set(event, size);
-		}
-		return size;
-	}
-	batchSizeBytes(batch) {
-		const cached = batchSizeCache.get(batch);
-		if (cached !== void 0) return cached;
-		const size = textEncoder.encode(JSON.stringify(batch)).byteLength;
-		batchSizeCache.set(batch, size);
-		return size;
-	}
-	removePending(batch) {
-		const index = this.pending.indexOf(batch);
-		if (index < 0) return;
-		this.pending.splice(index, 1);
-		this.pendingSizeBytes = Math.max(0, this.pendingSizeBytes - this.batchSizeBytes(batch));
-		this.log(`Sent replay batch ${batch.sequence}`);
-	}
-	stopCapture(reason) {
-		this.log(reason);
-		this.overflowed = true;
-		this.stopRecording?.();
-		this.stopRecording = void 0;
-	}
-	enqueueBatch(batch) {
-		this.needsFinalization = !batch.isFinal;
-		this.pending.push(batch);
-		this.pendingSizeBytes += this.batchSizeBytes(batch);
-	}
-	async flush(lowLatency, isFinal = false, flushReason = "manual") {
-		if (this.events.length === 0 && !isFinal) {
-			await this.sendPending(lowLatency);
-			return;
-		}
-		const rotation = touchActivity(this.options.siteKey, this.lastCookielessMode);
-		if (rotation) this.applySessionRotation(rotation.prev, rotation.next);
-		const context = this.sessionContext();
-		this.enqueueEventsIfReady(context, flushReason, lowLatency ? this.maxLowLatencyBatchSizeBytes : this.maxBatchSizeBytes);
-		if (!isFinal) return this.sendPending(lowLatency);
-		this.finalizeSession(context, flushReason);
-		for (const batch of [...this.pending].reverse()) this.sendBatch(batch, true).then((sent) => sent && this.removePending(batch));
-	}
-	async sendPending(lowLatency) {
-		if (this.retryTask) return;
-		if (this.sending) {
-			this.queuedFlush = !!this.queuedFlush || lowLatency;
-			return;
-		}
-		this.sending = true;
-		try {
-			while (this.pending.length > 0) {
-				const batch = this.pending[0];
-				if (!await this.sendBatch(batch, lowLatency)) {
-					this.log(`Failed to send replay batch ${batch.sequence}`);
-					if (!this.disposed) this.scheduleRetry();
-					break;
-				}
-				this.retryAttempt = 0;
-				this.removePending(batch);
-				if (this.queuedFlush) break;
-			}
-		} finally {
-			this.sending = false;
-			if (this.queuedFlush !== null) {
-				const lowLatency = this.queuedFlush;
-				this.queuedFlush = null;
-				this.sendPending(lowLatency);
-			}
-		}
-	}
-	scheduleRetry() {
-		if (this.retryTask) return;
-		this.retryAttempt = Math.min(this.retryAttempt + 1, RETRY_MAX_ATTEMPTS);
-		const delay = this.retryDelay(this.retryAttempt);
-		this.log(this.retryAttempt === RETRY_MAX_ATTEMPTS ? `Replay delivery paused for ${delay}ms` : `Retrying replay delivery in ${delay}ms`);
-		this.retryTask = setTimeout(() => {
-			this.retryTask = null;
-			if (this.retryAttempt === RETRY_MAX_ATTEMPTS) this.retryAttempt = 0;
-			this.sendPending(false);
-		}, delay);
-	}
-	retryDelay(attempt) {
-		if (attempt >= RETRY_MAX_ATTEMPTS) return RETRY_COOLDOWN_MS;
-		const ceiling = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
-		return Math.round(ceiling * (.5 + Math.random() * .5));
-	}
-	async sendBatch(batch, lowLatency) {
-		const json = JSON.stringify(batch);
-		const keepalive = lowLatency && this.batchSizeBytes(batch) <= KEEPALIVE_LIMIT_BYTES;
-		const send = (data, contentType, query = "") => sendData({
-			url: `${this.endpoint}${query}`,
-			data,
-			contentType,
-			debug: this.options.debug,
-			debugPrefix: "[Replay]",
-			useBeacon: keepalive,
-			keepalive,
-			settleRejected: true
 		});
-		if (!lowLatency && this.compress) try {
-			const compressed = await gzip(json);
-			this.log(`Compressed ${json.length}B -> ${compressed.byteLength}B (${Math.round(compressed.byteLength / json.length * 100)}%)`);
-			return send(compressed, "application/octet-stream", "?encoding=gzip");
-		} catch {
-			this.log("Compression failed, using uncompressed");
-		}
-		return send(json, "application/json");
+		return true;
 	}
 };
-//#endregion
 export { ReplayTracker as default, sessionReplay };