@faststats/web 0.6.0 → 0.8.0

package/dist/outbound-links.d.ts

@@ -0,0 +1,10 @@
+import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
+//#region src/outbound-links.d.ts
+declare function outboundLinks(): AnalyticsExtension;
+declare class OutboundLinkTracker {
+  private lastActivation;
+  getHref(event: Event): string | null;
+  private isDuplicate;
+}
+//#endregion
+export { OutboundLinkTracker, outboundLinks };

package/dist/outbound-links.js

@@ -0,0 +1,62 @@
+import { a as sanitizeUrl } from "./chunks/api-urls-DWk43fu6.js";
+//#region src/outbound-links.ts
+function outboundLinks() {
+	return {
+		name: "outbound-links",
+		setup(context) {
+			const tracker = new OutboundLinkTracker();
+			const onClick = (event) => {
+				const href = tracker.getHref(event);
+				if (href) context.capture("outbound_link", { outbound_link: sanitizeUrl(href) });
+			};
+			document.addEventListener("click", onClick, true);
+			document.addEventListener("auxclick", onClick, true);
+			return () => {
+				document.removeEventListener("click", onClick, true);
+				document.removeEventListener("auxclick", onClick, true);
+			};
+		}
+	};
+}
+const DEDUPE_MS = 500;
+var OutboundLinkTracker = class {
+	lastActivation = null;
+	getHref(event) {
+		if (!(event instanceof MouseEvent) || !isEligibleActivation(event)) return null;
+		const anchor = findOutboundAnchor(event);
+		if (!anchor || this.isDuplicate(event, anchor.href)) return null;
+		return anchor.href;
+	}
+	isDuplicate(event, href) {
+		const activation = {
+			button: event.button,
+			href,
+			clientX: event.clientX,
+			clientY: event.clientY,
+			at: Date.now()
+		};
+		const previous = this.lastActivation;
+		this.lastActivation = activation;
+		return !!(previous && previous.href === activation.href && previous.button === activation.button && previous.clientX === activation.clientX && previous.clientY === activation.clientY && activation.at - previous.at <= DEDUPE_MS);
+	}
+};
+function isEligibleActivation(event) {
+	if (event.defaultPrevented) return false;
+	if (event.type === "click") return event.button === 0;
+	if (event.type === "auxclick") return event.button === 1;
+	return false;
+}
+function findOutboundAnchor(event) {
+	for (const node of event.composedPath()) if (isOutboundAnchor(node)) return node;
+	let node = event.target;
+	while (node) {
+		if (isOutboundAnchor(node)) return node;
+		node = node.parentNode;
+	}
+	return null;
+}
+function isOutboundAnchor(node) {
+	return node instanceof HTMLAnchorElement && (node.protocol === "http:" || node.protocol === "https:") && node.host !== location.host;
+}
+//#endregion
+export { OutboundLinkTracker, outboundLinks };

package/dist/replay.d.ts

@@ -1,2 +1,128 @@
-import { n as ReplayTrackerOptions, t as ReplayTracker } from "./chunks/replay-DgodPHzA.js";
-export { ReplayTrackerOptions, ReplayTracker as default };
+import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
+import { record } from "@rrweb/record";
+import { LogLevel } from "@rrweb/rrweb-plugin-console-record";
+//#region ../../node_modules/.bun/@rrweb+types@2.1.1/node_modules/@rrweb/types/dist/index.d.ts
+declare global {
+  interface Window {
+    FontFace: typeof FontFace;
+  }
+}
+//#endregion
+//#region src/replay-mutation-throttler.d.ts
+type ReplayMutationThrottleOptions = {
+  enabled?: boolean;
+  bucketSize?: number;
+  refillRate?: number;
+};
+//#endregion
+//#region src/replay.d.ts
+type RecordOptions = NonNullable<Parameters<typeof record>[0]>;
+interface ReplayTrackerOptions {
+  siteKey: string;
+  baseUrl?: string;
+  debug?: boolean;
+  trackHash?: boolean;
+  cookieless?: boolean;
+  compress?: boolean;
+  flushInterval?: number;
+  maxEvents?: number;
+  maxBatchSizeBytes?: number;
+  maxLowLatencyBatchSizeBytes?: number;
+  maxPendingBatches?: number;
+  maxQueueSizeBytes?: number;
+  minReplayLengthMs?: number;
+  sampling?: RecordOptions["sampling"];
+  slimDOMOptions?: RecordOptions["slimDOMOptions"];
+  maskAllInputs?: boolean;
+  maskInputOptions?: RecordOptions["maskInputOptions"];
+  blockClass?: string;
+  blockSelector?: string;
+  maskTextClass?: string;
+  maskTextSelector?: string;
+  checkoutEveryNms?: number;
+  checkoutEveryNth?: number;
+  recordConsole?: boolean;
+  consoleLevel?: LogLevel[];
+  consoleLengthThreshold?: number;
+  consoleStringLengthLimit?: number;
+  mutationThrottle?: ReplayMutationThrottleOptions;
+}
+type SessionReplayExtensionOptions = Omit<ReplayTrackerOptions, "siteKey" | "baseUrl" | "debug" | "trackHash" | "cookieless">;
+declare function sessionReplay(options?: SessionReplayExtensionOptions): AnalyticsExtension;
+declare class ReplayTracker {
+  private readonly options;
+  private readonly endpoint;
+  private readonly compressionSupported;
+  private readonly flushInterval;
+  private readonly maxEvents;
+  private readonly maxBatchSizeBytes;
+  private readonly maxLowLatencyBatchSizeBytes;
+  private readonly maxPendingBatches;
+  private readonly maxQueueSizeBytes;
+  private readonly minReplayLengthMs;
+  private readonly events;
+  private readonly pending;
+  private readonly minLengthBlockedBatches;
+  private queuedEventsSizeBytes;
+  private pendingSizeBytes;
+  private viewId;
+  private viewUrl;
+  private chunkStartedAt;
+  private started;
+  private disposed;
+  private startTime;
+  private sequence;
+  private intervalId;
+  private flushTask;
+  private retryTask;
+  private retryAttempt;
+  private minLengthFlushTask;
+  private stopRecording?;
+  private sending;
+  private inFlightBatch;
+  private queuedFlush;
+  private unsubscribeRotation?;
+  private lastCookielessMode;
+  private terminalFlushRequested;
+  private overflowed;
+  private replayEventSequence;
+  private readonly mutationThrottler;
+  constructor(options: ReplayTrackerOptions);
+  private log;
+  private clearFlushTimers;
+  private clearQueues;
+  private dropMinLengthBlockedBatches;
+  private unblockSessionBatches;
+  private finalizeSessionPending;
+  private nextBatchSequence;
+  setCookielessMode(cookieless: boolean): void;
+  start(): void;
+  trackPageChange(url?: string): void;
+  onPageHidden(persisted?: boolean, terminal?: boolean): void;
+  onPageShow(persisted?: boolean): void;
+  private beginRecording;
+  stop(discard?: boolean): void;
+  private onSessionRotated;
+  private subscribeToSessionRotation;
+  private applySessionRotation;
+  private resetSessionTiming;
+  private onEvent;
+  private onUnload;
+  private requestTerminalFlush;
+  private hasReachedMinLength;
+  private requestFlush;
+  private scheduleMinLengthFlush;
+  private enqueueEventsIfReady;
+  private takeEventBatches;
+  private createBatch;
+  private eventSizeBytes;
+  private batchSizeBytes;
+  private removePending;
+  private enqueueBatch;
+  private flush;
+  private scheduleRetry;
+  private retryDelay;
+  private sendBatch;
+}
+//#endregion
+export { ReplayTrackerOptions, SessionReplayExtensionOptions, ReplayTracker as default, sessionReplay };

package/dist/replay.js

@@ -1,21 +1,91 @@
-import { a as resolveBaseUrl, o as sanitizeUrl, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-CaNa8upY.js";
-import { a as onSessionRotated, c as touchActivity, d as setStorageItem, i as isCookielessMode, l as getStorageItem, n as createId, r as getSessionContext, t as sendData } from "./chunks/send-data-DjdbGDDc.js";
-import { t as getAnonymousId } from "./chunks/identifiers-cUymVK5H.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-DWk43fu6.js";
+import { i as onSessionRotated, l as setStorageItem, n as createId, o as touchActivity, r as getSessionContext, s as getStorageItem, t as sendData } from "./chunks/send-data-DFZnsaL2.js";
+import { t as getAnonymousId } from "./chunks/identifiers-KgQDX74Q.js";
 import { record } from "@rrweb/record";
+import { getRecordConsolePlugin } from "@rrweb/rrweb-plugin-console-record";
+//#region src/replay-mutation-throttler.ts
+const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3;
+const MUTATION_SOURCE_TYPE = 0;
+const MAX_TRACKED_NODES = 1e4;
+/** Bounds pathological per-node attribute churn without breaking the mutation chain. */
+var ReplayMutationThrottler = class {
+	buckets = /* @__PURE__ */ new Map();
+	bucketSize;
+	refillRate;
+	constructor(options = {}) {
+		this.bucketSize = Math.max(1, options.bucketSize ?? 100);
+		this.refillRate = Math.max(1, options.refillRate ?? 10);
+	}
+	reset() {
+		this.buckets.clear();
+	}
+	throttle(event) {
+		if (event.type !== INCREMENTAL_SNAPSHOT_EVENT_TYPE) return event;
+		const data = event.data;
+		if (data.source !== MUTATION_SOURCE_TYPE || !data.attributes?.length) return event;
+		const attributes = data.attributes.filter(({ id }) => this.consume(id));
+		if (attributes.length === data.attributes.length) return event;
+		if (attributes.length === 0 && (data.adds?.length ?? 0) === 0 && (data.removes?.length ?? 0) === 0 && (data.texts?.length ?? 0) === 0) return;
+		return {
+			...event,
+			data: {
+				...data,
+				attributes
+			}
+		};
+	}
+	consume(nodeId) {
+		const now = Date.now();
+		const bucket = this.buckets.get(nodeId) ?? {
+			tokens: this.bucketSize,
+			updatedAt: now
+		};
+		const elapsedSeconds = Math.max(0, now - bucket.updatedAt) / 1e3;
+		bucket.tokens = Math.min(this.bucketSize, bucket.tokens + elapsedSeconds * this.refillRate);
+		bucket.updatedAt = now;
+		if (!this.buckets.has(nodeId) && this.buckets.size >= MAX_TRACKED_NODES) this.buckets.delete(this.buckets.keys().next().value);
+		this.buckets.set(nodeId, bucket);
+		if (bucket.tokens < 1) return false;
+		bucket.tokens -= 1;
+		return true;
+	}
+};
+//#endregion
 //#region src/replay.ts
 const MAX_TIMEOUT_MS = 2147483647;
-const DEFAULT_MAX_QUEUE_SIZE_BYTES = 2 * 1024 * 1024;
-const DEFAULT_MAX_BATCH_SIZE_BYTES = 512 * 1024;
-const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 60 * 1024;
+const DEFAULT_MAX_QUEUE_SIZE_BYTES = 2097152;
+const DEFAULT_MAX_BATCH_SIZE_BYTES = 921600;
+const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 61440;
 const RETRY_BASE_DELAY_MS = 2e3;
 const RETRY_MAX_ATTEMPTS = 5;
-const RETRY_COOLDOWN_MS = 5 * 6e4;
+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 textEncoder = new TextEncoder();
 const batchSizeCache = /* @__PURE__ */ new WeakMap();
+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);
+		}
+	};
+}
 var ReplayTracker = class {
 	options;
 	endpoint;
@@ -33,10 +103,10 @@ var ReplayTracker = class {
 	queuedEventsSizeBytes = 0;
 	pendingSizeBytes = 0;
 	viewId = createId();
+	viewUrl = "";
 	chunkStartedAt = 0;
 	started = false;
 	disposed = false;
-	startGeneration = 0;
 	startTime = 0;
 	sequence = 0;
 	intervalId = null;
@@ -49,17 +119,23 @@ var ReplayTracker = class {
 	inFlightBatch = null;
 	queuedFlush = null;
 	unsubscribeRotation;
-	lastCookielessMode = isCookielessMode();
+	lastCookielessMode;
+	terminalFlushRequested = false;
+	overflowed = false;
+	replayEventSequence = 0;
+	mutationThrottler;
 	constructor(options) {
 		this.options = options;
+		this.lastCookielessMode = options.cookieless ?? false;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.replay}`;
-		this.flushInterval = options.flushInterval ?? 5e3;
+		this.flushInterval = options.flushInterval ?? 15e3;
 		this.maxEvents = options.maxEvents ?? 1e3;
 		this.maxBatchSizeBytes = options.maxBatchSizeBytes ?? DEFAULT_MAX_BATCH_SIZE_BYTES;
 		this.maxLowLatencyBatchSizeBytes = options.maxLowLatencyBatchSizeBytes ?? DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES;
 		this.maxPendingBatches = options.maxPendingBatches ?? 30;
 		this.maxQueueSizeBytes = options.maxQueueSizeBytes ?? DEFAULT_MAX_QUEUE_SIZE_BYTES;
 		this.minReplayLengthMs = options.minReplayLengthMs ?? 3e3;
+		this.mutationThrottler = options.mutationThrottle?.enabled === false ? null : new ReplayMutationThrottler(options.mutationThrottle);
 	}
 	log(...args) {
 		if (this.options.debug) console.log("[Replay]", ...args);
@@ -113,38 +189,33 @@ var ReplayTracker = class {
 	setCookielessMode(cookieless) {
 		if (this.lastCookielessMode === cookieless) return;
 		this.lastCookielessMode = cookieless;
-		if (cookieless) {
-			this.clearQueues();
-			this.clearFlushTimers();
-		}
-		this.startTime = getSessionContext(this.options.siteKey).sessionStart;
+		if (this.started) this.subscribeToSessionRotation();
+		this.clearQueues();
+		this.clearFlushTimers();
+		this.startTime = getSessionContext(this.options.siteKey, this.lastCookielessMode).sessionStart;
 		this.chunkStartedAt = Date.now();
 	}
 	start() {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
 		this.disposed = false;
+		this.terminalFlushRequested = false;
+		this.overflowed = false;
 		this.viewId = createId();
-		this.startTime = getSessionContext(this.options.siteKey).sessionStart;
+		this.viewUrl = sanitizeUrl(window.location.href, this.options.trackHash ?? false);
+		this.startTime = getSessionContext(this.options.siteKey, this.lastCookielessMode).sessionStart;
 		this.chunkStartedAt = Date.now();
-		this.unsubscribeRotation = onSessionRotated((prev, next) => {
-			this.onSessionRotated(prev, next);
-		});
-		const generation = ++this.startGeneration;
-		this.beginRecording(generation);
+		this.subscribeToSessionRotation();
+		this.beginRecording();
 		this.intervalId = setInterval(() => this.requestFlush("interval"), this.flushInterval);
 		window.addEventListener("beforeunload", this.onUnload);
 		this.log("Recording started");
 	}
 	trackPageChange(url) {
 		if (!this.started) return;
-		this.enqueueEventsIfReady(getSessionContext(this.options.siteKey), {
-			flushReason: "navigation",
-			sealBeforeMinLength: true
-		});
 		this.viewId = createId();
-		this.chunkStartedAt = Date.now();
-		const href = sanitizeUrl(url ?? window.location.href);
+		const href = sanitizeUrl(url ?? window.location.href, this.options.trackHash ?? false);
+		this.viewUrl = href;
 		this.onEvent({
 			type: VIEW_META_EVENT_TYPE,
 			timestamp: Date.now(),
@@ -156,21 +227,22 @@ var ReplayTracker = class {
 				}
 			}
 		}, false);
-		if (this.pending.length > 0) queueMicrotask(() => void this.flush(false));
 	}
-	onPageHidden(persisted = false) {
+	onPageHidden(persisted = false, terminal = false) {
 		if (persisted) return;
-		this.flush(true, true, "pageHidden");
+		if (terminal) {
+			this.requestTerminalFlush("pageHidden");
+			return;
+		}
+		this.flush(false, false, "pageHidden");
 	}
 	onPageShow(persisted = false) {
 		if (!persisted || !this.started) return;
 		if (this.pending.length > 0) this.flush(false, false, "pageShow");
 	}
-	async beginRecording(generation) {
-		const [consolePluginModule, sequentialIdPluginModule] = await Promise.all([this.options.recordConsole === true ? import("@rrweb/rrweb-plugin-console-record") : Promise.resolve(null), import("@rrweb/rrweb-plugin-sequential-id-record")]);
-		if (generation !== this.startGeneration) return;
-		const plugins = [sequentialIdPluginModule.getRecordSequentialIdPlugin({ key: REPLAY_SEQUENTIAL_ID_KEY })];
-		if (consolePluginModule) plugins.push(consolePluginModule.getRecordConsolePlugin({
+	beginRecording() {
+		const plugins = [];
+		if (this.options.recordConsole === true) plugins.push(getRecordConsolePlugin({
 			level: this.options.consoleLevel ?? [
 				"error",
 				"warn",
@@ -214,21 +286,16 @@ var ReplayTracker = class {
 			blockSelector: this.options.blockSelector,
 			maskTextClass: this.options.maskTextClass,
 			maskTextSelector: this.options.maskTextSelector,
-			checkoutEveryNms: this.options.checkoutEveryNms ?? 6e4,
+			checkoutEveryNms: this.options.checkoutEveryNms ?? 3e5,
 			checkoutEveryNth: this.options.checkoutEveryNth,
 			plugins
 		});
-		if (generation !== this.startGeneration) {
-			stop?.();
-			return;
-		}
 		this.stopRecording = stop;
 	}
-	stop() {
+	stop(discard = false) {
 		if (!this.started) return;
 		this.started = false;
 		this.disposed = true;
-		this.startGeneration++;
 		this.unsubscribeRotation?.();
 		this.unsubscribeRotation = void 0;
 		this.stopRecording?.();
@@ -237,6 +304,11 @@ var ReplayTracker = class {
 		this.clearFlushTimers();
 		this.intervalId = null;
 		window.removeEventListener("beforeunload", this.onUnload);
+		if (discard) {
+			this.clearQueues();
+			this.log("Recording discarded");
+			return;
+		}
 		if (!this.hasReachedMinLength()) {
 			this.events.length = 0;
 			this.queuedEventsSizeBytes = 0;
@@ -251,6 +323,10 @@ var ReplayTracker = class {
 		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) {
 		this.enqueueEventsIfReady(prev, {
 			isFinal: true,
@@ -266,7 +342,8 @@ var ReplayTracker = class {
 		this.startTime = next.sessionStart;
 		this.chunkStartedAt = Date.now();
 	}
-	onEvent = (event, isCheckout) => {
+	onEvent = (event, _isCheckout) => {
+		if (this.overflowed) return;
 		let capturedEvent = event;
 		if (event.type === RRWEB_EVENT_META) {
 			const data = event.data;
@@ -274,23 +351,39 @@ var ReplayTracker = class {
 				...event,
 				data: {
 					...data,
-					href: sanitizeUrl(data.href)
+					href: sanitizeUrl(data.href, this.options.trackHash ?? false)
 				}
 			};
 		}
+		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;
+		}
+		capturedEvent = Object.assign(capturedEvent, { [REPLAY_SEQUENTIAL_ID_KEY]: ++this.replayEventSequence });
 		this.events.push(capturedEvent);
 		this.queuedEventsSizeBytes += this.eventSizeBytes(capturedEvent);
 		let reason;
-		if (isCheckout) reason = "checkout";
-		else if (this.events.length >= this.maxEvents) reason = "maxEvents";
+		if (this.events.length >= this.maxEvents) reason = "maxEvents";
 		else if (this.queuedEventsSizeBytes >= this.maxBatchSizeBytes) reason = "maxBytes";
-		else if (capturedEvent.type === RRWEB_EVENT_FULL_SNAPSHOT && this.hasReachedMinLength()) reason = "fullSnapshot";
 		if (reason) this.requestFlush(reason);
 		else this.scheduleMinLengthFlush();
 	};
 	onUnload = () => {
-		this.flush(true, true, "unload");
+		this.requestTerminalFlush("unload");
 	};
+	requestTerminalFlush(reason) {
+		if (this.terminalFlushRequested) return;
+		this.terminalFlushRequested = true;
+		if (!this.hasReachedMinLength()) {
+			this.events.length = 0;
+			this.queuedEventsSizeBytes = 0;
+			this.dropMinLengthBlockedBatches();
+			return;
+		}
+		this.flush(true, true, reason);
+	}
 	hasReachedMinLength() {
 		return this.minReplayLengthMs <= 0 || Date.now() - this.startTime >= this.minReplayLengthMs;
 	}
@@ -347,7 +440,7 @@ var ReplayTracker = class {
 		return batches;
 	}
 	createBatch(events, context, isFinal, flushReason = "manual") {
-		const identifier = getAnonymousId();
+		const identifier = getAnonymousId(this.options.siteKey, this.lastCookielessMode);
 		const sequence = this.nextBatchSequence(context);
 		const chunkStartedAt = this.chunkStartedAt;
 		const now = Date.now();
@@ -364,7 +457,7 @@ var ReplayTracker = class {
 			batchId: `${context.sessionId}-${sequence}-${chunkStartedAt}`,
 			sequence,
 			timestamp: now,
-			url: sanitizeUrl(window.location.href),
+			url: this.viewUrl || sanitizeUrl(window.location.href, this.options.trackHash ?? false),
 			...isFinal ? { isFinal: true } : {},
 			flushReason,
 			events
@@ -380,10 +473,6 @@ var ReplayTracker = class {
 		batchSizeCache.set(batch, size);
 		return size;
 	}
-	dropOldestPending(reason) {
-		const batch = this.pending[0];
-		if (batch) this.removePending(batch, reason);
-	}
 	removePending(batch, reason) {
 		const index = this.pending.indexOf(batch);
 		if (index < 0) return false;
@@ -394,18 +483,20 @@ var ReplayTracker = class {
 	}
 	enqueueBatch(batch) {
 		const size = this.batchSizeBytes(batch);
-		if (size > this.maxQueueSizeBytes) {
-			this.log(`Replay batch ${batch.sequence} is ${size}B, exceeding ${this.maxQueueSizeBytes}B queue limit; dropping`);
+		if (size > this.maxQueueSizeBytes || this.pending.length >= this.maxPendingBatches || this.pendingSizeBytes + size > this.maxQueueSizeBytes) {
+			this.log(`Replay queue limit reached at batch ${batch.sequence}; stopping recording at the last complete chain`);
+			this.overflowed = true;
+			this.stopRecording?.();
+			this.stopRecording = void 0;
 			return;
 		}
-		while ((this.pending.length >= this.maxPendingBatches || this.pendingSizeBytes + size > this.maxQueueSizeBytes) && this.pending.length > 0) this.dropOldestPending("Pending queue limit reached");
 		this.pending.push(batch);
 		this.pendingSizeBytes += size;
 	}
 	async flush(lowLatency, isFinal = false, flushReason = "manual") {
-		const rotation = touchActivity(this.options.siteKey);
+		const rotation = touchActivity(this.options.siteKey, this.lastCookielessMode);
 		if (rotation) this.applySessionRotation(rotation.prev, rotation.next);
-		const context = getSessionContext(this.options.siteKey);
+		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
 		this.enqueueEventsIfReady(context, {
 			isFinal,
 			flushReason,
@@ -477,9 +568,10 @@ var ReplayTracker = class {
 	}
 	async sendBatch(batch, lowLatency) {
 		const json = JSON.stringify(batch);
+		const lowLatencySafe = lowLatency && textEncoder.encode(json).byteLength <= 61440;
 		const sendOptions = {
-			useBeacon: lowLatency,
-			keepalive: lowLatency
+			useBeacon: lowLatencySafe,
+			keepalive: lowLatencySafe
 		};
 		if (!lowLatency && (this.options.compress ?? true) && this.compressionSupported) try {
 			const stream = new Blob([json]).stream().pipeThrough(new CompressionStream("gzip"));
@@ -503,4 +595,4 @@ var ReplayTracker = class {
 	}
 };
 //#endregion
-export { ReplayTracker as default };
+export { ReplayTracker as default, sessionReplay };

package/dist/web-vitals.d.ts

@@ -1,10 +1,15 @@
+import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
 //#region src/web-vitals.d.ts
 interface WebVitalsOptions {
   siteKey: string;
   baseUrl?: string;
   debug?: boolean;
   attribution?: boolean;
+  trackHash?: boolean;
+  cookieless?: boolean;
 }
+type WebVitalsExtensionOptions = Pick<WebVitalsOptions, "attribution">;
+declare function webVitals(options?: WebVitalsExtensionOptions): AnalyticsExtension;
 declare class WebVitalsTracker {
   private readonly options;
   private readonly endpoint;
@@ -12,15 +17,15 @@ declare class WebVitalsTracker {
   private started;
   private flushing;
   private initialUrl;
-  private currentUrl;
+  private session;
+  private cookieless;
   constructor(options: WebVitalsOptions);
+  setCookielessMode(cookieless: boolean): void;
   start(): Promise<void>;
-  stop(): void;
+  stop(discard?: boolean): void;
   onPageHidden(persisted?: boolean): void;
-  trackPageChange(url?: string): void;
   private onMetric;
-  private getMetricUrl;
   private flush;
 }
 //#endregion
-export { WebVitalsOptions, WebVitalsTracker as default };
+export { WebVitalsExtensionOptions, WebVitalsOptions, WebVitalsTracker as default, webVitals };