@maple-dev/browser 0.9.0 → 0.10.1

package/dist/{sink-DHPiMgU0.mjs → sink-BOR9_z4b.mjs}

@@ -82,6 +82,104 @@ function scrubUrl(url) {
 	return out;
 }
 //#endregion
+//#region ../browser-session/src/platform/cookie.ts
+/** Scope cookies to the registered domain so subdomains share them. */
+let crossSubdomainCookie = true;
+/** Explicit `Domain=` override; `""` forces a host-only cookie. */
+let cookieDomainOverride;
+/** Memoized probe result. `undefined` = not resolved yet. */
+let probedCookieDomain;
+/**
+* Apply the host app's cookie configuration. Called from `configurePrivacy`, so
+* both SDKs get it from the single call they already make.
+*
+* Like the consent gates, this only ever *tightens*: an app that initializes two
+* SDKs, only one of which passes a `privacy` block, must not have the other's
+* absent option widen the cookie back out to every subdomain.
+*
+* "Tighter" for `cookieDomain` means *narrower scope*, which is why this is not
+* first-write-wins: `""` (host-only) is the tightest value there is, and a
+* second SDK asking for it has to win over an earlier `"example.com"`. Between
+* two non-empty domains the shorter one is the broader (`example.com` covers
+* `app.example.com`, not the reverse), so the longer string wins.
+*/
+function configureCookieScope(options) {
+	if (options.crossSubdomainCookie === false) crossSubdomainCookie = false;
+	if (options.cookieDomain !== void 0) cookieDomainOverride = tighterCookieDomain(cookieDomainOverride, options.cookieDomain);
+	probedCookieDomain = void 0;
+}
+/** The narrower of two `Domain=` values, treating `undefined` as "unset". */
+function tighterCookieDomain(current, next) {
+	if (current === void 0) return next;
+	if (current === "" || next === "") return "";
+	return next.length > current.length ? next : current;
+}
+function readRawCookie(name) {
+	if (typeof document === "undefined") return void 0;
+	try {
+		for (const part of document.cookie.split(";")) {
+			const raw = part.trim();
+			if (!raw.startsWith(`${name}=`)) continue;
+			return decodeURIComponent(raw.slice(name.length + 1));
+		}
+	} catch {}
+}
+function setRawCookie(name, value, domain, maxAgeSeconds) {
+	if (typeof document === "undefined") return false;
+	const attributes = [
+		`${name}=${encodeURIComponent(value)}`,
+		"path=/",
+		`max-age=${Math.max(0, Math.floor(maxAgeSeconds))}`,
+		"SameSite=Lax"
+	];
+	if (domain) attributes.push(`domain=.${domain}`);
+	if (typeof location !== "undefined" && location.protocol === "https:") attributes.push("Secure");
+	try {
+		document.cookie = attributes.join("; ");
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Expire `name` on the shared domain and host-only: it may predate a narrowed scope. */
+function deleteRawCookie(name) {
+	const domain = cookieDomain();
+	setRawCookie(name, "", domain, 0);
+	if (domain) setRawCookie(name, "", "", 0);
+}
+/**
+* The broadest domain this browser will actually accept a cookie for, found by
+* probing rather than by carrying a public-suffix list, the same trick
+* posthog-js uses. Candidates start at the broadest (the last two labels) and
+* narrow a label at a time, with the first that sticks winning, so
+* `app.example.co.uk` tries the rejected `co.uk`, then lands on `example.co.uk`.
+*
+* Returns `""` (host-only cookie) for single-label hosts like `localhost` and
+* for bare IPs, neither of which can carry a `Domain=` attribute.
+*/
+function probeCookieDomain() {
+	if (typeof document === "undefined" || typeof location === "undefined") return "";
+	const hostname = location.hostname;
+	if (!hostname || /^[\d.]+$/.test(hostname) || hostname.includes(":")) return "";
+	const parts = hostname.split(".");
+	if (parts.length < 2) return "";
+	for (let i = parts.length - 2; i >= 0; i--) {
+		const candidate = parts.slice(i).join(".");
+		const probe = "__maple_probe";
+		if (setRawCookie(probe, "1", candidate, 60) && readRawCookie(probe) === "1") {
+			setRawCookie(probe, "", candidate, 0);
+			return candidate;
+		}
+	}
+	return "";
+}
+function cookieDomain() {
+	if (cookieDomainOverride !== void 0) return cookieDomainOverride;
+	if (!crossSubdomainCookie) return "";
+	if (probedCookieDomain === void 0) probedCookieDomain = probeCookieDomain();
+	return probedCookieDomain;
+}
+//#endregion
 //#region ../browser-session/src/platform/json.ts
 /**
 * Minimal structural guards for records read back out of browser storage.
@@ -126,6 +224,88 @@ function isStringRecord(value) {
 	return isJsonObject(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 //#endregion
+//#region ../browser-session/src/session/idle.ts
+/**
+* Rotate the session after this much inactivity (PostHog's default). The visit
+* claim uses the same window: longer and a rotated session goes unbilled,
+* shorter and one continuous visit is billed twice.
+*/
+const IDLE_TIMEOUT_MS = 18e5;
+//#endregion
+//#region ../browser-session/src/identity/visit.ts
+/**
+* The billable unit: one visit per visitor per idle window, across every tab and
+* subdomain. `SessionId` cannot be that unit: sessionStorage scopes it to one
+* tab and one origin, and it must stay that way because `session_replays`
+* resolves each `(OrgId, SessionId)` by `argMax(field, Version)` over the whole
+* row, so two tabs sharing an id would overwrite each other.
+*
+* The marker is the visit's latest activity, not the moment it was claimed:
+* active tabs keep extending it, so a tab opened an hour into a busy visit is
+* not a second charge, and 30 idle minutes (a session rotation) start a new one.
+*/
+const STORAGE_KEY$2 = "maple.visit";
+/** Cookie names cannot contain `.` per RFC 6265's token grammar. */
+const COOKIE_NAME$1 = "maple_visit";
+/** In-memory copy: all a page load has when persistence is off or blocked. */
+let ephemeral$1;
+function parseMarker(raw) {
+	if (!raw) return void 0;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function readMarker(persist) {
+	if (!persist) return ephemeral$1;
+	const fromCookie = parseMarker(readRawCookie(COOKIE_NAME$1));
+	if (fromCookie !== void 0) return fromCookie;
+	try {
+		const fromStorage = parseMarker(window.localStorage.getItem(STORAGE_KEY$2));
+		if (fromStorage !== void 0) return fromStorage;
+	} catch {}
+	return ephemeral$1;
+}
+function writeMarker(at, persist) {
+	ephemeral$1 = at;
+	if (!persist) return;
+	const value = String(at);
+	try {
+		window.localStorage.setItem(STORAGE_KEY$2, value);
+	} catch {}
+	setRawCookie(COOKIE_NAME$1, value, cookieDomain(), (IDLE_TIMEOUT_MS - (Date.now() - at)) / 1e3);
+}
+function withinVisit(marker, at) {
+	return marker !== void 0 && Math.abs(at - marker) < 18e5;
+}
+/**
+* Claim the visit `at` belongs to, returning whether this caller is the one
+* charged for it. `persist` is false when visitor tracking is off, which keeps
+* the claim in memory: no identifier-adjacent cookie the host app opted out of.
+*/
+function claimVisit(at, persist) {
+	if (typeof window === "undefined") return false;
+	const marker = readMarker(persist);
+	if (withinVisit(marker, at)) {
+		if (at > marker) writeMarker(at, persist);
+		return false;
+	}
+	writeMarker(at, persist);
+	return true;
+}
+/** Extend the current visit to `at`. Never opens one: only `claimVisit` does. */
+function touchVisit(at, persist) {
+	if (typeof window === "undefined") return;
+	const marker = readMarker(persist);
+	if (withinVisit(marker, at) && at > marker) writeMarker(at, persist);
+}
+/** Drop the claim from every store, for a visitor-tracking opt-out. */
+function clearVisitClaim() {
+	ephemeral$1 = void 0;
+	try {
+		window.localStorage.removeItem(STORAGE_KEY$2);
+	} catch {}
+	deleteRawCookie(COOKIE_NAME$1);
+}
+//#endregion
 //#region ../browser-session/src/identity/visitor.ts
 /**
 * A persistent per-browser visitor id.
@@ -183,96 +363,11 @@ let enabled = true;
 let cached;
 let persisted = false;
 let mintedThisLoad = false;
-/** Scope the cookie to the registered domain so subdomains share the id. */
-let crossSubdomainCookie = true;
-/** Explicit `Domain=` override; `""` forces a host-only cookie. */
-let cookieDomainOverride;
-/** Memoized probe result. `undefined` = not resolved yet. */
-let probedCookieDomain;
 /**
-* Apply the host app's cookie configuration. Called from `configurePrivacy`, so
-* both SDKs get it from the single call they already make.
-*
-* Like the consent gates, this only ever *tightens*: an app that initializes two
-* SDKs, only one of which passes a `privacy` block, must not have the other's
-* absent option widen the cookie back out to every subdomain.
-*
-* "Tighter" for `cookieDomain` means *narrower scope*, which is why this is not
-* first-write-wins: `""` (host-only) is the tightest value there is, and a
-* second SDK asking for it has to win over an earlier `"example.com"`. Between
-* two non-empty domains the shorter one is the broader — `example.com` covers
-* `app.example.com` and not the reverse — so the longer string wins.
-*/
-function configureVisitorCookie(options) {
-	if (options.crossSubdomainCookie === false) crossSubdomainCookie = false;
-	if (options.cookieDomain !== void 0) cookieDomainOverride = tighterCookieDomain(cookieDomainOverride, options.cookieDomain);
-	probedCookieDomain = void 0;
-}
-/** The narrower of two `Domain=` values, treating `undefined` as "unset". */
-function tighterCookieDomain(current, next) {
-	if (current === void 0) return next;
-	if (current === "" || next === "") return "";
-	return next.length > current.length ? next : current;
-}
-function readRawCookie(name) {
-	if (typeof document === "undefined") return void 0;
-	try {
-		for (const part of document.cookie.split(";")) {
-			const raw = part.trim();
-			if (!raw.startsWith(`${name}=`)) continue;
-			return decodeURIComponent(raw.slice(name.length + 1));
-		}
-	} catch {}
-}
-function setRawCookie(name, value, domain, maxAgeSeconds) {
-	if (typeof document === "undefined") return false;
-	const attributes = [
-		`${name}=${encodeURIComponent(value)}`,
-		"path=/",
-		`max-age=${Math.max(0, Math.floor(maxAgeSeconds))}`,
-		"SameSite=Lax"
-	];
-	if (domain) attributes.push(`domain=.${domain}`);
-	if (typeof location !== "undefined" && location.protocol === "https:") attributes.push("Secure");
-	try {
-		document.cookie = attributes.join("; ");
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* The broadest domain this browser will actually accept a cookie for, found by
-* probing rather than by carrying a public-suffix list — the same trick
-* posthog-js uses. Candidates start at the broadest (the last two labels) and
-* narrow a label at a time, with the first that sticks winning — so
-* `app.example.co.uk` tries the rejected `co.uk`, then lands on `example.co.uk`.
-*
-* Returns `""` (host-only cookie) for single-label hosts like `localhost` and
-* for bare IPs, neither of which can carry a `Domain=` attribute.
+* Kept under this name because `configurePrivacy` and the SDK tests call it;
+* the domain decision lives in `platform/cookie.ts`, shared with the visit claim.
 */
-function probeCookieDomain() {
-	if (typeof document === "undefined" || typeof location === "undefined") return "";
-	const hostname = location.hostname;
-	if (!hostname || /^[\d.]+$/.test(hostname) || hostname.includes(":")) return "";
-	const parts = hostname.split(".");
-	if (parts.length < 2) return "";
-	for (let i = parts.length - 2; i >= 0; i--) {
-		const candidate = parts.slice(i).join(".");
-		const probe = "__maple_probe";
-		if (setRawCookie(probe, "1", candidate, 60) && readRawCookie(probe) === "1") {
-			setRawCookie(probe, "", candidate, 0);
-			return candidate;
-		}
-	}
-	return "";
-}
-function cookieDomain() {
-	if (cookieDomainOverride !== void 0) return cookieDomainOverride;
-	if (!crossSubdomainCookie) return "";
-	if (probedCookieDomain === void 0) probedCookieDomain = probeCookieDomain();
-	return probedCookieDomain;
-}
+const configureVisitorCookie = configureCookieScope;
 function parseRecord(raw) {
 	if (!raw) return void 0;
 	const value = parseJsonObject(raw);
@@ -383,9 +478,8 @@ function setVisitorTracking(nextEnabled) {
 	try {
 		window.localStorage.removeItem(STORAGE_KEY$1);
 	} catch {}
-	const domain = cookieDomain();
-	setRawCookie(COOKIE_NAME, "", domain, 0);
-	if (domain) setRawCookie(COOKIE_NAME, "", "", 0);
+	deleteRawCookie(COOKIE_NAME);
+	clearVisitClaim();
 }
 //#endregion
 //#region ../browser-session/src/events/trace-id.ts
@@ -568,11 +662,13 @@ const browserDocument = () => globalThis.document;
 const SDK_HINT_HEADER = "x-maple-sdk";
 /** `<name>/<version>` — the one shape ingest expects in `x-maple-sdk`. */
 const sdkHint = (name, version) => `${name}/${version}`;
-/** Auth + identity headers shared by every ingest request. */
+/** Auth + identity headers shared by every ingest request. No key, no `Authorization`. */
 function ingestHeaders(config) {
+	const identity = { [SDK_HINT_HEADER]: config.sdk };
+	if (!config.ingestKey) return identity;
 	return {
 		Authorization: `Bearer ${config.ingestKey}`,
-		[SDK_HINT_HEADER]: config.sdk
+		...identity
 	};
 }
 const lastWarnAt = /* @__PURE__ */ new Map();
@@ -817,6 +913,7 @@ function buildSessionMetaRow(input) {
 		resource_attributes: {
 			"maple.session.recorded": input.recorded ? "true" : "false",
 			"maple.session.replay_format": "rrweb",
+			...input.recorded && input.replayTrigger ? { "maple.session.replay_trigger": input.replayTrigger } : void 0,
 			...input.visitorId && input.visitorIdPersisted === false ? { "maple.visitor.persisted": "false" } : void 0,
 			...input.environment ? {
 				"deployment.environment": input.environment,
@@ -826,6 +923,7 @@ function buildSessionMetaRow(input) {
 		},
 		visitor_id: input.visitorId ?? "",
 		visitor_is_new: input.visitorIsNew ? 1 : 0,
+		billable_start: input.billableStart ? 1 : 0,
 		user_email: (input.captureUserEmail === false ? void 0 : identity?.email) ?? "",
 		user_name: identity?.username ?? "",
 		group_id: identity?.groupId ?? "",
@@ -890,8 +988,6 @@ function approximateSize(value) {
 //#endregion
 //#region ../browser-session/src/session/session.ts
 const STORAGE_KEY = "maple.session";
-/** Rotate the session after this much inactivity (PostHog's default). */
-const IDLE_TIMEOUT_MS = 18e5;
 /** Hard cap on a single session's lifetime regardless of activity. */
 const MAX_SESSION_MS = 864e5;
 /**
@@ -949,10 +1045,19 @@ function parseSessionRecord(raw) {
 		if (typeof value.visitorIsNew !== "boolean") return void 0;
 		record.visitorIsNew = value.visitorIsNew;
 	}
+	if (value.billable !== void 0) {
+		if (typeof value.billable !== "boolean") return void 0;
+		record.billable = value.billable;
+	}
 	if (value.replaySampled !== void 0) {
 		if (typeof value.replaySampled !== "boolean") return void 0;
 		record.replaySampled = value.replaySampled;
 	}
+	if (value.replayBuffered !== void 0) {
+		if (typeof value.replayBuffered !== "boolean") return void 0;
+		record.replayBuffered = value.replayBuffered;
+	}
+	if (value.replayTrigger === "error") record.replayTrigger = value.replayTrigger;
 	if (value.utm !== void 0) {
 		if (!isStringRecord(value.utm)) return void 0;
 		record.utm = value.utm;
@@ -968,6 +1073,12 @@ const UTM_KEYS = [
 ];
 /** In-memory fallback when sessionStorage is unavailable (private mode). */
 let ephemeral;
+/**
+* Set while sessionStorage writes throw. On quota exhaustion reads still work,
+* so the stored copy is a frozen snapshot: `metaVersion` pinned at 1 billed
+* every heartbeat as a new session. Keep this separate from the read try/catch.
+*/
+let writesFailed = false;
 const rotationListeners = /* @__PURE__ */ new Set();
 /**
 * Read the entry URL/referrer/UTM of the current page.
@@ -1009,6 +1120,7 @@ function freshRecord(now) {
 	};
 }
 function readRecord() {
+	if (writesFailed && ephemeral) return ephemeral;
 	try {
 		const raw = window.sessionStorage.getItem(STORAGE_KEY);
 		if (!raw) return void 0;
@@ -1021,7 +1133,10 @@ function writeRecord(record) {
 	ephemeral = record;
 	try {
 		window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(record));
-	} catch {}
+		writesFailed = false;
+	} catch {
+		writesFailed = true;
+	}
 	claimTab(record.id);
 }
 const TAB_LEASE_PREFIX = "maple.session.tab.";
@@ -1123,7 +1238,7 @@ function ownedByAnotherTab(record, now) {
 	}
 }
 function isSessionExpired(record, now = Date.now()) {
-	return now - record.lastActivityAt > IDLE_TIMEOUT_MS || now - record.startedAt > MAX_SESSION_MS;
+	return now - record.lastActivityAt > 18e5 || now - record.startedAt > MAX_SESSION_MS;
 }
 /** Observe genuine idle/lifetime rotation. Invoked before the new record is installed. */
 function onSessionRotate(listener) {
@@ -1234,6 +1349,22 @@ function noteCounts(counts) {
 	});
 }
 /**
+* Whether `sessionId` is the session charged for its visit. `claim` runs once,
+* on the first row, and the answer is persisted so heartbeats, reloads and the
+* `ended` row all agree with it.
+*/
+function resolveBillable(sessionId, claim) {
+	const record = readRecord();
+	if (!record || record.id !== sessionId) return false;
+	if (record.billable !== void 0) return record.billable;
+	const billable = claim();
+	writeRecord({
+		...record,
+		billable
+	});
+	return billable;
+}
+/**
 * The persisted session record as-is — no activity touch, no rotation. Use
 * this to read counters when posting a metadata row; `getSession()` would
 * rotate an idle session out from under the row being written.
@@ -1306,20 +1437,65 @@ function claimReplaySample(sampleRate) {
 	return sampled;
 }
 /**
+* This session's replay mode: recorded at `sampleRate`, otherwise buffered for
+* errors at `onErrorSampleRate`. Rolled once per session and persisted, like
+* `claimReplaySample`.
+*/
+function claimReplayMode(sampleRate, onErrorSampleRate) {
+	if (claimReplaySample(sampleRate)) return "record";
+	const record = readRecord() ?? getSession();
+	if (record.replayBuffered === void 0) {
+		const buffered = onErrorSampleRate > 0 && uniformRandom() < onErrorSampleRate;
+		writeRecord({
+			...record,
+			replayBuffered: buffered
+		});
+		return buffered ? "buffer" : "off";
+	}
+	return record.replayBuffered ? "buffer" : "off";
+}
+/** An error made this buffered session a recorded one: later loads record it from the start. */
+function markReplayTriggered(sessionId) {
+	const record = readRecord();
+	if (!record || record.id !== sessionId) return;
+	writeRecord({
+		...record,
+		replaySampled: true,
+		replayTrigger: "error"
+	});
+}
+/**
 * Pin a session to the capture mode a running page is already in. A session
 * minted by idle rotation mid-page inherits that page's mode rather than
 * rolling again, and later loads of it honour the same answer.
 */
-function adoptReplayDecision(sessionId, recorded) {
+function adoptReplayDecision(sessionId, recorded, buffered) {
 	const record = readRecord();
 	if (!record || record.id !== sessionId || record.replaySampled !== void 0) return;
 	writeRecord({
 		...record,
-		replaySampled: recorded
+		replaySampled: recorded,
+		...buffered !== void 0 && !recorded ? { replayBuffered: buffered } : void 0
 	});
 }
 //#endregion
 //#region ../browser-session/src/events/events-sink.ts
+/** On `globalThis` like the sink: every bundled copy of this module must see the same listeners. */
+const LISTENERS_KEY = "__MAPLE_SESSION_EVENT_LISTENERS__";
+function listeners() {
+	const global = globalThis;
+	let set = global[LISTENERS_KEY];
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		global[LISTENERS_KEY] = set;
+	}
+	return set;
+}
+/** Observe every event the live sink records, e.g. for an error's breadcrumb trail. Returns an unsubscribe. */
+function onSessionEvent(listener) {
+	listeners().add(listener);
+	return () => listeners().delete(listener);
+}
 const FLUSH_INTERVAL_MS = 5e3;
 const FLUSH_BYTES = 65536;
 /**
@@ -1386,6 +1562,9 @@ function startEventSink(config, sessionId) {
 		});
 		bufferBytes += approximateSize(ev);
 		if (bufferBytes >= FLUSH_BYTES) flush();
+		for (const listener of listeners()) try {
+			listener(ev);
+		} catch {}
 	};
 	const stopNavigation = installNavigationObserver((url) => {
 		emit({
@@ -1546,7 +1725,7 @@ function toRow(config, sessionId, ev, seq) {
 * posted at session start, whose counters are all zero and therefore read as a
 * bounce. 60s is the floor worth using: the table is a ReplacingMergeTree, so
 * every heartbeat is an unmerged part until the next merge. Billing meters only
-* `version == 1` rows, so heartbeats do not double-bill.
+* `billable_start == 1 && version == 1` rows, so heartbeats do not double-bill.
 */
 const HEARTBEAT_INTERVAL_MS = 6e4;
 /**
@@ -1564,6 +1743,7 @@ function startSessionLifecycle(options, hooks) {
 	let errorCountBase = 0;
 	let sinkClickCountAtStart = 0;
 	let sinkErrorCountAtStart = 0;
+	const isRecorded = () => typeof hooks.recorded === "function" ? hooks.recorded() : hooks.recorded;
 	/**
 	* The persisted record of the session this lifecycle owns.
 	*
@@ -1612,6 +1792,10 @@ function startSessionLifecycle(options, hooks) {
 	const post = (status, keepalive) => {
 		const record = liveRecord();
 		const counts = countsFor(record);
+		const visitorId = getVisitorId();
+		const persistVisit = visitorId !== void 0;
+		const billableStart = resolveBillable(record.id, () => claimVisit(Date.now(), persistVisit));
+		touchVisit(record.lastActivityAt, persistVisit);
 		hooks.post(buildSessionMetaRow({
 			sessionId: record.id,
 			startedAt: new Date(record.startedAt),
@@ -1622,7 +1806,7 @@ function startSessionLifecycle(options, hooks) {
 			captureUserEmail: options.captureUserEmail,
 			environment: options.environment,
 			serviceVersion: options.serviceVersion,
-			visitorId: getVisitorId(),
+			visitorId,
 			visitorIsNew: record.visitorIsNew === true,
 			visitorIdPersisted: isVisitorIdPersisted(),
 			entry: entryContextOf(record),
@@ -1631,7 +1815,9 @@ function startSessionLifecycle(options, hooks) {
 			pageViews: counts.pageViews,
 			errorCount: counts.errorCount,
 			traceIds: status === "ended" ? options.getTraceIds?.(record.id) : void 0,
-			recorded: hooks.recorded
+			recorded: isRecorded(),
+			replayTrigger: record.replayTrigger,
+			billableStart
 		}), keepalive);
 	};
 	const stopHeartbeat = () => {
@@ -1643,7 +1829,7 @@ function startSessionLifecycle(options, hooks) {
 		if (stopped || running) return;
 		running = true;
 		const record = liveRecord();
-		adoptReplayDecision(record.id, hooks.recorded);
+		adoptReplayDecision(record.id, isRecorded(), hooks.buffered?.());
 		rebaseCounts(record);
 		hooks.onStart?.(record);
 		post("active", false);
@@ -1705,6 +1891,9 @@ function startSessionLifecycle(options, hooks) {
 		get sessionId() {
 			return current.id;
 		},
+		announce: () => {
+			if (running) post("active", false);
+		},
 		shutdown: async (shutdownOptions) => {
 			if (stopped) return;
 			stopped = true;
@@ -1788,4 +1977,4 @@ function readSessionSink() {
 	return globalThis[SESSION_SINK_KEY];
 }
 //#endregion
-export { setVisitorTracking as A, warnDropped as C, setActiveTraceIdProvider as D, activeTraceId as E, scrubUrl as M, withStartedTraceId as O, sdkHint as S, safeEmit as T, isLikelyBot as _, recordTraceId as a, postSessionBlob as b, getActiveSink as c, claimReplaySample as d, getSession as f, postSessionMetaRow as g, rotateSession as h, readSessionSink as i, addUrlSanitizer as j, configureVisitorCookie as k, queuePending as l, nextChunkSeq as m, getObservedTraceIds as n, startSessionLifecycle as o, markActivity as p, publishSessionSink as r, clearPendingEvents as s, clearSessionSink as t, startEventSink as u, SDK_HINT_HEADER as v, BLOCK_SELECTOR as w, postSessionMeta as x, gzip as y };
+export { setActiveTraceIdProvider as A, postSessionMeta as C, BLOCK_SELECTOR as D, selectorOf as E, scrubUrl as F, configureVisitorCookie as M, setVisitorTracking as N, safeEmit as O, addUrlSanitizer as P, postSessionBlob as S, warnDropped as T, rotateSession as _, recordTraceId as a, gzip as b, getActiveSink as c, startEventSink as d, claimReplayMode as f, nextChunkSeq as g, markReplayTriggered as h, readSessionSink as i, withStartedTraceId as j, activeTraceId as k, onSessionEvent as l, markActivity as m, getObservedTraceIds as n, startSessionLifecycle as o, getSession as p, publishSessionSink as r, clearPendingEvents as s, clearSessionSink as t, queuePending as u, postSessionMetaRow as v, sdkHint as w, ingestHeaders as x, isLikelyBot as y };