@faststats/web 0.7.0 → 0.8.1

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,130 @@
-import { n as ReplayTrackerOptions, t as ReplayTracker } from "./chunks/replay-BeC2XA4N.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 activeSessionId;
+  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 beginReplayStream;
+  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,7 +1,8 @@
-import { a as resolveBaseUrl, o as sanitizeUrl, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-Dp2XNjRF.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-DR1JUXka.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BvRNbiwA.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;
@@ -52,18 +53,39 @@ var ReplayMutationThrottler = class {
 //#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 = 900 * 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;
@@ -85,7 +107,6 @@ var ReplayTracker = class {
 	chunkStartedAt = 0;
 	started = false;
 	disposed = false;
-	startGeneration = 0;
 	startTime = 0;
 	sequence = 0;
 	intervalId = null;
@@ -94,16 +115,19 @@ var ReplayTracker = class {
 	retryAttempt = 0;
 	minLengthFlushTask = null;
 	stopRecording;
+	activeSessionId = "";
 	sending = false;
 	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 ?? 15e3;
 		this.maxEvents = options.maxEvents ?? 1e3;
@@ -166,10 +190,14 @@ var ReplayTracker = class {
 	setCookielessMode(cookieless) {
 		if (this.lastCookielessMode === cookieless) return;
 		this.lastCookielessMode = cookieless;
+		if (this.started) this.subscribeToSessionRotation();
 		this.clearQueues();
 		this.clearFlushTimers();
-		this.startTime = getSessionContext(this.options.siteKey).sessionStart;
+		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		this.activeSessionId = context.sessionId;
+		this.startTime = context.sessionStart;
 		this.chunkStartedAt = Date.now();
+		this.beginReplayStream();
 	}
 	start() {
 		if (this.started || typeof window === "undefined") return;
@@ -177,15 +205,15 @@ var ReplayTracker = class {
 		this.disposed = false;
 		this.terminalFlushRequested = false;
 		this.overflowed = false;
+		this.replayEventSequence = 0;
 		this.viewId = createId();
 		this.viewUrl = sanitizeUrl(window.location.href, this.options.trackHash ?? false);
-		this.startTime = getSessionContext(this.options.siteKey).sessionStart;
+		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		this.activeSessionId = context.sessionId;
+		this.startTime = context.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");
@@ -219,11 +247,9 @@ var ReplayTracker = class {
 		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",
@@ -267,21 +293,16 @@ var ReplayTracker = class {
 			blockSelector: this.options.blockSelector,
 			maskTextClass: this.options.maskTextClass,
 			maskTextSelector: this.options.maskTextSelector,
-			checkoutEveryNms: this.options.checkoutEveryNms ?? 5 * 6e4,
+			checkoutEveryNms: this.options.checkoutEveryNms ?? 3e5,
 			checkoutEveryNth: this.options.checkoutEveryNth,
 			plugins
 		});
-		if (generation !== this.startGeneration) {
-			stop?.();
-			return;
-		}
 		this.stopRecording = stop;
 	}
 	stop(discard = false) {
 		if (!this.started) return;
 		this.started = false;
 		this.disposed = true;
-		this.startGeneration++;
 		this.unsubscribeRotation?.();
 		this.unsubscribeRotation = void 0;
 		this.stopRecording?.();
@@ -309,14 +330,41 @@ 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) {
+		if (this.activeSessionId === next.sessionId) return;
 		this.enqueueEventsIfReady(prev, {
 			isFinal: true,
 			flushReason: "sessionRotate"
 		});
 		this.finalizeSessionPending(prev, "sessionRotate");
 		this.unblockSessionBatches(prev.sessionId);
+		this.activeSessionId = next.sessionId;
 		this.resetSessionTiming(next);
+		this.beginReplayStream();
+	}
+	beginReplayStream() {
+		this.replayEventSequence = 0;
+		const stopRecording = this.stopRecording;
+		if (!stopRecording) return;
+		try {
+			record.takeFullSnapshot(true);
+		} catch (snapshotError) {
+			this.stopRecording = void 0;
+			try {
+				stopRecording();
+				this.replayEventSequence = 0;
+				this.beginRecording();
+			} catch (restartError) {
+				this.log("Failed to restart replay stream", {
+					snapshotError,
+					restartError
+				});
+			}
+		}
 	}
 	resetSessionTiming(next) {
 		if (this.minLengthFlushTask) clearTimeout(this.minLengthFlushTask);
@@ -343,6 +391,7 @@ var ReplayTracker = class {
 			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;
@@ -421,7 +470,7 @@ var ReplayTracker = class {
 		return batches;
 	}
 	createBatch(events, context, isFinal, flushReason = "manual") {
-		const identifier = getAnonymousId(this.options.siteKey);
+		const identifier = getAnonymousId(this.options.siteKey, this.lastCookielessMode);
 		const sequence = this.nextBatchSequence(context);
 		const chunkStartedAt = this.chunkStartedAt;
 		const now = Date.now();
@@ -475,9 +524,9 @@ var ReplayTracker = class {
 		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,
@@ -549,7 +598,7 @@ var ReplayTracker = class {
 	}
 	async sendBatch(batch, lowLatency) {
 		const json = JSON.stringify(batch);
-		const lowLatencySafe = lowLatency && textEncoder.encode(json).byteLength <= 60 * 1024;
+		const lowLatencySafe = lowLatency && textEncoder.encode(json).byteLength <= 61440;
 		const sendOptions = {
 			useBeacon: lowLatencySafe,
 			keepalive: lowLatencySafe
@@ -576,4 +625,4 @@ var ReplayTracker = class {
 	}
 };
 //#endregion
-export { ReplayTracker as default };
+export { ReplayTracker as default, sessionReplay };

package/dist/web-vitals.d.ts

@@ -1,3 +1,4 @@
+import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
 //#region src/web-vitals.d.ts
 interface WebVitalsOptions {
   siteKey: string;
@@ -5,7 +6,10 @@ interface WebVitalsOptions {
   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;
@@ -14,7 +18,9 @@ declare class WebVitalsTracker {
   private flushing;
   private initialUrl;
   private session;
+  private cookieless;
   constructor(options: WebVitalsOptions);
+  setCookielessMode(cookieless: boolean): void;
   start(): Promise<void>;
   stop(discard?: boolean): void;
   onPageHidden(persisted?: boolean): void;
@@ -22,4 +28,4 @@ declare class WebVitalsTracker {
   private flush;
 }
 //#endregion
-export { WebVitalsOptions, WebVitalsTracker as default };
+export { WebVitalsExtensionOptions, WebVitalsOptions, WebVitalsTracker as default, webVitals };

package/dist/web-vitals.js

@@ -1,6 +1,25 @@
-import { a as resolveBaseUrl, o as sanitizeUrl, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-Dp2XNjRF.js";
-import { r as getSessionContext, t as sendData } from "./chunks/send-data-DR1JUXka.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-DWk43fu6.js";
+import { r as getSessionContext, t as sendData } from "./chunks/send-data-DFZnsaL2.js";
 //#region src/web-vitals.ts
+function webVitals(options = {}) {
+	return {
+		name: "web-vitals",
+		async setup(context) {
+			const tracker = new WebVitalsTracker({
+				...options,
+				siteKey: context.siteKey,
+				baseUrl: context.baseUrl,
+				debug: context.debug,
+				trackHash: context.trackHash,
+				cookieless: context.isCookieless()
+			});
+			context.on("pageHide", ({ persisted }) => tracker.onPageHidden(persisted));
+			context.on("consentChange", ({ cookieless }) => tracker.setCookielessMode(cookieless));
+			await tracker.start();
+			return ({ discard }) => tracker.stop(discard);
+		}
+	};
+}
 const METRIC_NAMES = /* @__PURE__ */ new Set([
 	"CLS",
 	"INP",
@@ -16,23 +35,31 @@ var WebVitalsTracker = class {
 	flushing = false;
 	initialUrl = "";
 	session = null;
+	cookieless;
 	constructor(options) {
 		this.options = options;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.vitals}`;
+		this.cookieless = options.cookieless ?? false;
+	}
+	setCookielessMode(cookieless) {
+		if (this.cookieless === cookieless) return;
+		this.cookieless = cookieless;
+		this.metrics.clear();
+		this.session = this.started ? getSessionContext(this.options.siteKey, cookieless) : null;
 	}
 	async start() {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
 		this.initialUrl = sanitizeUrl(window.location.href, this.options.trackHash ?? false);
-		this.session = getSessionContext(this.options.siteKey);
-		const mod = await (this.options.attribution ? import("web-vitals/attribution") : import("web-vitals"));
+		this.session = getSessionContext(this.options.siteKey, this.cookieless);
+		const vitals = this.options.attribution ? await import("web-vitals/attribution") : await import("web-vitals");
 		if (!this.started) return;
 		const changes = { reportAllChanges: true };
-		mod.onCLS(this.onMetric, changes);
-		mod.onINP(this.onMetric, changes);
-		mod.onLCP(this.onMetric, changes);
-		mod.onFCP(this.onMetric);
-		mod.onTTFB(this.onMetric);
+		vitals.onCLS(this.onMetric, changes);
+		vitals.onINP(this.onMetric, changes);
+		vitals.onLCP(this.onMetric, changes);
+		vitals.onFCP(this.onMetric);
+		vitals.onTTFB(this.onMetric);
 	}
 	stop(discard = false) {
 		if (!this.started) return;
@@ -49,7 +76,7 @@ var WebVitalsTracker = class {
 		const name = metric.name;
 		if (!METRIC_NAMES.has(name) || !Number.isFinite(metric.value) || metric.value < 0) return;
 		const { id, rating, delta, navigationType } = metric;
-		const attribution = "attribution" in metric && metric.attribution ? metric.attribution : void 0;
+		const attribution = this.options.attribution && "attribution" in metric && metric.attribution ? metric.attribution : void 0;
 		this.metrics.set(name, {
 			metric: name,
 			value: metric.value,
@@ -67,7 +94,7 @@ var WebVitalsTracker = class {
 		this.flushing = true;
 		const batch = this.metrics;
 		this.metrics = /* @__PURE__ */ new Map();
-		const session = this.session ?? getSessionContext(this.options.siteKey);
+		const session = this.session ?? getSessionContext(this.options.siteKey, this.cookieless);
 		let sent = false;
 		try {
 			sent = await sendData({
@@ -91,4 +118,4 @@ var WebVitalsTracker = class {
 	}
 };
 //#endregion
-export { WebVitalsTracker as default };
+export { WebVitalsTracker as default, webVitals };

package/package.json

@@ -13,10 +13,10 @@
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
-		"./feature-flags": {
-			"types": "./dist/feature-flags.d.ts",
-			"import": "./dist/feature-flags.js",
-			"default": "./dist/feature-flags.js"
+		"./outbound-links": {
+			"types": "./dist/outbound-links.d.ts",
+			"import": "./dist/outbound-links.js",
+			"default": "./dist/outbound-links.js"
 		},
 		"./replay": {
 			"types": "./dist/replay.d.ts",
@@ -42,7 +42,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "0.7.0",
+	"version": "0.8.1",
 	"scripts": {
 		"build": "tsdown && bun run check-size",
 		"dev": "bun run build",
@@ -51,15 +51,14 @@
 		"check-size": "node scripts/check-bundle-size.mjs"
 	},
 	"devDependencies": {
-		"@rrweb/types": "^2.0.1",
-		"@types/bun": "latest",
-		"tsdown": "^0.22.3",
+		"@rrweb/types": "^2.1.1",
+		"@types/bun": "^1.4.0",
+		"tsdown": "^0.22.14",
 		"typescript": "^6.0.3"
 	},
 	"dependencies": {
-		"@rrweb/record": "^2.1.0",
-		"@rrweb/rrweb-plugin-console-record": "^2.1.0",
-		"@rrweb/rrweb-plugin-sequential-id-record": "^2.1.0",
-		"web-vitals": "^6.0.0"
+		"@rrweb/record": "^2.1.1",
+		"@rrweb/rrweb-plugin-console-record": "^2.1.1",
+		"web-vitals": "^6.2.1"
 	}
 }