@faststats/web 0.11.0 → 0.12.1

package/README.md

@@ -5,8 +5,8 @@
 
 The base SDK handles analytics, identity, sessions, navigation, outbound link
 clicks, and consent.
-Error tracking, Web Vitals, and session replay are independent extensions, so
-applications only download the products they use.
+Error tracking, Web Vitals, session replay, and feature flags are independent
+extensions, so applications only download the products they use.
 
 ```ts
 import { init, track } from "@faststats/web";
@@ -52,8 +52,10 @@ Consent remains client-local: use `"anonymous"` for cookieless collection,
 that the page was visible and its document had focus. It pauses when the tab is
 hidden, the window loses focus, or the page enters the back-forward cache, and
 resets on navigation, logout, or session rotation. A monotonic clock keeps
-system-clock changes from affecting this duration. Reading without interacting still counts while the page has focus;
-this metric does not infer whether a person is idle.
+system-clock changes from affecting this duration. It also pauses after 60
+seconds without pointer, keyboard, or scroll input, unless a `<video>` or
+`<audio>` element on the page is playing, and resumes on the next input. Time
+the device spent asleep or the tab frozen is not counted.
 
 Pageviews wait until the page becomes visible. Pages replaced or closed before
 being shown do not emit pageviews or page-leave events.
@@ -68,15 +70,65 @@ Each visit retains its original identity, session, and page metadata. A session
 or identity change starts a new visit, even on the same route. Both persistent
 and cookieless sessions expire after 30 minutes of inactivity or 24 hours of age.
 
-`session_duration` is elapsed wall-clock time since the session started, including
-time away. It is separate from active time on the page. Paused visits do not keep
-sending larger session durations while the user is away.
+`session_duration` is elapsed wall-clock time from the session start to the last
+counted activity. It includes time away between two active periods of the same
+session, so it is separate from active time on the page. An idle visitor stops
+extending the session, which then expires after 30 minutes like any other.
 
 Delivery is best effort: a sudden process kill or network failure can lose time
 since the last delivered checkpoint. The collector must accept successive events
 for the same visitor and URL; deploy the removal of its five-second debounce
 before releasing this SDK.
 
+### Feature flags
+
+`featureFlags()` loads the project's flags for the visitor the client tracks and
+resolves them synchronously from memory:
+
+```ts
+import { init } from "@faststats/web";
+import { featureFlags } from "@faststats/web/flags";
+
+const flags = featureFlags({ flags: ["new-checkout", "max-uploads"] });
+init({ siteKey: "site_123", extensions: [flags] });
+
+await flags.ready();
+if (flags.isEnabled("new-checkout")) showNewCheckout();
+const maxUploads = flags.get("max-uploads", 10);
+```
+
+Every loaded flag is recorded as an exposure, whether or not the app reads it,
+so list the keys the app uses in `flags`. Without it every flag in the project
+is loaded.
+
+Flags are evaluated for the anonymous visitor ID, and the session ID links each
+evaluation to analytics. `identify()` re-evaluates them for that user, so
+rollouts follow the user across devices, and `logout()` goes back to a new
+anonymous visitor. When the user is known at startup, pass `userId` to skip the
+anonymous load. A cookieless visitor has no lasting ID, so rollouts hold for the
+session only. Flags are not loaded while consent is `"denied"`.
+
+`get()` returns the default passed at the call site while flags are loading, and
+when the flag does not exist, is archived, has a different type, or the service
+cannot be reached within `timeoutMs`. `details(key)` adds the variant and reason
+(`rule_match`, `target_match`, `fallthrough`, `disabled`,
+`prerequisite_failed`).
+
+```ts
+flags.subscribe(() => render(flags.status)); // "idle" | "loading" | "ready" | "error"
+await flags.setContext({ attributes: { plan: "pro" } });
+await flags.reload();
+```
+
+| Option       |                                                          |
+| ------------ | -------------------------------------------------------- |
+| `flags`      | The flag keys to load.                                   |
+| `userId`     | Your ID for a signed-in user, when known at startup.     |
+| `attributes` | Anything targeting rules should match on.                |
+| `endpoint`   | Base URL of the flags service, when self-run.            |
+| `timeoutMs`  | Aborts a slower load. Defaults to `3000`.                |
+| `fetch`      | A `fetch` implementation to use instead of the global.   |
+
 ### Network recording in session replay
 
 Network recording is disabled by default. Enable it with

package/dist/chunks/{extensions-DZDQn8O8.d.ts → extensions-BfubKIzk.d.ts}

@@ -13,6 +13,10 @@ type ExtensionHooks = {
   consentChange: {
     cookieless: boolean;
   };
+  /** `identify()` set a user, or `logout()` cleared one. */
+  identityChange: {
+    userId: string | undefined;
+  };
   error: {
     error: Error;
   };

package/dist/chunks/{identifiers-BwGNL11R.js → identifiers-DOtve3E5.js}

@@ -1,4 +1,4 @@
-import { c as removeStorageItem, l as setStorageItem, n as createId, s as getStorageItem } from "./send-data-D520oab1.js";
+import { c as setStorageItem, o as getStorageItem, s as removeStorageItem, t as createId } from "./session-manager-DUpF3mi3.js";
 //#region src/utils/identifiers.ts
 const ANONYMOUS_ID_KEY = "faststats_anon_id_";
 function getAnonymousId(siteKey, cookieless = false) {

package/dist/chunks/send-data-gBIF6DTb.js

@@ -0,0 +1,83 @@
+//#region src/utils/api-urls.ts
+function resolveBaseUrl(baseUrl) {
+	return baseUrl?.replace(/\/+$/, "") || "https://metrics.faststats.dev";
+}
+const URLS = {
+	events: "/v1/web",
+	identify: "/v1/identify",
+	replay: "/v1/replay",
+	vitals: "/v1/vitals"
+};
+function sanitizeUrl(url, includeHash = false) {
+	try {
+		const parsed = new URL(url, location.href);
+		return `${parsed.origin}${parsed.pathname}${includeHash ? parsed.hash : ""}`;
+	} catch {
+		return url.split(includeHash ? "?" : /[?#]/, 1)[0] ?? "";
+	}
+}
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_term",
+	"utm_content"
+];
+function getReferrer() {
+	const raw = document.referrer;
+	if (!raw) return null;
+	try {
+		if (new URL(raw, location.href).origin === location.origin) return null;
+	} catch {}
+	return sanitizeUrl(raw);
+}
+function getPageContext(includeHash = false) {
+	const hash = includeHash ? location.hash : "";
+	const ctx = {
+		page: `${location.pathname}${hash}`,
+		url: sanitizeUrl(location.href, includeHash),
+		referrer: getReferrer(),
+		title: document.title
+	};
+	if (!location.search) return ctx;
+	const sp = new URLSearchParams(location.search);
+	for (const key of UTM_KEYS) {
+		const value = sp.get(key);
+		if (value) ctx[key] = value;
+	}
+	return ctx;
+}
+//#endregion
+//#region src/utils/send-data.ts
+async function sendData(options) {
+	const { url, data, contentType = "application/json", debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, settleRejected } = options;
+	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
+		const body = data instanceof Blob ? data : new Blob([data], { type: contentType });
+		if (globalThis.navigator.sendBeacon(url, body)) {
+			if (debug) console.log(`${debugPrefix} Sent via beacon`);
+			return true;
+		}
+	} catch {}
+	const size = typeof data === "string" ? data.length : data instanceof Blob ? data.size : data.byteLength;
+	const post = (keepalive) => fetch(url, {
+		method: "POST",
+		body: data,
+		headers: { "Content-Type": contentType },
+		keepalive,
+		credentials: "omit"
+	});
+	try {
+		const useKeepalive = keepalive && size <= 61440;
+		const { ok, status } = await post(useKeepalive).catch((error) => {
+			if (!useKeepalive) throw error;
+			return post(false);
+		});
+		if (debug) console.log(debugPrefix, ok ? "Sent via fetch" : status);
+		return ok || !!settleRejected && status < 500 && status !== 429;
+	} catch {
+		if (debug) console.log(debugPrefix, "Failed to send");
+		return false;
+	}
+}
+//#endregion
+export { sanitizeUrl as a, resolveBaseUrl as i, URLS as n, getPageContext as r, sendData as t };

package/dist/chunks/{send-data-D520oab1.js → session-manager-DUpF3mi3.js}

@@ -1,54 +1,3 @@
-//#region src/utils/api-urls.ts
-function resolveBaseUrl(baseUrl) {
-	return baseUrl?.replace(/\/+$/, "") || "https://metrics.faststats.dev";
-}
-const URLS = {
-	events: "/v1/web",
-	identify: "/v1/identify",
-	replay: "/v1/replay",
-	vitals: "/v1/vitals"
-};
-function sanitizeUrl(url, includeHash = false) {
-	try {
-		const parsed = new URL(url, location.href);
-		return `${parsed.origin}${parsed.pathname}${includeHash ? parsed.hash : ""}`;
-	} catch {
-		return url.split(includeHash ? "?" : /[?#]/, 1)[0] ?? "";
-	}
-}
-const UTM_KEYS = [
-	"utm_source",
-	"utm_medium",
-	"utm_campaign",
-	"utm_term",
-	"utm_content"
-];
-function getReferrer() {
-	const raw = document.referrer;
-	if (!raw) return null;
-	try {
-		const pageOrigin = new URL(location.href).origin;
-		if (new URL(raw, location.href).origin === pageOrigin) return null;
-	} catch {}
-	return sanitizeUrl(raw);
-}
-function getPageContext(includeHash = false) {
-	const hash = includeHash ? location.hash : "";
-	const ctx = {
-		page: `${location.pathname}${hash}`,
-		url: sanitizeUrl(location.href, includeHash),
-		referrer: getReferrer(),
-		title: document.title || ""
-	};
-	if (!location.search) return ctx;
-	const sp = new URLSearchParams(location.search);
-	for (const key of UTM_KEYS) {
-		const value = sp.get(key);
-		if (value) ctx[key] = value;
-	}
-	return ctx;
-}
-//#endregion
 //#region src/utils/storage.ts
 function getStorageItem(name, key) {
 	try {
@@ -188,43 +137,13 @@ function resetSession(siteKey, cookieless = false) {
 }
 function onSessionRotated(siteKey, cookieless, listener) {
 	const key = memoryKey(siteKey, cookieless);
-	let listeners = rotationListeners.get(key);
-	if (!listeners) {
-		listeners = /* @__PURE__ */ new Set();
-		rotationListeners.set(key, listeners);
-	}
+	const listeners = rotationListeners.get(key) ?? /* @__PURE__ */ new Set();
+	rotationListeners.set(key, listeners);
 	listeners.add(listener);
 	return () => {
-		listeners?.delete(listener);
-		if (listeners?.size === 0) rotationListeners.delete(key);
+		listeners.delete(listener);
+		if (listeners.size === 0) rotationListeners.delete(key);
 	};
 }
 //#endregion
-//#region src/utils/send-data.ts
-async function sendData(options) {
-	const { url, data, contentType = "application/json", debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, settleRejected } = options;
-	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
-		const beaconBody = data instanceof Blob || typeof Blob === "undefined" ? data : new Blob([data], { type: contentType });
-		if (globalThis.navigator.sendBeacon(url, beaconBody)) {
-			if (debug) console.log(`${debugPrefix} Sent via beacon`);
-			return true;
-		}
-	} catch {}
-	const size = typeof data === "string" ? data.length : data instanceof Blob ? data.size : data.byteLength;
-	try {
-		const { ok, status } = await fetch(url, {
-			method: "POST",
-			body: data,
-			headers: { "Content-Type": contentType },
-			keepalive: keepalive && size <= 61440,
-			credentials: "omit"
-		});
-		if (debug) console.log(debugPrefix, ok ? "Sent via fetch" : status);
-		return ok || !!settleRejected && status < 500 && status !== 429;
-	} catch {
-		if (debug) console.log(debugPrefix, "Failed to send");
-		return false;
-	}
-}
-//#endregion
-export { resetSession as a, removeStorageItem as c, getPageContext as d, resolveBaseUrl as f, onSessionRotated as i, setStorageItem as l, createId as n, touchActivity as o, sanitizeUrl as p, getSessionContext as r, getStorageItem as s, sendData as t, URLS as u };
+export { touchActivity as a, setStorageItem as c, resetSession as i, getSessionContext as n, getStorageItem as o, onSessionRotated as r, removeStorageItem as s, createId as t };

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/error.d.ts
 export type ErrorEntry = {
   error: string;

package/dist/error.js

@@ -1,8 +1,9 @@
-import { d as getPageContext, f as resolveBaseUrl, r as getSessionContext, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BwGNL11R.js";
+import { i as resolveBaseUrl, n as URLS, r as getPageContext, t as sendData } from "./chunks/send-data-gBIF6DTb.js";
+import { n as getSessionContext } from "./chunks/session-manager-DUpF3mi3.js";
+import { t as getAnonymousId } from "./chunks/identifiers-DOtve3E5.js";
 //#region src/error.ts
 const SDK_NAME = "@faststats/web";
-const SDK_VERSION = "0.11.0";
+const SDK_VERSION = "0.12.1";
 function errorTracking(options = {}) {
 	return {
 		name: "error-tracking",

package/dist/flags.d.ts

@@ -0,0 +1,79 @@
+import { n as AnalyticsExtensionContext, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
+//#region src/flags.d.ts
+export interface FeatureFlagsOptions {
+  /**
+   * Flag keys this app reads. Every loaded flag is recorded as an exposure,
+   * so list them to keep flags the app never shows out of analytics.
+   * Loads every flag when omitted.
+   */
+  flags?: string[];
+  /** Your own ID for a signed-in user. Rollouts follow it across devices. */
+  userId?: string;
+  /** Anything targeting rules should match on. */
+  attributes?: Record<string, unknown>;
+  /** Base URL of the feature flags service. */
+  endpoint?: string;
+  /** Aborts a load that takes longer, so flags serve their defaults. */
+  timeoutMs?: number;
+  fetch?: typeof fetch;
+}
+export type FeatureFlagReason = "disabled" | "prerequisite_failed" | "target_match" | "rule_match" | "fallthrough";
+export interface FeatureFlagResult {
+  value: unknown;
+  variant: string;
+  reason: FeatureFlagReason;
+}
+export interface FeatureFlagsContext {
+  /** Pass `null` to go back to the anonymous visitor. */
+  userId?: string | null;
+  /** Replaces the attributes set before. */
+  attributes?: Record<string, unknown>;
+}
+/**
+ * `idle` until the client starts tracking, `loading` during the first load
+ * for a visitor, then `ready`, or `error` when that load failed.
+ */
+export type FeatureFlagsStatus = "idle" | "loading" | "ready" | "error";
+/**
+ * Loads flags from the FastStats flags service for the visitor the analytics
+ * client tracks and resolves them synchronously from memory.
+ */
+export declare class FeatureFlags implements AnalyticsExtension {
+  private readonly options;
+  readonly name = "feature-flags";
+  private readonly listeners;
+  private context;
+  private results;
+  private currentStatus;
+  private latestLoad;
+  private subjectKey;
+  private loading;
+  private userId;
+  private attributes;
+  constructor(options?: FeatureFlagsOptions);
+  setup(context: AnalyticsExtensionContext): ExtensionCleanup;
+  get status(): FeatureFlagsStatus;
+  /**
+   * The flag's value, or `defaultValue` while flags are loading, when the flag
+   * does not exist or is archived, or when its type differs from the default's.
+   */
+  get(key: string, defaultValue: boolean): boolean;
+  get(key: string, defaultValue: string): string;
+  get(key: string, defaultValue: number): number;
+  get<T>(key: string, defaultValue: T): T;
+  isEnabled(key: string): boolean;
+  details(key: string): FeatureFlagResult | undefined;
+  /** Changes who flags are evaluated for and loads them again. */
+  setContext(context: FeatureFlagsContext): Promise<void>;
+  /** Resolves once the load in flight settles. Never rejects. */
+  ready(): Promise<void>;
+  /** Loads the flags again. Never rejects; a failed load sets `status`. */
+  reload(): Promise<void>;
+  /** Calls `listener` whenever the flags or `status` change. */
+  subscribe(listener: () => void): () => void;
+  private subject;
+  private evaluate;
+  private update;
+}
+export declare function featureFlags(options?: FeatureFlagsOptions): FeatureFlags;
+//#endregion

package/dist/flags.js

@@ -0,0 +1,145 @@
+import { n as getSessionContext } from "./chunks/session-manager-DUpF3mi3.js";
+import { t as getAnonymousId } from "./chunks/identifiers-DOtve3E5.js";
+//#region src/flags.ts
+const DEFAULT_ENDPOINT = "https://flags.faststats.dev";
+const DEFAULT_TIMEOUT_MS = 3e3;
+/**
+* Loads flags from the FastStats flags service for the visitor the analytics
+* client tracks and resolves them synchronously from memory.
+*/
+var FeatureFlags = class {
+	options;
+	name = "feature-flags";
+	listeners = /* @__PURE__ */ new Set();
+	context = null;
+	results = {};
+	currentStatus = "idle";
+	latestLoad = 0;
+	subjectKey = "";
+	loading = null;
+	userId;
+	attributes;
+	constructor(options = {}) {
+		this.options = options;
+		this.userId = options.userId;
+		this.attributes = options.attributes;
+	}
+	setup(context) {
+		this.context = context;
+		context.on("identityChange", ({ userId }) => {
+			this.userId = userId;
+			this.reload();
+		});
+		context.on("consentChange", () => void this.reload());
+		this.reload();
+		return () => {
+			if (this.context !== context) return;
+			this.context = null;
+			this.latestLoad++;
+			this.loading = null;
+			this.subjectKey = "";
+			this.update({}, "idle");
+		};
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	get(key, defaultValue) {
+		const result = this.details(key);
+		if (!result) return defaultValue;
+		const type = typeof defaultValue;
+		if ((type === "boolean" || type === "string" || type === "number") && typeof result.value !== type) return defaultValue;
+		return result.value;
+	}
+	isEnabled(key) {
+		return this.get(key, false);
+	}
+	details(key) {
+		return Object.hasOwn(this.results, key) ? this.results[key] : void 0;
+	}
+	/** Changes who flags are evaluated for and loads them again. */
+	setContext(context) {
+		if (context.userId !== void 0) this.userId = context.userId?.trim() || void 0;
+		if (context.attributes) this.attributes = context.attributes;
+		return this.reload();
+	}
+	/** Resolves once the load in flight settles. Never rejects. */
+	ready() {
+		return this.loading ?? Promise.resolve();
+	}
+	/** Loads the flags again. Never rejects; a failed load sets `status`. */
+	reload() {
+		const context = this.context;
+		if (!context) return Promise.resolve();
+		const load = ++this.latestLoad;
+		const subject = this.subject(context);
+		if (subject.key !== this.subjectKey) {
+			this.subjectKey = subject.key;
+			this.update({}, "loading");
+		}
+		const loading = this.evaluate(context, subject.body).then((results) => {
+			if (load === this.latestLoad) this.update(results, "ready");
+		}, (error) => {
+			if (context.debug) console.log("[FastStats] flags failed", error);
+			if (load !== this.latestLoad) return;
+			if (this.currentStatus === "loading") this.update({}, "error");
+		}).finally(() => {
+			if (this.loading === loading) this.loading = null;
+		});
+		this.loading = loading;
+		return loading;
+	}
+	/** Calls `listener` whenever the flags or `status` change. */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	subject(context) {
+		const cookieless = context.isCookieless();
+		const { sessionId } = getSessionContext(context.siteKey, cookieless);
+		const identifier = getAnonymousId(context.siteKey, cookieless) || sessionId;
+		return {
+			key: JSON.stringify([identifier, this.userId]),
+			body: {
+				identifier,
+				userId: this.userId,
+				sessionId,
+				attributes: this.attributes ?? {},
+				flags: this.options.flags && [...new Set(this.options.flags)]
+			}
+		};
+	}
+	async evaluate(context, body) {
+		const endpoint = (this.options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
+		const response = await (this.options.fetch ?? fetch)(`${endpoint}/v1/evaluate`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${context.siteKey}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+			cache: "no-store"
+		});
+		if (!response.ok) throw new Error(`Evaluation failed with status ${response.status}`);
+		const data = await response.json();
+		if (typeof data?.flags !== "object" || data.flags === null) throw new Error("Unexpected response from the flags service");
+		return data.flags;
+	}
+	update(results, status) {
+		this.results = results;
+		this.currentStatus = status;
+		for (const listener of [...this.listeners]) try {
+			listener();
+		} catch (error) {
+			if (this.context?.debug) console.log("[FastStats] flags listener failed", error);
+		}
+	}
+};
+function featureFlags(options) {
+	return new FeatureFlags(options);
+}
+//#endregion
+export { FeatureFlags, featureFlags };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as ExtensionHook, i as ExtensionHandler, n as AnalyticsExtensionContext, o as ExtensionHooks, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { a as ExtensionHook, i as ExtensionHandler, n as AnalyticsExtensionContext, o as ExtensionHooks, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/analytics.d.ts
 type ConsentMode = "anonymous" | "granted" | "denied";
 interface IdentifyOptions {
@@ -38,6 +38,7 @@ export declare class WebAnalytics {
   private pageKey;
   private visit;
   private pendingPageview;
+  private lastInputAt;
   private consentMode;
   constructor(options: WebAnalyticsOptions);
   start(): void;
@@ -65,6 +66,8 @@ export declare class WebAnalytics {
   private readonly onPageHide;
   private readonly onPageShow;
   private readonly onResume;
+  private readonly onActivity;
+  private isIdle;
   private leavePage;
   private checkpoint;
   private pauseVisit;

package/dist/index.js

@@ -1,5 +1,6 @@
-import { a as resetSession, d as getPageContext, f as resolveBaseUrl, n as createId, o as touchActivity, p as sanitizeUrl, r as getSessionContext, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
-import { n as resetAnonymousId, t as getAnonymousId } from "./chunks/identifiers-BwGNL11R.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, r as getPageContext, t as sendData } from "./chunks/send-data-gBIF6DTb.js";
+import { a as touchActivity, i as resetSession, n as getSessionContext, t as createId } from "./chunks/session-manager-DUpF3mi3.js";
+import { n as resetAnonymousId, t as getAnonymousId } from "./chunks/identifiers-DOtve3E5.js";
 //#region src/extensions.ts
 var ExtensionHost = class {
 	context;
@@ -39,11 +40,8 @@ var ExtensionHost = class {
 				...this.context,
 				on: (hook, handler) => {
 					if (this.stopped) return () => {};
-					let handlers = this.handlers.get(hook);
-					if (!handlers) {
-						handlers = /* @__PURE__ */ new Set();
-						this.handlers.set(hook, handlers);
-					}
+					const handlers = this.handlers.get(hook) ?? /* @__PURE__ */ new Set();
+					this.handlers.set(hook, handlers);
 					handlers.add(handler);
 					const off = () => handlers.delete(handler);
 					subscriptions.push(off);
@@ -131,6 +129,7 @@ const RESERVED_EVENTS = /* @__PURE__ */ new Set([
 	"error",
 	"outbound_link"
 ]);
+const IDLE_MS = 6e4;
 var WebAnalytics = class {
 	options;
 	baseUrl;
@@ -142,6 +141,7 @@ var WebAnalytics = class {
 	pageKey = "";
 	visit = null;
 	pendingPageview = null;
+	lastInputAt = 0;
 	consentMode;
 	constructor(options) {
 		this.options = options;
@@ -169,7 +169,7 @@ var WebAnalytics = class {
 		const key = location.pathname + location.search + (this.options.trackHash ? location.hash : "");
 		if (key !== this.pageKey) {
 			this.leavePage();
-			if (this.pageKey) this.extensions?.emit("pageChange", { url: getPageContext(this.options.trackHash).url ?? "" });
+			if (this.pageKey) this.extensions?.emit("pageChange", { url: getPageContext(this.options.trackHash).url });
 			this.pageKey = key;
 			this.pendingPageview = null;
 		}
@@ -189,6 +189,7 @@ var WebAnalytics = class {
 			context,
 			duration: 0,
 			startedAt: null,
+			checkedAt: Date.now(),
 			reportedDuration: -1
 		};
 		this.send("pageview", {
@@ -213,6 +214,7 @@ var WebAnalytics = class {
 		} : userOrExternalId;
 		const externalId = user.id.trim();
 		if (!externalId) return false;
+		this.extensions?.emit("identityChange", { userId: externalId });
 		const clearFields = [
 			"email",
 			"name",
@@ -246,6 +248,7 @@ var WebAnalytics = class {
 		this.leavePage();
 		if (resetAnonymousIdentity) resetAnonymousId(this.options.siteKey, this.isCookieless());
 		resetSession(this.options.siteKey, this.isCookieless());
+		this.extensions?.emit("identityChange", { userId: void 0 });
 		this.pageview({ trigger: "logout" });
 	}
 	setConsentMode(mode) {
@@ -323,12 +326,18 @@ var WebAnalytics = class {
 		this.bind(window, "focus", this.onResume);
 		this.bind(window, "blur", () => this.pauseVisit());
 		this.bind(window, "popstate", this.onNavigate);
+		for (const type of [
+			"pointerdown",
+			"pointermove",
+			"keydown",
+			"scroll"
+		]) this.bind(window, type, this.onActivity, true);
 		if (this.options.trackHash) this.bind(window, "hashchange", this.onNavigate);
 		this.cleanup.push(observeHistory(this.onNavigate), trackOutboundLinks((url) => this.send("outbound_link", { outbound_link: url })));
 	}
-	bind(target, type, listener) {
-		target.addEventListener(type, listener);
-		this.cleanup.push(() => target.removeEventListener(type, listener));
+	bind(target, type, listener, capture = false) {
+		target.addEventListener(type, listener, capture);
+		this.cleanup.push(() => target.removeEventListener(type, listener, capture));
 	}
 	onNavigate = () => this.pageview({ trigger: "navigation" });
 	onVisibilityChange = () => {
@@ -362,6 +371,17 @@ var WebAnalytics = class {
 		this.pageview(this.pendingPageview ?? { trigger: "session" });
 		this.resumeVisit();
 	};
+	onActivity = () => {
+		this.lastInputAt = performance.now();
+		if (this.visit?.startedAt === null && document.hasFocus()) this.onResume();
+	};
+	isIdle() {
+		const now = performance.now();
+		if (now - this.lastInputAt < IDLE_MS) return false;
+		const playing = [...document.querySelectorAll("video,audio")].some((media) => !media.paused && !media.ended);
+		if (playing) this.lastInputAt = now;
+		return !playing;
+	}
 	leavePage() {
 		this.pauseVisit();
 		this.visit = null;
@@ -369,10 +389,16 @@ var WebAnalytics = class {
 	checkpoint() {
 		const visit = this.visit;
 		if (!visit || !this.isActive()) return;
+		let activeAt = visit.checkedAt;
 		if (visit.startedAt !== null) {
 			const now = performance.now();
-			visit.duration += now - visit.startedAt;
+			if (now - visit.startedAt < IDLE_MS) {
+				const active = Math.min(now, this.lastInputAt + IDLE_MS) - visit.startedAt;
+				visit.duration += active;
+				activeAt += active;
+			}
 			visit.startedAt = now;
+			visit.checkedAt = Date.now();
 		}
 		const duration = Math.round(visit.duration);
 		if (duration === visit.reportedDuration) return;
@@ -380,7 +406,7 @@ var WebAnalytics = class {
 		this.send("page_leave", {
 			visit_id: visit.id,
 			time_on_page: duration,
-			session_duration: Math.max(0, Date.now() - visit.session.sessionStart)
+			session_duration: Math.max(0, activeAt - visit.session.sessionStart)
 		}, visit.context);
 	}
 	pauseVisit() {
@@ -391,9 +417,10 @@ var WebAnalytics = class {
 	}
 	resumeVisit() {
 		if (!this.isActive() || !this.visit || this.visit.startedAt !== null || document.visibilityState !== "visible" || !document.hasFocus()) return;
-		this.visit.startedAt = performance.now();
+		this.visit.startedAt = this.lastInputAt = performance.now();
+		this.visit.checkedAt = Date.now();
 		this.heartbeatTimer = setInterval(() => {
-			if (document.visibilityState !== "visible" || !document.hasFocus()) {
+			if (document.visibilityState !== "visible" || !document.hasFocus() || this.isIdle()) {
 				this.pauseVisit();
 				return;
 			}

package/dist/replay.d.ts

@@ -1,8 +1,8 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 import { record } from "@rrweb/record";
 import { LogLevel } from "@rrweb/rrweb-plugin-console-record";
 import { NetworkRecordOptions } from "@rrweb/rrweb-plugin-network-record";
-//#region ../../node_modules/.bun/@rrweb+types@2.1.6/node_modules/@rrweb/types/dist/index.d.ts
+//#region ../../node_modules/.bun/@rrweb+types@2.1.7/node_modules/@rrweb/types/dist/index.d.ts
 declare global {
   interface Window {
     FontFace: typeof FontFace;
@@ -58,7 +58,7 @@ export declare function sessionReplay(options?: SessionReplayExtensionOptions):
 export default class ReplayTracker {
   private readonly options;
   private readonly endpoint;
-  private readonly compressionSupported;
+  private readonly compress;
   private readonly flushInterval;
   private readonly maxEvents;
   private readonly maxBatchSizeBytes;
@@ -95,6 +95,8 @@ export default class ReplayTracker {
   private readonly mutationThrottler;
   constructor(options: ReplayTrackerOptions);
   private log;
+  private sessionContext;
+  private sanitize;
   private clearFlushTimers;
   private dropEvents;
   private clearQueues;
@@ -131,4 +133,5 @@ export default class ReplayTracker {
   private retryDelay;
   private sendBatch;
 }
-//#endregion
+//#endregion
+export {};

package/dist/replay.js

@@ -1,5 +1,6 @@
-import { f as resolveBaseUrl, i as onSessionRotated, l as setStorageItem, n as createId, o as touchActivity, p as sanitizeUrl, r as getSessionContext, s as getStorageItem, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BwGNL11R.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as sendData } from "./chunks/send-data-gBIF6DTb.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 { record } from "@rrweb/record";
 import { getRecordConsolePlugin } from "@rrweb/rrweb-plugin-console-record";
 import { getRecordNetworkPlugin } from "@rrweb/rrweb-plugin-network-record";
@@ -25,7 +26,7 @@ var ReplayMutationThrottler = class {
 		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;
+		if (!attributes.length && !data.adds?.length && !data.removes?.length && !data.texts?.length) return;
 		return {
 			...event,
 			data: {
@@ -95,7 +96,8 @@ function nextReplaySequence(siteKey, context, cookieless) {
 const MAX_TIMEOUT_MS = 2147483647;
 const DEFAULT_MAX_QUEUE_SIZE_BYTES = 2097152;
 const DEFAULT_MAX_BATCH_SIZE_BYTES = 921600;
-const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 61440;
+const KEEPALIVE_LIMIT_BYTES = 61440;
+const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 57344;
 const RETRY_BASE_DELAY_MS = 2e3;
 const RETRY_MAX_ATTEMPTS = 5;
 const RETRY_COOLDOWN_MS = 3e5;
@@ -104,7 +106,12 @@ const RRWEB_EVENT_FULL_SNAPSHOT = 2;
 const RRWEB_EVENT_META = 4;
 const REPLAY_SEQUENTIAL_ID_KEY = "_faststatsSeqId";
 const textEncoder = new TextEncoder();
+const eventSizeCache = /* @__PURE__ */ new WeakMap();
 const batchSizeCache = /* @__PURE__ */ new WeakMap();
+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);
@@ -133,7 +140,7 @@ function sessionReplay(options = {}) {
 var ReplayTracker = class {
 	options;
 	endpoint;
-	compressionSupported = typeof window !== "undefined" && "CompressionStream" in window;
+	compress;
 	flushInterval;
 	maxEvents;
 	maxBatchSizeBytes;
@@ -172,7 +179,8 @@ var ReplayTracker = class {
 		this.options = options;
 		this.lastCookielessMode = options.cookieless ?? false;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl)}${URLS.replay}`;
-		this.flushInterval = boundedInteger(options.flushInterval, 15e3, 1, MAX_TIMEOUT_MS);
+		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);
@@ -184,6 +192,12 @@ var ReplayTracker = class {
 	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);
@@ -214,7 +228,7 @@ var ReplayTracker = class {
 		if (this.started) this.subscribeToSessionRotation();
 		this.clearQueues();
 		this.clearFlushTimers();
-		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		const context = this.sessionContext();
 		this.activeSessionId = context.sessionId;
 		this.resetSessionTiming(context);
 		this.beginReplayStream();
@@ -227,8 +241,8 @@ var ReplayTracker = class {
 		this.overflowed = false;
 		this.replayEventSequence = 0;
 		this.viewId = createId();
-		this.viewUrl = sanitizeUrl(window.location.href, this.options.trackHash ?? false);
-		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		this.viewUrl = this.sanitize(window.location.href);
+		const context = this.sessionContext();
 		this.activeSessionId = context.sessionId;
 		this.resetSessionTiming(context);
 		this.subscribeToSessionRotation();
@@ -239,7 +253,7 @@ var ReplayTracker = class {
 	trackPageChange(url) {
 		if (!this.started) return;
 		this.viewId = createId();
-		const href = sanitizeUrl(url ?? window.location.href, this.options.trackHash ?? false);
+		const href = this.sanitize(url ?? window.location.href);
 		this.viewUrl = href;
 		this.onEvent({
 			type: VIEW_META_EVENT_TYPE,
@@ -351,12 +365,7 @@ var ReplayTracker = class {
 			this.log("Recording discarded");
 			return;
 		}
-		if (!this.hasReachedMinLength()) {
-			this.dropEvents();
-			this.needsFinalization = false;
-			this.log(`Recording too short (${Date.now() - this.startTime}ms), discarding events`);
-		}
-		this.flush(true, true, "stop");
+		this.requestTerminalFlush("stop");
 		this.log("Recording stopped");
 	}
 	onSessionRotated(prev, next) {
@@ -415,7 +424,7 @@ var ReplayTracker = class {
 				...event,
 				data: {
 					...data,
-					href: sanitizeUrl(data.href, this.options.trackHash ?? false)
+					href: this.sanitize(data.href)
 				}
 			};
 		}
@@ -446,7 +455,8 @@ var ReplayTracker = class {
 		if (!this.hasReachedMinLength()) {
 			this.dropEvents();
 			this.needsFinalization = false;
-			return;
+			this.log(`Recording too short (${Date.now() - this.startTime}ms), discarding events`);
+			if (this.pending.length === 0) return;
 		}
 		this.flush(true, true, reason);
 	}
@@ -472,12 +482,11 @@ var ReplayTracker = class {
 			return;
 		}
 		if (this.minLengthFlushTask) return;
-		const remainingMs = Math.max(0, this.minReplayLengthMs - (Date.now() - this.startTime));
 		this.minLengthFlushTask = setTimeout(() => {
 			this.minLengthFlushTask = null;
 			this.initialFlushPending = false;
 			this.requestFlush("minLength");
-		}, Math.min(remainingMs, MAX_TIMEOUT_MS));
+		}, this.minReplayLengthMs - (Date.now() - this.startTime));
 	}
 	enqueueEventsIfReady(context, flushReason, maxBatchSizeBytes = this.maxBatchSizeBytes) {
 		if (this.events.length === 0) return;
@@ -536,14 +545,19 @@ var ReplayTracker = class {
 			sequence,
 			sequenceContractVersion: 1,
 			timestamp: now,
-			url: this.viewUrl || sanitizeUrl(window.location.href, this.options.trackHash ?? false),
+			url: this.viewUrl || this.sanitize(window.location.href),
 			...isFinal ? { isFinal: true } : {},
 			flushReason,
 			events
 		};
 	}
 	eventSizeBytes(event) {
-		return textEncoder.encode(JSON.stringify(event)).byteLength + 1;
+		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);
@@ -577,7 +591,7 @@ var ReplayTracker = class {
 		}
 		const rotation = touchActivity(this.options.siteKey, this.lastCookielessMode);
 		if (rotation) this.applySessionRotation(rotation.prev, rotation.next);
-		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		const context = this.sessionContext();
 		this.enqueueEventsIfReady(context, flushReason, lowLatency ? this.maxLowLatencyBatchSizeBytes : this.maxBatchSizeBytes);
 		if (!isFinal) return this.sendPending(lowLatency);
 		this.finalizeSession(context, flushReason);
@@ -629,33 +643,25 @@ var ReplayTracker = class {
 	}
 	async sendBatch(batch, lowLatency) {
 		const json = JSON.stringify(batch);
-		const lowLatencySafe = lowLatency && this.batchSizeBytes(batch) <= DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES;
-		const sendOptions = {
+		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: lowLatencySafe,
-			keepalive: lowLatencySafe,
+			useBeacon: keepalive,
+			keepalive,
 			settleRejected: true
-		};
-		if (!lowLatency && (this.options.compress ?? true) && this.compressionSupported) try {
-			const stream = new Blob([json]).stream().pipeThrough(new CompressionStream("gzip"));
-			const compressed = new Uint8Array(await new Response(stream).arrayBuffer());
+		});
+		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 sendData({
-				url: `${this.endpoint}?encoding=gzip`,
-				data: compressed,
-				contentType: "application/octet-stream",
-				...sendOptions
-			});
+			return send(compressed, "application/octet-stream", "?encoding=gzip");
 		} catch {
 			this.log("Compression failed, using uncompressed");
 		}
-		return sendData({
-			url: this.endpoint,
-			data: json,
-			contentType: "application/json",
-			...sendOptions
-		});
+		return send(json, "application/json");
 	}
 };
 //#endregion

package/dist/web-vitals.d.ts

@@ -1,4 +1,4 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/web-vitals.d.ts
 export interface WebVitalsOptions {
   siteKey: string;
@@ -16,7 +16,8 @@ export default class WebVitalsTracker {
   private sending?;
   private generation;
   private unsubscribe?;
-  private readonly sentMetrics;
+  private unfollowSession?;
+  private sentMetrics;
   private initialUrl;
   private session;
   private cookieless;
@@ -25,6 +26,7 @@ export default class WebVitalsTracker {
   start(): void;
   stop(discard?: boolean): void;
   onPageHidden(persisted?: boolean): void;
+  private followSession;
   private onMetric;
   private discard;
   private flush;

package/dist/web-vitals.js

@@ -1,35 +1,49 @@
-import { f as resolveBaseUrl, p as sanitizeUrl, r as getSessionContext, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as sendData } from "./chunks/send-data-gBIF6DTb.js";
+import { n as getSessionContext, r as onSessionRotated } from "./chunks/session-manager-DUpF3mi3.js";
 import { onCLS, onFCP, onINP, onLCP, onTTFB } from "web-vitals/attribution";
 //#region src/utils/web-vitals-collector.ts
 const collectors = /* @__PURE__ */ new WeakMap();
+function getCollector() {
+	const existing = collectors.get(document);
+	if (existing) return existing;
+	const collector = {
+		subscribers: /* @__PURE__ */ new Set(),
+		latest: /* @__PURE__ */ new Map(),
+		sent: /* @__PURE__ */ new Map()
+	};
+	collectors.set(document, collector);
+	const report = (metric) => {
+		const snapshot = { ...metric };
+		snapshot.attribution = { ...metric.attribution };
+		collector.latest.set(metric.name, snapshot);
+		for (const listener of collector.subscribers) listener(snapshot);
+	};
+	const changes = { reportAllChanges: true };
+	onCLS(report, changes);
+	onINP(report, changes);
+	onLCP(report, changes);
+	onFCP(report);
+	onTTFB(report);
+	return collector;
+}
 function subscribeToVitals(subscriber) {
-	let collector = collectors.get(document);
-	if (!collector) {
-		collector = {
-			subscribers: /* @__PURE__ */ new Set(),
-			latest: /* @__PURE__ */ new Map()
-		};
-		collectors.set(document, collector);
-		const { latest, subscribers } = collector;
-		const report = (metric) => {
-			const snapshot = { ...metric };
-			snapshot.attribution = { ...metric.attribution };
-			latest.set(metric.name, snapshot);
-			for (const listener of subscribers) listener(snapshot);
-		};
-		const changes = { reportAllChanges: true };
-		onCLS(report, changes);
-		onINP(report, changes);
-		onLCP(report, changes);
-		onFCP(report);
-		onTTFB(report);
-	}
-	collector.subscribers.add(subscriber);
-	for (const metric of collector.latest.values()) subscriber(metric);
+	const { subscribers, latest } = getCollector();
+	subscribers.add(subscriber);
+	for (const metric of latest.values()) subscriber(metric);
 	return () => {
-		collector.subscribers.delete(subscriber);
+		subscribers.delete(subscriber);
 	};
 }
+/**
+* What `destination` already received from this document. Shared so a
+* re-created tracker does not resend the metrics replayed to it.
+*/
+function sentVitals(destination) {
+	const { sent } = getCollector();
+	const vitals = sent.get(destination) ?? /* @__PURE__ */ new Map();
+	sent.set(destination, vitals);
+	return vitals;
+}
 //#endregion
 //#region src/web-vitals.ts
 function webVitals() {
@@ -50,13 +64,6 @@ function webVitals() {
 		}
 	};
 }
-const METRIC_NAMES = /* @__PURE__ */ new Set([
-	"CLS",
-	"INP",
-	"LCP",
-	"FCP",
-	"TTFB"
-]);
 var WebVitalsTracker = class {
 	options;
 	endpoint;
@@ -65,6 +72,7 @@ var WebVitalsTracker = class {
 	sending;
 	generation = 0;
 	unsubscribe;
+	unfollowSession;
 	sentMetrics = /* @__PURE__ */ new Map();
 	initialUrl = "";
 	session = null;
@@ -77,21 +85,21 @@ var WebVitalsTracker = class {
 	setCookielessMode(cookieless) {
 		if (this.cookieless === cookieless) return;
 		this.cookieless = cookieless;
-		this.discard();
-		this.session = this.started ? getSessionContext(this.options.siteKey, cookieless) : null;
+		if (this.started) this.followSession();
 	}
 	start() {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
 		this.initialUrl = sanitizeUrl(window.performance?.getEntriesByType("navigation")[0]?.name || window.location.href, this.options.trackHash ?? false);
-		this.session = getSessionContext(this.options.siteKey, this.cookieless);
+		this.followSession();
+		this.sentMetrics = sentVitals(`${this.endpoint}\0${this.options.siteKey}`);
 		this.unsubscribe = subscribeToVitals(this.onMetric);
 	}
 	stop(discard = false) {
 		if (!this.started) return;
 		this.started = false;
 		this.unsubscribe?.();
-		this.unsubscribe = void 0;
+		this.unfollowSession?.();
 		if (discard) this.discard();
 		else this.flush();
 	}
@@ -102,26 +110,39 @@ var WebVitalsTracker = class {
 			if (generation === this.generation) this.flush();
 		});
 	}
+	followSession() {
+		const { siteKey } = this.options;
+		this.unfollowSession?.();
+		this.session = getSessionContext(siteKey, this.cookieless);
+		this.unfollowSession = onSessionRotated(siteKey, this.cookieless, (_prev, next) => {
+			this.session = next;
+		});
+	}
 	onMetric = (metric) => {
-		if (!this.started || !METRIC_NAMES.has(metric.name) || !Number.isFinite(metric.value) || metric.value < 0) return;
+		if (!this.started || !Number.isFinite(metric.value) || metric.value < 0) return;
 		this.metrics.set(metric.name, metric);
 	};
 	discard() {
 		this.generation++;
 		this.metrics.clear();
-		this.sentMetrics.clear();
 	}
 	async flush() {
 		const generation = this.generation;
 		while (this.sending) await this.sending;
-		if (generation !== this.generation || !this.metrics.size) return;
-		const batch = this.metrics;
-		const session = this.session ?? getSessionContext(this.options.siteKey, this.cookieless);
+		const session = this.session;
+		if (generation !== this.generation || !session) return;
+		const batch = [...this.metrics.values()].filter(({ name, id, value }) => {
+			const sent = this.sentMetrics.get(name);
+			return sent?.id !== id || sent.value !== value;
+		});
+		this.metrics = /* @__PURE__ */ new Map();
+		if (!batch.length) return;
+		const trackHash = this.options.trackHash ?? false;
 		const data = JSON.stringify({
 			token: this.options.siteKey,
 			sessionId: session.sessionId,
 			windowId: session.windowId,
-			vitals: [...batch.values()].map(({ name, value, id, rating, navigationType, attribution }) => {
+			vitals: batch.map(({ name, value, id, rating, navigationType, attribution }) => {
 				const previous = this.sentMetrics.get(name);
 				return {
 					metric: name,
@@ -136,8 +157,7 @@ var WebVitalsTracker = class {
 				};
 			}),
 			metadata: { url: this.initialUrl }
-		});
-		this.metrics = /* @__PURE__ */ new Map();
+		}, (_key, value) => typeof value === "string" && /^https?:\/\//.test(value) ? sanitizeUrl(value, trackHash) : value);
 		this.sending = sendData({
 			url: this.endpoint,
 			data,
@@ -146,12 +166,8 @@ var WebVitalsTracker = class {
 		});
 		const sent = await this.sending;
 		this.sending = void 0;
-		if (generation !== this.generation) return;
-		for (const [name, vital] of batch) if (sent) this.sentMetrics.set(name, {
-			id: vital.id,
-			value: vital.value
-		});
-		else if (!this.metrics.has(name)) this.metrics.set(name, vital);
+		for (const vital of batch) if (sent) this.sentMetrics.set(vital.name, vital);
+		else if (generation === this.generation && !this.metrics.has(vital.name)) this.metrics.set(vital.name, vital);
 	}
 };
 //#endregion

package/package.json

@@ -23,6 +23,11 @@
 			"import": "./dist/error.js",
 			"default": "./dist/error.js"
 		},
+		"./flags": {
+			"types": "./dist/flags.d.ts",
+			"import": "./dist/flags.js",
+			"default": "./dist/flags.js"
+		},
 		"./web-vitals": {
 			"types": "./dist/web-vitals.d.ts",
 			"import": "./dist/web-vitals.js",
@@ -37,7 +42,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "0.11.0",
+	"version": "0.12.1",
 	"scripts": {
 		"build": "tsdown && bun run check-size",
 		"dev": "bun run build",
@@ -46,15 +51,15 @@
 		"check-size": "node scripts/check-bundle-size.mjs"
 	},
 	"devDependencies": {
-		"@rrweb/types": "^2.1.6",
+		"@rrweb/types": "^2.1.7",
 		"@types/bun": "^1.4.2",
 		"tsdown": "^0.23.0",
 		"typescript": "^7.0.2"
 	},
 	"dependencies": {
-		"@rrweb/record": "^2.1.6",
-		"@rrweb/rrweb-plugin-console-record": "^2.1.6",
-		"@rrweb/rrweb-plugin-network-record": "^2.1.6",
-		"web-vitals": "^6.2.2"
+		"@rrweb/record": "^2.1.7",
+		"@rrweb/rrweb-plugin-console-record": "^2.1.7",
+		"@rrweb/rrweb-plugin-network-record": "^2.1.7",
+		"web-vitals": "^6.2.3"
 	}
 }