@maple-dev/browser 0.12.0 → 0.14.0

package/dist/{sink-DbEuphC-.mjs → sink-Ji0J42ul.mjs}

@@ -11,6 +11,15 @@ function mayUseStorage() {
 //#region ../browser-session/src/platform/url-privacy.ts
 const REDACTED = "REDACTED";
 const SENSITIVE_PARAM = /^(access_token|id_token|refresh_token|token|token_hash|auth|authorization|code|oobcode|state|password|passwd|pwd|pass|secret|client_secret|api_key|apikey|key|signature|sig|otp|jwt|session|sessionid|session_id|ticket|__clerk_ticket|reset_token|magic|nonce|x-amz-signature|x-amz-credential|x-amz-security-token|x-goog-signature|x-goog-credential)$/i;
+/**
+* Any name that, lowercased with `_`, `-` and `.` removed, ends in a credential
+* word: `accessToken`, `auth_token`, `user-token`, `__clerk_db_jwt`, `x-api-key`.
+* Suffix rather than substring, so `tokenizer_mode` or `secretary` stay readable.
+*/
+const CREDENTIAL_SUFFIX = /(token|secret|password|passwd|apikey|jwt|signature|credential|credentials|privatekey)$/;
+function isSensitiveName(name) {
+	return SENSITIVE_PARAM.test(name) || CREDENTIAL_SUFFIX.test(name.toLowerCase().replace(/[-_.]/g, ""));
+}
 /** Sanitizers live on `globalThis`, like consent: one page, one policy, however many SDK copies. */
 const SANITIZERS_KEY = "__MAPLE_URL_SANITIZERS__";
 function sanitizers() {
@@ -27,45 +36,68 @@ function sanitizers() {
 */
 function addUrlSanitizer(sanitizer) {
 	sanitizers().add(sanitizer);
+	return () => void sanitizers().delete(sanitizer);
 }
 function redactParams(params) {
 	let changed = false;
 	for (const name of new Set(params.keys())) {
-		if (!SENSITIVE_PARAM.test(name)) continue;
+		if (!isSensitiveName(name)) continue;
 		params.set(name, REDACTED);
 		changed = true;
 	}
 	return changed;
 }
+function redactQuery(query) {
+	const params = new URLSearchParams(query);
+	return redactParams(params) ? params.toString() : query;
+}
 /**
 * Implicit-flow tokens ride the fragment as `#access_token=…&…`; a hash-routed
-* app carries them in the route's own query, `#/reset?token=…`. The route path
-* is kept either way.
+* app carries them in the route's own query, `#/reset?token=…` or `#reset?token=…`.
+* The route path is kept either way.
 */
 function redactFragment(fragment) {
-	if (fragment.startsWith("/") || fragment.startsWith("!/")) {
-		const queryAt = fragment.indexOf("?");
-		if (queryAt === -1) return fragment;
-		const params = new URLSearchParams(fragment.slice(queryAt + 1));
-		return redactParams(params) ? `${fragment.slice(0, queryAt)}?${params.toString()}` : fragment;
-	}
-	if (!fragment.includes("=")) return fragment;
-	const params = new URLSearchParams(fragment);
-	return redactParams(params) ? params.toString() : fragment;
+	const queryAt = fragment.indexOf("?");
+	const head = queryAt === -1 ? fragment : fragment.slice(0, queryAt);
+	const redactedHead = head.startsWith("/") || head.startsWith("!/") || !head.includes("=") ? head : redactQuery(head);
+	return queryAt === -1 ? redactedHead : `${redactedHead}?${redactQuery(fragment.slice(queryAt + 1))}`;
 }
 const ABSOLUTE = /^[a-z][a-z0-9+.-]*:/i;
 const RELATIVE_BASE = "http://relative.invalid";
-/** Redact credential-shaped query and fragment parameters, keeping the URL's form. */
+/** `user:password@` after a scheme's `//`, for URLs the parser rejects. */
+const USERINFO = /^([a-z][a-z0-9+.-]*:)?\/\/[^/?#@]*@/i;
+/** One `name=value` pair after a query, fragment or matrix separator. */
+const PAIR = /([?&#;])([^=&#;?]*)=([^&#;?]*)/g;
+function decodeName(raw) {
+	try {
+		return decodeURIComponent(raw.replace(/\+/g, " "));
+	} catch {
+		return raw;
+	}
+}
+/**
+* Best-effort redaction for a URL `new URL` rejects (`https://exa mple.com/?token=1`):
+* returning it raw would send exactly the credentials redaction exists to stop.
+*/
+function redactUnparsable(url) {
+	return url.replace(USERINFO, (_, scheme) => `${scheme ?? ""}//`).replace(PAIR, (pair, separator, name) => isSensitiveName(decodeName(name)) ? `${separator}${name}=${REDACTED}` : pair);
+}
+/** Redact credentials in userinfo and in query and fragment parameters, keeping the URL's form. */
 function redactUrl(url) {
-	if (!url || !url.includes("?") && !url.includes("#")) return url;
+	if (!url || !/[?#@;]/.test(url)) return url;
 	const absolute = ABSOLUTE.test(url);
 	let parsed;
 	try {
 		parsed = new URL(url, absolute ? void 0 : RELATIVE_BASE);
 	} catch {
-		return url;
+		return redactUnparsable(url);
 	}
 	let changed = redactParams(parsed.searchParams);
+	if (parsed.username || parsed.password) {
+		parsed.username = "";
+		parsed.password = "";
+		changed = true;
+	}
 	const fragment = parsed.hash.slice(1);
 	const redactedFragment = redactFragment(fragment);
 	if (redactedFragment !== fragment) {
@@ -92,13 +124,42 @@ function scrubUrl(url) {
 	return out;
 }
 //#endregion
+//#region ../browser-session/src/platform/uuid.ts
+/**
+* A random v4 UUID. `crypto.randomUUID` exists only in secure contexts (HTTPS
+* and localhost) and from Safari 15.4, so a plain-http intranet or staging site
+* would otherwise throw from `init()`. `getRandomValues` has no such limit.
+*/
+function randomUuid() {
+	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+//#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;
+/**
+* On `globalThis`, like consent: two bundled SDK copies writing the same cookies
+* under different `Domain=` scopes would each keep a copy the other cannot delete.
+*/
+const SCOPE_KEY = "__MAPLE_BROWSER_COOKIE_SCOPE__";
+function scope() {
+	const owner = globalThis;
+	const existing = owner[SCOPE_KEY];
+	if (isCookieScope(existing)) return existing;
+	const fresh = {
+		cookieDomainOverride: void 0,
+		crossSubdomainCookie: true,
+		probedCookieDomain: void 0
+	};
+	owner[SCOPE_KEY] = fresh;
+	return fresh;
+}
+function isCookieScope(value) {
+	return typeof value === "object" && value !== null && "crossSubdomainCookie" in value;
+}
 /**
 * Apply the host app's cookie configuration. Called from `configurePrivacy`, so
 * both SDKs get it from the single call they already make.
@@ -114,9 +175,10 @@ let probedCookieDomain;
 * `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;
+	const state = scope();
+	if (options.crossSubdomainCookie === false) state.crossSubdomainCookie = false;
+	if (options.cookieDomain !== void 0) state.cookieDomainOverride = tighterCookieDomain(state.cookieDomainOverride, options.cookieDomain);
+	state.probedCookieDomain = void 0;
 }
 /** The narrower of two `Domain=` values, treating `undefined` as "unset". */
 function tighterCookieDomain(current, next) {
@@ -124,16 +186,29 @@ function tighterCookieDomain(current, next) {
 	if (current === "" || next === "") return "";
 	return next.length > current.length ? next : current;
 }
-function readRawCookie(name) {
-	if (typeof document === "undefined") return void 0;
+/** Every value stored under `name`: a host-only and a domain cookie can coexist. */
+function readRawCookies(name) {
+	if (typeof document === "undefined") return [];
+	const values = [];
 	try {
 		for (const part of document.cookie.split(";")) {
 			const raw = part.trim();
 			if (!raw.startsWith(`${name}=`)) continue;
-			return decodeURIComponent(raw.slice(name.length + 1));
+			try {
+				values.push(decodeURIComponent(raw.slice(name.length + 1)));
+			} catch {}
 		}
 	} catch {}
+	return values;
+}
+function readRawCookie(name) {
+	return readRawCookies(name)[0];
 }
+/**
+* Write a cookie, returning whether the browser actually kept it. Assigning to
+* `document.cookie` succeeds silently when the cookie is refused (blocked,
+* oversized, bad `Domain=`), so a stored cookie is confirmed by reading it back.
+*/
 function setRawCookie(name, value, domain, maxAgeSeconds) {
 	if (typeof document === "undefined") return false;
 	const attributes = [
@@ -146,10 +221,10 @@ function setRawCookie(name, value, domain, maxAgeSeconds) {
 	if (typeof location !== "undefined" && location.protocol === "https:") attributes.push("Secure");
 	try {
 		document.cookie = attributes.join("; ");
-		return true;
 	} catch {
 		return false;
 	}
+	return maxAgeSeconds <= 0 || readRawCookies(name).includes(value);
 }
 /**
 * Expire `name` host-only and on every parent domain it could have been scoped
@@ -158,15 +233,19 @@ function setRawCookie(name, value, domain, maxAgeSeconds) {
 */
 function deleteRawCookie(name) {
 	setRawCookie(name, "", "", 0);
-	for (const domain of candidateDomains()) setRawCookie(name, "", domain, 0);
-	if (cookieDomainOverride) setRawCookie(name, "", cookieDomainOverride, 0);
+	const hostname = typeof location === "undefined" ? "" : location.hostname;
+	for (const domain of candidateDomains(hostname)) setRawCookie(name, "", domain, 0);
+	const override = scope().cookieDomainOverride;
+	if (override) setRawCookie(name, "", override, 0);
 }
-/** Parent domains of this host, broadest first. Empty for single-label hosts and IPs. */
-function candidateDomains() {
-	if (typeof location === "undefined") return [];
-	const hostname = location.hostname;
+/**
+* Parent domains of `hostname`, broadest first. Empty for single-label hosts,
+* IPs, and hosts with an empty label (`example.com.`), whose suffixes are not domains.
+*/
+function candidateDomains(hostname) {
 	if (!hostname || /^[\d.]+$/.test(hostname) || hostname.includes(":")) return [];
 	const parts = hostname.split(".");
+	if (parts.includes("")) return [];
 	const candidates = [];
 	for (let i = parts.length - 2; i >= 0; i--) candidates.push(parts.slice(i).join("."));
 	return candidates;
@@ -182,21 +261,21 @@ function candidateDomains() {
 * for bare IPs, neither of which can carry a `Domain=` attribute.
 */
 function probeCookieDomain() {
-	if (typeof document === "undefined") return "";
-	for (const candidate of candidateDomains()) {
-		const probe = "__maple_probe";
-		if (setRawCookie(probe, "1", candidate, 60) && readRawCookie(probe) === "1") {
-			setRawCookie(probe, "", candidate, 0);
-			return candidate;
-		}
+	if (typeof document === "undefined" || typeof location === "undefined") return "";
+	const probe = "__maple_probe";
+	const value = randomUuid().slice(0, 8);
+	for (const candidate of candidateDomains(location.hostname)) if (setRawCookie(probe, value, candidate, 60)) {
+		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 state = scope();
+	if (state.cookieDomainOverride !== void 0) return state.cookieDomainOverride;
+	if (!state.crossSubdomainCookie) return "";
+	if (state.probedCookieDomain === void 0) state.probedCookieDomain = probeCookieDomain();
+	return state.probedCookieDomain;
 }
 //#endregion
 //#region ../browser-session/src/platform/json.ts
@@ -242,6 +321,18 @@ function parseJsonObject(raw) {
 function isStringRecord(value) {
 	return isJsonObject(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
+/** A `\\` pair, or the escape `JSON.stringify` writes for a lone surrogate. */
+const LONE_SURROGATE_ESCAPE = /\\(?:\\|u[dD][89a-fA-F][0-9a-fA-F]{2})/g;
+/**
+* `JSON.stringify`, with every lone surrogate written as U+FFFD. JavaScript
+* strings may hold half an emoji; strict JSON parsers (ingest's among them)
+* reject the escape for one, and with it the whole NDJSON batch it rides in.
+* Paired surrogates are written as raw characters, so any `\uD8xx` escape left
+* in the output is a lone one.
+*/
+function stringifyWellFormed(value) {
+	return (JSON.stringify(value) ?? "null").replace(LONE_SURROGATE_ESCAPE, (escape) => escape === "\\\\" ? escape : "\\ufffd");
+}
 //#endregion
 //#region ../browser-session/src/session/idle.ts
 /**
@@ -268,53 +359,71 @@ const STORAGE_KEY$2 = "maple.visit";
 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) {
+function parseVisitMarker(raw) {
 	if (!raw) return void 0;
-	const parsed = Number.parseInt(raw, 10);
-	return Number.isFinite(parsed) ? parsed : void 0;
+	const match = /^(\d{1,16})(?:\.([0-9a-z]{1,32}))?$/.exec(raw);
+	if (!match?.[1]) return void 0;
+	return {
+		at: Number(match[1]),
+		token: match[2] ?? ""
+	};
 }
 function readMarker(persist) {
 	if (!persist) return ephemeral$1;
-	const fromCookie = parseMarker(readRawCookie(COOKIE_NAME$1));
+	const fromCookie = parseVisitMarker(readRawCookie(COOKIE_NAME$1));
 	if (fromCookie !== void 0) return fromCookie;
 	try {
-		const fromStorage = parseMarker(window.localStorage.getItem(STORAGE_KEY$2));
+		const fromStorage = parseVisitMarker(window.localStorage.getItem(STORAGE_KEY$2));
 		if (fromStorage !== void 0) return fromStorage;
 	} catch {}
 	return ephemeral$1;
 }
-function writeMarker(at, persist) {
-	ephemeral$1 = at;
+function writeMarker(marker, persist) {
+	ephemeral$1 = marker;
 	if (!persist) return;
-	const value = String(at);
+	const value = marker.token ? `${marker.at}.${marker.token}` : String(marker.at);
 	try {
 		window.localStorage.setItem(STORAGE_KEY$2, value);
 	} catch {}
-	setRawCookie(COOKIE_NAME$1, value, cookieDomain(), (IDLE_TIMEOUT_MS - (Date.now() - at)) / 1e3);
+	setRawCookie(COOKIE_NAME$1, value, cookieDomain(), (IDLE_TIMEOUT_MS - (Date.now() - marker.at)) / 1e3);
 }
 function withinVisit(marker, at) {
-	return marker !== void 0 && Math.abs(at - marker) < 18e5;
+	return marker !== void 0 && Math.abs(at - marker.at) < 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.
+*
+* Restored tabs all start at once and can each read "no visit" before any of
+* them writes one. Each writes its own token and reads the marker back, and
+* only the tab whose token survived is charged: the last writer wins.
 */
 function claimVisit(at, persist) {
 	if (typeof window === "undefined") return false;
 	const marker = readMarker(persist);
 	if (withinVisit(marker, at)) {
-		if (at > marker) writeMarker(at, persist);
+		if (at > marker.at) writeMarker({
+			at,
+			token: marker.token
+		}, persist);
 		return false;
 	}
-	writeMarker(at, persist);
-	return true;
+	const token = randomUuid().slice(0, 8);
+	writeMarker({
+		at,
+		token
+	}, persist);
+	return readMarker(persist)?.token === token;
 }
 /** 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);
+	if (withinVisit(marker, at) && at > marker.at) writeMarker({
+		at,
+		token: marker.token
+	}, persist);
 }
 /** Drop the claim from every store, for a visitor-tracking opt-out. */
 function clearVisitClaim() {
@@ -377,22 +486,42 @@ const COOKIE_NAME = "maple_visitor";
 * expiry onto ids already in the wild is not.
 */
 const MAX_AGE_MS = 3456e7;
-let enabled = true;
-/** Memoized so the hot path never re-reads storage. */
-let cached;
-let persisted = false;
-let mintedThisLoad = false;
+/** Only ids this SDK could have minted; anything else in the cookie is someone else's. */
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* On `globalThis`, like consent: with two bundled SDK copies, per-copy state let
+* one copy's opt-out purge the id while the other minted it straight back.
+*/
+const VISITOR_KEY = "__MAPLE_BROWSER_VISITOR__";
+function visitorState() {
+	const owner = globalThis;
+	const existing = owner[VISITOR_KEY];
+	if (isVisitorState(existing)) return existing;
+	const fresh = {
+		cached: void 0,
+		enabled: true,
+		mintedThisLoad: false,
+		optedOut: false,
+		persisted: false
+	};
+	owner[VISITOR_KEY] = fresh;
+	return fresh;
+}
+function isVisitorState(value) {
+	return typeof value === "object" && value !== null && "optedOut" in value;
+}
 /**
 * 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.
 */
 const configureVisitorCookie = configureCookieScope;
-function parseRecord(raw) {
+function parseVisitorRecord(raw) {
 	if (!raw) return void 0;
 	const value = parseJsonObject(raw);
 	if (!value) return void 0;
 	const { id, mintedAt } = value;
-	if (typeof id !== "string" || typeof mintedAt !== "number") return void 0;
+	if (typeof id !== "string" || !UUID.test(id)) return void 0;
+	if (typeof mintedAt !== "number" || !Number.isFinite(mintedAt)) return void 0;
 	if (Date.now() - mintedAt > MAX_AGE_MS) return void 0;
 	return {
 		id,
@@ -401,13 +530,13 @@ function parseRecord(raw) {
 }
 function readFromStorage() {
 	try {
-		return parseRecord(window.localStorage.getItem(STORAGE_KEY$1) ?? void 0);
+		return parseVisitorRecord(window.localStorage.getItem(STORAGE_KEY$1));
 	} catch {
 		return;
 	}
 }
 function readFromCookie() {
-	return parseRecord(readRawCookie(COOKIE_NAME));
+	return parseVisitorRecord(readRawCookie(COOKIE_NAME));
 }
 function writeToStorage(record) {
 	try {
@@ -430,31 +559,32 @@ function writeToCookie(record) {
 function write(record) {
 	const inStorage = writeToStorage(record);
 	const inCookie = writeToCookie(record);
-	persisted = inStorage || inCookie;
+	visitorState().persisted = inStorage || inCookie;
 }
 /**
 * The current visitor id, minting one on first use. `undefined` when visitor
 * tracking is off or outside a browser.
 */
 function getVisitorId() {
-	if (!enabled || typeof window === "undefined") return void 0;
-	if (cached) return cached.id;
+	const state = visitorState();
+	if (!state.enabled || state.optedOut || typeof window === "undefined") return void 0;
+	if (state.cached) return state.cached.id;
 	const fromCookie = readFromCookie();
 	const fromStorage = readFromStorage();
 	const existing = fromCookie ?? fromStorage;
 	if (existing) {
-		cached = existing;
-		persisted = true;
+		state.cached = existing;
+		state.persisted = true;
 		if (!fromCookie) writeToCookie(existing);
 		if (!fromStorage || fromStorage.id !== existing.id) writeToStorage(existing);
 		return existing.id;
 	}
 	const record = {
-		id: crypto.randomUUID(),
+		id: randomUuid(),
 		mintedAt: Date.now()
 	};
-	cached = record;
-	mintedThisLoad = true;
+	state.cached = record;
+	state.mintedThisLoad = true;
 	write(record);
 	return record.id;
 }
@@ -471,8 +601,9 @@ function getVisitorId() {
 */
 function claimNewVisitor() {
 	getVisitorId();
-	if (!mintedThisLoad) return false;
-	mintedThisLoad = false;
+	const state = visitorState();
+	if (!state.mintedThisLoad) return false;
+	state.mintedThisLoad = false;
 	return true;
 }
 /**
@@ -482,18 +613,31 @@ function claimNewVisitor() {
 * layer can flag it rather than quietly inflate.
 */
 function isVisitorIdPersisted() {
-	return persisted;
+	return visitorState().persisted;
 }
 /**
 * Turn persistent visitor tracking on or off. Turning it off also purges any
 * id already stored — an opt-out that leaves the identifier behind is not one.
 */
 function setVisitorTracking(nextEnabled) {
-	enabled = nextEnabled;
-	if (nextEnabled) return;
-	cached = void 0;
-	persisted = false;
-	mintedThisLoad = false;
+	visitorState().enabled = nextEnabled;
+	if (!nextEnabled) purgeVisitorId();
+}
+/**
+* `persistVisitorId: false` from any SDK on the page. Unlike `setVisitorTracking`,
+* which follows consent both ways, this never turns back on for the page load.
+*/
+function optOutOfVisitorId() {
+	visitorState().optedOut = true;
+	purgeVisitorId();
+}
+/** Drop the id and the visit claim from memory and every store. */
+function purgeVisitorId() {
+	const state = visitorState();
+	state.cached = void 0;
+	state.persisted = false;
+	state.mintedThisLoad = false;
+	if (typeof window === "undefined") return;
 	try {
 		window.localStorage.removeItem(STORAGE_KEY$1);
 	} catch {}
@@ -533,10 +677,14 @@ function consentState() {
 	const existing = owner[CONSENT_KEY];
 	if (existing) {
 		existing.revokedAt ||= 0;
+		existing.configured ||= false;
+		existing.deniedBeforeGate ||= false;
 		return existing;
 	}
 	const fresh = {
 		allowedSince: 0,
+		configured: false,
+		deniedBeforeGate: false,
 		granted: false,
 		listeners: /* @__PURE__ */ new Set(),
 		requireConsent: false,
@@ -565,6 +713,34 @@ function consentRevokedAt() {
 		return inMemory;
 	}
 }
+/**
+* Withdraw consent for good: data kept from before now is never sent, and the
+* persistent visitor id and visit claim are deleted from every store.
+*/
+function revoke() {
+	writeRevokedAt(Date.now());
+	purgeVisitorId();
+}
+/**
+* How long a denial on a page that never granted waits before it purges.
+* Consent tools commonly set a default "denied" and then replay the stored
+* "granted" once loaded; purging at once would mint a new visitor every page.
+*/
+const DENIAL_SETTLE_MS = 1e4;
+let pendingRevoke;
+function cancelPendingRevoke() {
+	if (pendingRevoke !== void 0) clearTimeout(pendingRevoke);
+	pendingRevoke = void 0;
+}
+/** A denial with no grant before it on this page: a withdrawal unless a grant follows soon. */
+function revokeUnlessGranted() {
+	if (pendingRevoke !== void 0) return;
+	pendingRevoke = setTimeout(() => {
+		pendingRevoke = void 0;
+		if (!consentState().granted) revoke();
+	}, DENIAL_SETTLE_MS);
+}
+let warnedAboutMissingGate = false;
 function updateEffectiveConsent(previous) {
 	const state = consentState();
 	const allowed = hasConsent();
@@ -584,9 +760,11 @@ function updateEffectiveConsent(previous) {
 * denied→allowed transition would start capture on a user who never consented.
 * To genuinely relax a gate, reload without it.
 */
+/** Returns the remover for its `sanitizeUrl`, so a shutdown leaves no closure behind. */
 function configurePrivacy(options) {
 	const state = consentState();
 	const previous = hasConsent();
+	state.configured = true;
 	state.requireConsent = state.requireConsent || (options?.requireConsent ?? false);
 	state.respectDoNotTrack = state.respectDoNotTrack || (options?.respectDoNotTrack ?? false);
 	configurePersistence(options?.persistence);
@@ -594,15 +772,39 @@ function configurePrivacy(options) {
 		crossSubdomainCookie: options?.crossSubdomainCookie,
 		cookieDomain: options?.cookieDomain
 	});
-	if (options?.sanitizeUrl) addUrlSanitizer(options.sanitizeUrl);
+	if (options?.persistVisitorId === false) optOutOfVisitorId();
+	const removeSanitizer = options?.sanitizeUrl ? addUrlSanitizer(options.sanitizeUrl) : () => {};
+	if (state.requireConsent && state.deniedBeforeGate && !state.granted) revokeUnlessGranted();
+	state.deniedBeforeGate = false;
 	updateEffectiveConsent(previous);
+	return removeSanitizer;
 }
-/** Record the user's consent decision. No-op unless `requireConsent` is set. */
+/**
+* Record the user's consent decision. No-op unless `requireConsent` is set.
+*
+* Under the gate, every `false` is a withdrawal, including one replayed on a
+* fresh page load: the visitor id and data queued under an earlier grant must
+* not survive it. That one purges after a short settle, so a default "denied"
+* the consent tool replaces with "granted" does not reset the visitor.
+*/
 function setConsent(nextGranted) {
 	const previous = hasConsent();
 	const state = consentState();
-	if (state.granted && !nextGranted) writeRevokedAt(Date.now());
+	const wasGranted = state.granted;
 	state.granted = nextGranted;
+	if (nextGranted) {
+		state.deniedBeforeGate = false;
+		cancelPendingRevoke();
+	} else if (state.requireConsent) {
+		if (wasGranted) {
+			cancelPendingRevoke();
+			revoke();
+		} else revokeUnlessGranted();
+	} else if (!state.configured) state.deniedBeforeGate = true;
+	else if (!warnedAboutMissingGate) {
+		warnedAboutMissingGate = true;
+		console.warn("[maple] setConsent(false) has no effect without privacy.requireConsent; capture continues.");
+	}
 	updateEffectiveConsent(previous);
 }
 /** Whether capture may proceed at all. */
@@ -653,27 +855,41 @@ function activeTraceId() {
 	const id = traceIdProvider();
 	return id && id !== ZERO_TRACE_ID ? id : void 0;
 }
-const slots = [];
+const slots$1 = [];
 /** Report a span that just started. Fills the innermost open slot, first span wins. */
 function noteStartedTraceId(traceId) {
-	const slot = slots.at(-1);
+	const slot = slots$1.at(-1);
 	if (slot && slot.traceId === void 0 && traceId !== ZERO_TRACE_ID) slot.traceId = traceId;
 }
 /** Run `fn`, returning its result and the trace id of the first span started during it. */
 function withStartedTraceId(fn) {
 	const slot = { traceId: void 0 };
-	slots.push(slot);
+	slots$1.push(slot);
 	try {
 		return {
 			result: fn(),
 			traceId: slot.traceId
 		};
 	} finally {
-		const index = slots.lastIndexOf(slot);
-		if (index !== -1) slots.splice(index, 1);
+		const index = slots$1.lastIndexOf(slot);
+		if (index !== -1) slots$1.splice(index, 1);
 	}
 }
 //#endregion
+//#region ../browser-session/src/platform/text.ts
+/**
+* Cut `text` to at most `max` UTF-16 units without splitting a surrogate pair,
+* appending `suffix` when anything was cut. Half an emoji is a lone surrogate,
+* which strict JSON parsers reject along with the batch carrying it.
+*/
+function truncateText(text, max, suffix = "") {
+	if (text.length <= max) return text;
+	let end = Math.max(0, max);
+	const last = text.charCodeAt(end - 1);
+	if (end > 0 && last >= 55296 && last <= 56319) end--;
+	return `${text.slice(0, end)}${suffix}`;
+}
+//#endregion
 //#region ../browser-session/src/capture/shared.ts
 /** Emit best-effort: capture must never throw into the host app's call site. */
 function safeEmit(emit, ev) {
@@ -684,24 +900,25 @@ function safeEmit(emit, ev) {
 //#endregion
 //#region ../browser-session/src/capture/errors.ts
 const MAX_STACK = 4e3;
+const MAX_MESSAGE = 1e3;
 /** Capture uncaught errors + unhandled promise rejections as session events. */
 function installErrorCapture(emit) {
 	const onError = (event) => {
 		safeEmit(emit, {
 			type: "error",
 			level: "error",
-			message: event.message || String(event.error ?? "Error"),
-			errorStack: truncate(event.error?.stack),
+			message: truncate(event.message || String(event.error ?? "Error"), MAX_MESSAGE),
+			errorStack: truncate(describeRejection(event.error).stack, MAX_STACK),
 			traceId: activeTraceId()
 		});
 	};
 	const onRejection = (event) => {
-		const reason = event.reason;
+		const { message, stack } = describeRejection(event.reason);
 		safeEmit(emit, {
 			type: "error",
 			level: "error",
-			message: typeof reason === "string" ? reason : reason?.message ?? "Unhandled promise rejection",
-			errorStack: truncate(typeof reason === "object" ? reason?.stack : void 0),
+			message: truncate(message, MAX_MESSAGE),
+			errorStack: truncate(stack, MAX_STACK),
 			traceId: activeTraceId()
 		});
 	};
@@ -712,9 +929,25 @@ function installErrorCapture(emit) {
 		window.removeEventListener("unhandledrejection", onRejection);
 	};
 }
-function truncate(stack) {
-	if (!stack) return void 0;
-	return stack.length > MAX_STACK ? `${stack.slice(0, MAX_STACK)}…` : stack;
+/** An error or rejection reason is anything a `throw` or `reject()` was given. */
+function describeRejection(reason) {
+	if (typeof reason === "string") return {
+		message: reason,
+		stack: void 0
+	};
+	if (typeof reason !== "object" || reason === null) return {
+		message: "Unhandled promise rejection",
+		stack: void 0
+	};
+	return {
+		message: ("message" in reason && typeof reason.message === "string" ? reason.message : void 0) ?? "Unhandled promise rejection",
+		stack: "stack" in reason && typeof reason.stack === "string" ? reason.stack : void 0
+	};
+}
+/** Cut on a code-point boundary: half an emoji is a lone surrogate, which ingest rejects with its batch. */
+function truncate(text, max) {
+	if (!text) return void 0;
+	return truncateText(text, max, "…");
 }
 const BLOCK_SELECTOR = `[data-rr-block]`;
 /**
@@ -734,12 +967,28 @@ const isBlocked = (el) => {
 //#endregion
 //#region ../browser-session/src/capture/interactions.ts
 const MAX_TEXT = 120;
+/** Bounds the walk on a click that lands on `<body>` or a huge container. */
+const MAX_NODES = 500;
+/** rrweb's default mask class: replay shows its text as `*`, so neither may this. */
+const MASK_CLASS = "rr-mask";
+/** Text that is code, markup or user input rather than a visible label. */
+const SKIPPED_TAGS = /* @__PURE__ */ new Set([
+	"SCRIPT",
+	"STYLE",
+	"NOSCRIPT",
+	"TEMPLATE",
+	"INPUT",
+	"TEXTAREA",
+	"SELECT",
+	"OPTION"
+]);
 /**
 * Capture clicks and input events as session events. Listens in the capture
 * phase so it sees interactions even when the host app calls
 * `stopPropagation()`. Input *values* are never recorded; only the target
 * element. Click target text is omitted when `maskAllText` is set, and when the
-* target sits inside a blocked (`.rr-block` / `data-rr-block`) subtree.
+* target sits inside a blocked (`.rr-block` / `data-rr-block`) or masked
+* (`.rr-mask`) subtree; blocked descendants of the target are skipped.
 */
 function installInteractionCapture(emit, maskAllText) {
 	const onClick = (event) => {
@@ -748,7 +997,7 @@ function installInteractionCapture(emit, maskAllText) {
 		safeEmit(emit, {
 			type: "click",
 			targetSelector: selectorOf(target),
-			targetText: maskAllText || isBlocked(target) ? void 0 : textOf(target)
+			targetText: maskAllText || isBlocked(target) || isMasked(target) ? void 0 : textOf(target)
 		});
 	};
 	const onInput = (event) => {
@@ -770,10 +1019,41 @@ function installInteractionCapture(emit, maskAllText) {
 function selectorOf(el) {
 	return `${el.tagName.toLowerCase()}${el.id ? `#${el.id}` : ""}${typeof el.className === "string" && el.className.trim() ? `.${el.className.trim().split(/\s+/)[0]}` : ""}`;
 }
+/** An element whose text must not be read: blocked, masked, code, or editable. */
+function isHiddenText(el) {
+	return SKIPPED_TAGS.has(el.tagName.toUpperCase()) || el.classList.contains("rr-block") || el.classList.contains(MASK_CLASS) || el.hasAttribute("data-rr-block") || el instanceof HTMLElement && el.isContentEditable;
+}
+function isMasked(el) {
+	for (let node = el; node !== null; node = node.parentElement) if (node.classList.contains(MASK_CLASS)) return true;
+	return false;
+}
+/**
+* The target's visible label: its text nodes in document order, skipping hidden
+* subtrees and stopping once the cap is reached. `textContent` would read the
+* whole subtree, blocked parts and all, on every click.
+*/
 function textOf(el) {
-	const text = (el.textContent ?? "").trim().replace(/\s+/g, " ");
+	if (isHiddenText(el)) return void 0;
+	let text = "";
+	let visited = 0;
+	const stack = [el];
+	while (stack.length > 0 && visited < MAX_NODES && text.length <= MAX_TEXT) {
+		const node = stack.pop();
+		visited++;
+		if (node instanceof Text) {
+			text = `${text}${node.data}`.replace(/\s+/g, " ").trimStart();
+			continue;
+		}
+		if (node !== el && (!(node instanceof Element) || isHiddenText(node))) continue;
+		const children = node?.childNodes ?? [];
+		for (let i = children.length - 1; i >= 0; i--) {
+			const child = children[i];
+			if (child) stack.push(child);
+		}
+	}
+	text = text.trim();
 	if (!text) return void 0;
-	return text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}…` : text;
+	return truncateText(text, MAX_TEXT, "…");
 }
 //#endregion
 //#region ../browser-session/src/capture/baseline.ts
@@ -899,6 +1179,10 @@ function reserveKeepalive(requested, bytes, otlp = false) {
 		if (otlp) inflight.otlpBytes = Math.max(0, (inflight.otlpBytes ?? 0) - bytes);
 	};
 }
+/** Keepalive bytes a session write could reserve right now. */
+function keepaliveRoom() {
+	return Math.max(0, KEEPALIVE_BUDGET_BYTES - keepaliveInflight().bytes);
+}
 /** Body size in bytes: the keepalive limit counts bytes, and `string.length` counts UTF-16 units. */
 function byteLength(body) {
 	return typeof body === "string" ? new TextEncoder().encode(body).byteLength : body.byteLength;
@@ -946,6 +1230,7 @@ const GZIP_MIN_BYTES = 18;
 * crawlers, which tear the page down on nearly every session.
 */
 async function gzip(bytes) {
+	if (typeof CompressionStream !== "function") return gzipStored(bytes);
 	const stream = new CompressionStream("gzip");
 	const writer = stream.writable.getWriter();
 	const written = writer.write(bytes).then(() => writer.close());
@@ -954,39 +1239,158 @@ async function gzip(bytes) {
 	if (out.length < GZIP_MIN_BYTES || out[0] !== 31 || out[1] !== 139 || out[2] !== 8) throw new Error(`gzip produced ${out.length} bytes, not a complete gzip stream`);
 	return out;
 }
+let crcTable;
+function crc32(bytes) {
+	if (!crcTable) {
+		crcTable = /* @__PURE__ */ new Uint32Array(256);
+		for (let n = 0; n < 256; n++) {
+			let c = n;
+			for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+			crcTable[n] = c >>> 0;
+		}
+	}
+	let crc = 4294967295;
+	for (const byte of bytes) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+/** Largest payload of one stored (uncompressed) deflate block. */
+const STORED_BLOCK_BYTES = 65535;
+/**
+* gzip with stored deflate blocks: valid gzip any inflater reads, built
+* synchronously and not compressed. For a page going away, where
+* `CompressionStream` never resolves: a request has to be issued before the
+* document is torn down, and nothing after the first await runs by then.
+*/
+function gzipStored(bytes) {
+	const blocks = Math.max(1, Math.ceil(bytes.length / STORED_BLOCK_BYTES));
+	const out = new Uint8Array(10 + blocks * 5 + bytes.length + 8);
+	const view = new DataView(out.buffer);
+	out.set([
+		31,
+		139,
+		8,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		255
+	]);
+	let at = 10;
+	for (let block = 0; block < blocks; block++) {
+		const start = block * STORED_BLOCK_BYTES;
+		const length = Math.min(STORED_BLOCK_BYTES, bytes.length - start);
+		out[at] = block === blocks - 1 ? 1 : 0;
+		view.setUint16(at + 1, length, true);
+		view.setUint16(at + 3, ~length & 65535, true);
+		out.set(bytes.subarray(start, start + length), at + 5);
+		at += 5 + length;
+	}
+	view.setUint32(at, crc32(bytes), true);
+	view.setUint32(at + 4, bytes.length >>> 0, true);
+	return out;
+}
+function outcomeOf(status) {
+	if (status >= 200 && status < 300) return "accepted";
+	if (status === 429 || status >= 500) return "retry";
+	if (status === 401 || status === 402 || status === 403) return "refused";
+	return "rejected";
+}
+/**
+* Ingest URL and key pairs that were refused. Every later request with the
+* same key would be refused the same way, so none is sent for the rest of the
+* page; a re-init with another key starts clean.
+*/
+const refusedUrls = /* @__PURE__ */ new Set();
+/** The URL plus an FNV-1a hash of the key, so the key itself is not kept. */
+function channelOf(config, url) {
+	let hash = 2166136261;
+	for (const char of config.ingestKey ?? "") hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+	return `${url}|${hash >>> 0}`;
+}
+const isRefused = (config, url) => refusedUrls.has(channelOf(config, url));
+function refuse(config, url, status) {
+	const channel = channelOf(config, url);
+	if (refusedUrls.has(channel)) return;
+	refusedUrls.add(channel);
+	console.warn(`[maple] ingest refused ${url} (HTTP ${status}); nothing more is sent there from this page`);
+}
+/** POST one body, mapping the answer to a {@link PostOutcome}. Never throws. */
+async function postNdjson(config, url, body, keepalive, what) {
+	try {
+		const response = await postToIngest(url, {
+			...ingestHeaders(config),
+			"content-type": "application/x-ndjson"
+		}, body, keepalive);
+		const outcome = outcomeOf(response.status);
+		if (outcome === "refused") refuse(config, url, response.status);
+		return outcome;
+	} catch (error) {
+		warnDropped(what, error);
+		return "failed";
+	}
+}
 /** POST session metadata (NDJSON, single row). `keepalive` for the final unload write. */
 async function postSessionMeta(config, row, keepalive = false) {
-	const body = `${JSON.stringify(row)}\n`;
-	await postToIngest(`${config.endpoint}/v1/sessionReplays/meta`, {
-		...ingestHeaders(config),
-		"content-type": "application/x-ndjson"
-	}, body, keepalive).catch((error) => {
-		warnDropped("metadata POST", error);
-	});
+	const url = `${config.endpoint}/v1/sessionReplays/meta`;
+	if (isRefused(config, url)) return;
+	await postNdjson(config, url, `${stringifyWellFormed(row)}\n`, keepalive, "metadata POST");
+}
+/** Worst first: what a caller acts on when a batch went out in parts. */
+const OUTCOME_RANK = {
+	refused: 0,
+	failed: 1,
+	retry: 2,
+	rejected: 3,
+	accepted: 4
+};
+/**
+* Split NDJSON lines for a page going away: the oldest that fit the keepalive
+* room left, measured on the serialized bytes, and the rest as a plain request
+* that only survives if the page does. One body over the room lost all of it.
+*/
+function keepaliveBodies(lines) {
+	const encoder = new TextEncoder();
+	let room = keepaliveRoom();
+	let fits = 0;
+	for (const line of lines) {
+		const size = encoder.encode(line).byteLength;
+		if (size > room) break;
+		room -= size;
+		fits++;
+	}
+	return [{
+		body: lines.slice(0, fits).join(""),
+		keepalive: true
+	}, {
+		body: lines.slice(fits).join(""),
+		keepalive: false
+	}].filter(({ body }) => body.length > 0);
 }
 /**
 * POST distilled session events (NDJSON, one row per event). Never throws.
-* `"failed"` means no response came back, so the rows may or may not have
-* reached ingest.
+* A keepalive batch larger than the room left goes out in two parts, and the
+* worst of their outcomes is returned.
 */
 async function postSessionEvents(config, rows, keepalive = false) {
 	if (rows.length === 0) return "accepted";
-	const body = `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`;
-	try {
-		return (await postToIngest(`${config.endpoint}/v1/sessionEvents`, {
-			...ingestHeaders(config),
-			"content-type": "application/x-ndjson"
-		}, body, keepalive)).ok ? "accepted" : "rejected";
-	} catch (error) {
-		warnDropped("events POST", error);
-		return "failed";
-	}
+	const url = `${config.endpoint}/v1/sessionEvents`;
+	if (isRefused(config, url)) return "refused";
+	const lines = rows.map((row) => `${stringifyWellFormed(row)}\n`);
+	const bodies = keepalive ? keepaliveBodies(lines) : [{
+		body: lines.join(""),
+		keepalive: false
+	}];
+	return (await Promise.all(bodies.map((part) => postNdjson(config, url, part.body, part.keepalive, "events POST")))).reduce((worst, outcome) => OUTCOME_RANK[outcome] < OUTCOME_RANK[worst] ? outcome : worst);
 }
 const SESSION_EXHAUSTED_STATUS = 413;
 /** POST a gzipped rrweb event chunk. */
 async function postSessionBlob(config, meta, gzipped, keepalive = false) {
+	const url = `${config.endpoint}/v1/sessionReplays/blob`;
+	if (isRefused(config, url)) return "refused";
 	try {
-		const response = await postToIngest(`${config.endpoint}/v1/sessionReplays/blob`, {
+		const response = await postToIngest(url, {
 			...ingestHeaders(config),
 			"content-type": "application/octet-stream",
 			"x-maple-session-id": meta.sessionId,
@@ -995,8 +1399,10 @@ async function postSessionBlob(config, meta, gzipped, keepalive = false) {
 			"x-maple-event-count": String(meta.eventCount),
 			"x-maple-duration-ms": String(meta.durationMs)
 		}, gzipped, keepalive);
-		if (response.ok) return "accepted";
-		return response.status === SESSION_EXHAUSTED_STATUS ? "exhausted" : "rejected";
+		if (response.status === SESSION_EXHAUSTED_STATUS) return "exhausted";
+		const outcome = outcomeOf(response.status);
+		if (outcome === "refused") refuse(config, url, response.status);
+		return outcome;
 	} catch (error) {
 		warnDropped("blob PUT", error);
 		return "failed";
@@ -1016,10 +1422,12 @@ function parseUserAgent(ua) {
 	return parsed;
 }
 function parse(ua) {
+	const browserName = /edg/i.test(ua) ? "Edge" : /opr|opera/i.test(ua) ? "Opera" : /samsungbrowser/i.test(ua) ? "Samsung Internet" : /chrome|crios/i.test(ua) ? "Chrome" : /firefox|fxios/i.test(ua) ? "Firefox" : /safari/i.test(ua) ? "Safari" : "Unknown";
+	const osName = /windows/i.test(ua) ? "Windows" : /iphone|ipad|ipod|\bios\b/i.test(ua) ? "iOS" : /mac os|macintosh/i.test(ua) ? "macOS" : /android/i.test(ua) ? "Android" : /\bcros\b/i.test(ua) ? "ChromeOS" : /linux/i.test(ua) ? "Linux" : "Unknown";
 	return {
-		browserName: /edg/i.test(ua) ? "Edge" : /opr|opera/i.test(ua) ? "Opera" : /chrome|crios/i.test(ua) ? "Chrome" : /firefox|fxios/i.test(ua) ? "Firefox" : /safari/i.test(ua) ? "Safari" : "Unknown",
-		osName: /windows/i.test(ua) ? "Windows" : /iphone|ipad|ios/i.test(ua) ? "iOS" : /mac os|macintosh/i.test(ua) ? "macOS" : /android/i.test(ua) ? "Android" : /linux/i.test(ua) ? "Linux" : "Unknown",
-		deviceType: /mobile|iphone/i.test(ua) ? "mobile" : /ipad|tablet/i.test(ua) ? "tablet" : "desktop"
+		browserName,
+		osName,
+		deviceType: /ipad|tablet/i.test(ua) ? "tablet" : /mobile|iphone|ipod/i.test(ua) ? "mobile" : osName === "Android" ? "tablet" : "desktop"
 	};
 }
 /**
@@ -1069,7 +1477,7 @@ function isLikelyBot(ua) {
 /** ClickHouse-style `YYYY-MM-DD HH:MM:SS.mmm` in UTC (matches the ingest gateway). */
 function formatCHDateTime(date) {
 	const pad = (n, width = 2) => String(n).padStart(width, "0");
-	return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.` + pad(date.getUTCMilliseconds(), 3);
+	return `${pad(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.` + pad(date.getUTCMilliseconds(), 3);
 }
 /**
 * Build one `/v1/sessionReplays/meta` NDJSON row. Shared by `@maple-dev/browser`
@@ -1156,7 +1564,7 @@ function pathOf(url) {
 }
 /** POST one session metadata row (NDJSON). Best-effort — never throws. */
 async function postSessionMetaRow(target, row, keepalive = false) {
-	const body = `${JSON.stringify(row)}\n`;
+	const body = `${stringifyWellFormed(row)}\n`;
 	await postToIngest(`${target.endpoint.replace(/\/$/, "")}/v1/sessionReplays/meta`, {
 		...ingestHeaders(target),
 		"content-type": "application/x-ndjson"
@@ -1174,13 +1582,53 @@ function approximateSize(value) {
 	}
 }
 //#endregion
+//#region ../browser-session/src/capture/patch.ts
+const slots = /* @__PURE__ */ new WeakMap();
+/**
+* Install `wrap(original, hooks)` as `target[key]`, or reuse the wrapper an
+* earlier call left in place. The wrapper must read `hooks()` on every call
+* and only forward to `original` when it is undefined. Returns the teardown.
+*/
+function patchMethod(target, key, hooks, wrap) {
+	let byKey = slots.get(target);
+	if (!byKey) {
+		byKey = /* @__PURE__ */ new Map();
+		slots.set(target, byKey);
+	}
+	let slot = byKey.get(key);
+	if (slot && target[key] !== slot.wrapper && target[key] === slot.original) slot = void 0;
+	if (slot) slot.hooks = hooks;
+	else {
+		const original = target[key];
+		const fresh = {
+			original,
+			wrapper: void 0,
+			hooks
+		};
+		const wrapper = wrap(original, () => fresh.hooks);
+		fresh.wrapper = wrapper;
+		target[key] = wrapper;
+		byKey.set(key, fresh);
+		slot = fresh;
+	}
+	const owned = slot;
+	const map = byKey;
+	return () => {
+		if (owned.hooks !== hooks) return;
+		owned.hooks = void 0;
+		if (target[key] !== owned.wrapper) return;
+		Reflect.set(target, key, owned.original);
+		map.delete(key);
+	};
+}
+//#endregion
 //#region ../browser-session/src/session/session.ts
 const STORAGE_KEY = "maple.session";
 /** Hard cap on a single session's lifetime regardless of activity. */
 const MAX_SESSION_MS = 864e5;
 /**
 * The activity path runs per span creation (`getSessionId`) and per captured
-* event (`markActivity` — every console call, keystroke, click, fetch);
+* user input (`markActivity`: clicks, typing, scrolling, mouse movement);
 * persisting the bump on every call would hammer sessionStorage for no benefit
 * — rotation correctness only needs sub-idle-timeout granularity.
 */
@@ -1245,6 +1693,10 @@ function parseSessionRecord(raw) {
 		if (typeof value.replayBuffered !== "boolean") return void 0;
 		record.replayBuffered = value.replayBuffered;
 	}
+	if (value.replayHalted !== void 0) {
+		if (typeof value.replayHalted !== "boolean") return void 0;
+		record.replayHalted = value.replayHalted;
+	}
 	if (value.replayTrigger === "error") record.replayTrigger = value.replayTrigger;
 	if (value.utm !== void 0) {
 		if (!isStringRecord(value.utm)) return void 0;
@@ -1262,6 +1714,12 @@ const UTM_KEYS = [
 /** In-memory fallback when sessionStorage is unavailable (private mode). */
 let ephemeral;
 /**
+* The Storage `ephemeral` was last written to. When the key vanishes from that
+* same Storage (a host app's `sessionStorage.clear()` on logout), the in-memory
+* copy is still this tab's session; a different Storage object is not ours.
+*/
+let ephemeralStorage;
+/**
 * 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.
@@ -1271,9 +1729,8 @@ const rotationListeners = /* @__PURE__ */ new Set();
 /**
 * Read the entry URL/referrer/UTM of the current page.
 *
-* Guarded for non-DOM runtimes: `freshRecord` is reachable from `getSessionId`
-* on the span path and from the `nextChunkSeq`/`nextMetaVersion` fallbacks, so
-* this must not assume `location`/`document` exist.
+* Guarded for non-DOM runtimes: `freshRecord` is reachable from `markActivity`,
+* which runs outside a DOM, so this must not assume `location`/`document` exist.
 */
 function readEntryContext() {
 	if (typeof window === "undefined" || typeof location === "undefined") return {};
@@ -1298,7 +1755,7 @@ function readEntryContext() {
 }
 function freshRecord(now) {
 	return {
-		id: crypto.randomUUID(),
+		id: randomUuid(),
 		startedAt: now,
 		lastActivityAt: now,
 		chunkSeq: 0,
@@ -1310,8 +1767,9 @@ function freshRecord(now) {
 function readRecord() {
 	if (!mayUseStorage() || writesFailed && ephemeral) return ephemeral;
 	try {
-		const raw = window.sessionStorage.getItem(STORAGE_KEY);
-		if (!raw) return void 0;
+		const storage = window.sessionStorage;
+		const raw = storage.getItem(STORAGE_KEY);
+		if (!raw) return storage === ephemeralStorage ? ephemeral : void 0;
 		return parseSessionRecord(raw) ?? ephemeral;
 	} catch {
 		return ephemeral;
@@ -1319,9 +1777,12 @@ function readRecord() {
 }
 function writeRecord(record) {
 	ephemeral = record;
+	rememberCounters(record);
 	if (!mayUseStorage()) return;
 	try {
-		window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(record));
+		const storage = window.sessionStorage;
+		ephemeralStorage = storage;
+		storage.setItem(STORAGE_KEY, JSON.stringify(record));
 		writesFailed = false;
 	} catch {
 		writesFailed = true;
@@ -1331,11 +1792,13 @@ function writeRecord(record) {
 const TAB_LEASE_PREFIX = "maple.session.tab.";
 const TAB_LEASE_TTL_MS = 12e4;
 const TAB_LEASE_REFRESH_MS = 5e3;
+const TAB_LEASE_KEEPALIVE_MS = 3e4;
 const TAB_NONCE_KEY = "__MAPLE_TAB_NONCE__";
 /** The session id this tab has checked (or minted) and may keep using. */
 let verifiedSessionId;
 let leaseWrittenAt = 0;
 let releaseInstalled = false;
+let leaseTimer;
 /**
 * Set from `pagehide` until the page is shown again. The lifecycle's own
 * `pagehide` handler posts an `ended` row after ours runs, which writes the
@@ -1347,7 +1810,7 @@ function tabNonce() {
 	const owner = globalThis;
 	const existing = owner[TAB_NONCE_KEY];
 	if (typeof existing === "string") return existing;
-	const fresh = crypto.randomUUID();
+	const fresh = randomUuid();
 	owner[TAB_NONCE_KEY] = fresh;
 	return fresh;
 }
@@ -1378,10 +1841,27 @@ function claimTab(sessionId) {
 	leaseWrittenAt = now;
 	const storage = leaseStorage();
 	if (!storage) return;
+	writeLease(storage, sessionId, now);
+	installLeaseRelease();
+	if (leaseTimer === void 0 && typeof setInterval === "function") leaseTimer = setInterval(refreshLease, TAB_LEASE_KEEPALIVE_MS);
+}
+function writeLease(storage, sessionId, now) {
 	try {
 		storage.setItem(`${TAB_LEASE_PREFIX}${sessionId}`, `${tabNonce()}:${now}`);
 	} catch {}
-	installLeaseRelease();
+}
+function refreshLease() {
+	if (verifiedSessionId === void 0 || leaseReleased) return;
+	const record = readRecord();
+	if (!hasConsent() || record === void 0 || record.id !== verifiedSessionId || isSessionExpired(record)) {
+		clearInterval(leaseTimer);
+		leaseTimer = void 0;
+		return;
+	}
+	const storage = leaseStorage();
+	if (!storage) return;
+	leaseWrittenAt = Date.now();
+	writeLease(storage, verifiedSessionId, leaseWrittenAt);
 }
 function releaseTab(sessionId) {
 	const storage = leaseStorage();
@@ -1504,13 +1984,20 @@ function touchSession(now) {
 	return record;
 }
 /**
-* Mark activity, rotating first when the stored session has expired. Called per
-* captured event, so it shares `getSessionId`'s throttled touch — callers read
-* the returned record's `id` to detect that rotation.
+* Resolve the session a captured event belongs to. For `"input"` (what a person
+* does: clicks, typing, scrolling, navigation) this marks activity, rotating
+* first when the stored session has expired, and shares `getSessionId`'s
+* throttled touch; callers read the returned record's `id` to detect rotation.
+*
+* `"passive"` events (DOM mutations, console, network, errors) must neither keep
+* an abandoned page's session alive nor start a new one: they get the stored
+* record untouched, or `null` when it has expired. Undefined outside a browser.
 */
-function markActivity() {
+function markActivity(kind = "input") {
 	if (typeof window === "undefined") return void 0;
-	return touchSession(Date.now());
+	if (kind === "input") return touchSession(Date.now());
+	const record = readRecord();
+	return record !== void 0 && !isSessionExpired(record) ? record : null;
 }
 /**
 * Record a page view. Persisted on the session record rather than held in the
@@ -1574,19 +2061,58 @@ function entryContextOf(record) {
 		utm: record.utm ?? {}
 	};
 }
+const recentCounters = /* @__PURE__ */ new Map();
+const MAX_RECENT_COUNTERS = 4;
+function rememberCounters(record) {
+	recentCounters.delete(record.id);
+	recentCounters.set(record.id, {
+		chunkSeq: record.chunkSeq,
+		metaVersion: record.metaVersion
+	});
+	for (const id of recentCounters.keys()) {
+		if (recentCounters.size <= MAX_RECENT_COUNTERS) break;
+		recentCounters.delete(id);
+	}
+}
 /**
-* Take the next replay chunk sequence number for the current session. Monotonic
-* across reloads (persisted on the session record), so a refresh continues the
-* sequence instead of restarting at 0 and overwriting the previous load's blobs.
+* Advance one counter of `sessionId`: on its persisted record when that is the
+* stored one, else on this document's memory of it. Undefined for a session
+* this document never wrote, whose counters it cannot know.
 */
-function nextChunkSeq() {
-	const record = readRecord() ?? freshRecord(Date.now());
-	const seq = record.chunkSeq;
-	writeRecord({
-		...record,
-		chunkSeq: seq + 1
-	});
-	return seq;
+function takeCounter(sessionId, take) {
+	const record = readRecord();
+	if (record?.id === sessionId) {
+		const { value, next } = take({
+			chunkSeq: record.chunkSeq,
+			metaVersion: record.metaVersion
+		});
+		writeRecord({
+			...record,
+			chunkSeq: next.chunkSeq,
+			metaVersion: next.metaVersion
+		});
+		return value;
+	}
+	const remembered = recentCounters.get(sessionId);
+	if (!remembered) return void 0;
+	const { value, next } = take(remembered);
+	recentCounters.set(sessionId, next);
+	return value;
+}
+/**
+* Take the next replay chunk sequence number of `sessionId`. Monotonic across
+* reloads (persisted on the session record), so a refresh continues the
+* sequence instead of restarting at 0 and overwriting the previous load's blobs.
+* Undefined when the session's counter is unknown: the chunk must be dropped.
+*/
+function nextChunkSeq(sessionId) {
+	return takeCounter(sessionId, (counters) => ({
+		value: counters.chunkSeq,
+		next: {
+			...counters,
+			chunkSeq: counters.chunkSeq + 1
+		}
+	}));
 }
 /**
 * Take the next session-metadata row version for the current session.
@@ -1596,14 +2122,17 @@ function nextChunkSeq() {
 * older SDKs (no `metaVersion`) already posted versions 1 and 2, so the
 * counter resumes at 3 for them; a fresh session starts at 1.
 */
-function nextMetaVersion() {
-	const record = readRecord() ?? freshRecord(Date.now());
-	const version = (record.metaVersion ?? 2) + 1;
-	writeRecord({
-		...record,
-		metaVersion: version
+function nextMetaVersion(sessionId) {
+	return takeCounter(sessionId, (counters) => {
+		const version = (counters.metaVersion ?? 2) + 1;
+		return {
+			value: version,
+			next: {
+				...counters,
+				metaVersion: version
+			}
+		};
 	});
-	return version;
 }
 /** A uniform draw in [0, 1) from Web Crypto, the same source session ids use. */
 function uniformRandom() {
@@ -1644,6 +2173,19 @@ function claimReplayMode(sampleRate, onErrorSampleRate) {
 	}
 	return record.replayBuffered ? "buffer" : "off";
 }
+/** Recording of `sessionId` stopped for good: later recorder starts of it do nothing. */
+function markReplayHalted(sessionId) {
+	const record = readRecord();
+	if (!record || record.id !== sessionId || record.replayHalted) return;
+	writeRecord({
+		...record,
+		replayHalted: true
+	});
+}
+function isReplayHalted(sessionId) {
+	const record = readRecord();
+	return record?.id === sessionId && record.replayHalted === true;
+}
 /** An error made this buffered session a recorded one: later loads record it from the start. */
 function markReplayTriggered(sessionId) {
 	const record = readRecord();
@@ -1687,7 +2229,23 @@ function onSessionEvent(listener) {
 	return () => listeners().delete(listener);
 }
 const FLUSH_INTERVAL_MS = 5e3;
-const FLUSH_BYTES = 65536;
+/** Small enough that the batch a page leaves with usually fits the shared keepalive budget. */
+const FLUSH_BYTES = 32768;
+/** Ceiling on buffered events while ingest asks to back off; the oldest go first. */
+const MAX_BUFFER_BYTES = 262144;
+/** Pause after ingest asks for a retry (429, 5xx), doubling per answer in a row up to the cap. */
+const RETRY_BACKOFF_MS = 5e3;
+const MAX_RETRY_BACKOFF_MS = 6e4;
+/** Identical error rows kept per window: an error thrown every frame is one row, not sixty a second. */
+const MAX_REPEATED_ERRORS = 5;
+const REPEATED_ERROR_WINDOW_MS = 6e4;
+/** Event types a person causes. Only these keep a session from going idle. */
+const USER_EVENTS = /* @__PURE__ */ new Set([
+	"navigation",
+	"click",
+	"input",
+	"custom"
+]);
 /** Events across which an in-flight POST can fail although ingest stored it. */
 const PAGE_TRANSITIONS = [
 	"beforeunload",
@@ -1730,6 +2288,15 @@ function startEventSink(config, sessionId) {
 	let buffer = [];
 	let bufferBytes = 0;
 	let retry = [];
+	let resend = [];
+	/** The one non-keepalive POST in flight, and whether a flush was asked for meanwhile. */
+	let inFlight;
+	let flushAgain = false;
+	let retryAt = 0;
+	let retriesInARow = 0;
+	/** Ingest refused this page's key or plan: nothing more is buffered. */
+	let refused = false;
+	const repeatedErrors = /* @__PURE__ */ new Map();
 	let seq = 0;
 	let pageViews = 0;
 	let clickCount = 0;
@@ -1741,19 +2308,74 @@ function startEventSink(config, sessionId) {
 	};
 	const pageTarget = typeof globalThis.addEventListener === "function" ? globalThis : void 0;
 	for (const type of PAGE_TRANSITIONS) pageTarget?.addEventListener(type, onPageTransition);
-	const flush = async (keepalive = false) => {
+	const send = async (keepalive) => {
+		if (!keepalive && Date.now() < retryAt) return;
 		const fresh = buffer.map(({ ev, seq }) => toRow(config, sessionId, ev, seq));
-		const rows = keepalive ? fresh : [...retry, ...fresh];
+		const rows = keepalive ? [...resend, ...fresh] : [
+			...retry,
+			...resend,
+			...fresh
+		];
 		if (rows.length === 0) return;
 		if (!keepalive) retry = [];
+		resend = [];
 		buffer = [];
 		bufferBytes = 0;
 		const transitionsAtSend = pageTransitions;
-		if (await postSessionEvents(config, rows, keepalive) !== "failed" || keepalive || pageTransitions !== transitionsAtSend) return;
-		retry = [...fresh, ...retry];
+		const outcome = await postSessionEvents(config, rows, keepalive);
+		if (outcome === "refused") {
+			refused = true;
+			buffer = [];
+			bufferBytes = 0;
+			retry = [];
+			return;
+		}
+		if (outcome === "retry") {
+			retriesInARow++;
+			retryAt = Date.now() + Math.min(MAX_RETRY_BACKOFF_MS, RETRY_BACKOFF_MS * 2 ** (retriesInARow - 1));
+		} else retriesInARow = 0;
+		if (outcome === "retry") resend = [...fresh, ...resend];
+		else if (!keepalive && outcome === "failed" && pageTransitions === transitionsAtSend) retry = [...fresh, ...retry];
+	};
+	const flush = (keepalive = false) => {
+		if (keepalive) return send(true);
+		if (inFlight) {
+			flushAgain = true;
+			return inFlight;
+		}
+		const run = async () => {
+			try {
+				do {
+					flushAgain = false;
+					await send(false);
+				} while (flushAgain);
+			} finally {
+				inFlight = void 0;
+			}
+		};
+		inFlight = run();
+		return inFlight;
+	};
+	/** Whether `ev` repeats an error already sent `MAX_REPEATED_ERRORS` times this window. */
+	const isRepeatedError = (ev) => {
+		if (ev.type !== "error" && !(ev.type === "console" && ev.level === "error")) return false;
+		const key = `${ev.type}|${ev.message ?? ""}|${(ev.errorStack ?? "").slice(0, 500)}`;
+		const now = Date.now();
+		const seen = repeatedErrors.get(key);
+		if (!seen || now - seen.since > REPEATED_ERROR_WINDOW_MS) {
+			if (repeatedErrors.size >= 100) repeatedErrors.clear();
+			repeatedErrors.set(key, {
+				count: 1,
+				since: now
+			});
+			return false;
+		}
+		seen.count++;
+		return seen.count > MAX_REPEATED_ERRORS;
 	};
 	const emit = (ev) => {
-		const session = markActivity();
+		const session = markActivity(USER_EVENTS.has(ev.type) ? "input" : "passive");
+		if (session === null) return;
 		if (session && session.id !== sessionId) {
 			const nextSink = startEventSink(config, session.id);
 			if (ev.type !== "navigation") nextSink.emit(ev);
@@ -1764,11 +2386,16 @@ function startEventSink(config, sessionId) {
 			noteNavigation(ev.url ?? (typeof location !== "undefined" ? location.href : ""));
 		} else if (ev.type === "click") clickCount++;
 		else if (ev.type === "error" || ev.type === "console" && ev.level === "error") errorCount++;
+		if (refused || isRepeatedError(ev)) return;
 		buffer.push({
 			ev,
 			seq: seq++
 		});
 		bufferBytes += approximateSize(ev);
+		while (bufferBytes > MAX_BUFFER_BYTES && buffer.length > 1) {
+			const dropped = buffer.shift();
+			if (dropped) bufferBytes -= approximateSize(dropped.ev);
+		}
 		if (bufferBytes >= FLUSH_BYTES) flush();
 		for (const listener of listeners()) try {
 			listener(ev);
@@ -1819,24 +2446,18 @@ function installNavigationObserver(onNavigate) {
 		onNavigate(url);
 	};
 	emitNav();
-	const origPush = history.pushState;
-	const origReplace = history.replaceState;
+	const hooks = { emitNav };
 	const receiver = (self) => self instanceof History ? self : history;
-	history.pushState = function(...args) {
-		const result = origPush.apply(receiver(this), args);
-		emitNav();
-		return result;
-	};
-	history.replaceState = function(...args) {
-		const result = origReplace.apply(receiver(this), args);
-		emitNav();
+	const wrapHistory = (original, current) => function(...args) {
+		const result = original.apply(receiver(this), args);
+		current()?.emitNav();
 		return result;
 	};
+	const unpatch = [patchMethod(history, "pushState", hooks, wrapHistory), patchMethod(history, "replaceState", hooks, wrapHistory)];
 	window.addEventListener("popstate", emitNav);
 	window.addEventListener("hashchange", emitNav);
 	return () => {
-		history.pushState = origPush;
-		history.replaceState = origReplace;
+		for (const off of unpatch) off();
 		window.removeEventListener("popstate", emitNav);
 		window.removeEventListener("hashchange", emitNav);
 	};
@@ -1947,6 +2568,10 @@ function startSessionLifecycle(options, hooks) {
 	let stopped = false;
 	/** Whether a run is live: capture started, `active` posted, heartbeat armed. */
 	let running = false;
+	/** A live run whose tab is hidden: `ended` posted, heartbeat off, capture kept. */
+	let paused = false;
+	/** Ends a paused run once its session would have gone idle, so a hidden tab does not record for long. */
+	let pauseTimer;
 	let heartbeat;
 	let clickCountBase = 0;
 	let errorCountBase = 0;
@@ -2000,6 +2625,8 @@ function startSessionLifecycle(options, hooks) {
 	};
 	const post = (status, keepalive) => {
 		const record = liveRecord();
+		const version = nextMetaVersion(record.id);
+		if (version === void 0) return;
 		const counts = countsFor(record);
 		const visitorId = getVisitorId();
 		const persistVisit = visitorId !== void 0;
@@ -2008,7 +2635,7 @@ function startSessionLifecycle(options, hooks) {
 		hooks.post(buildSessionMetaRow({
 			sessionId: record.id,
 			startedAt: new Date(record.startedAt),
-			version: nextMetaVersion(),
+			version,
 			status,
 			serviceName: options.serviceName,
 			identity: options.getIdentity?.(),
@@ -2034,6 +2661,10 @@ function startSessionLifecycle(options, hooks) {
 		clearInterval(heartbeat);
 		heartbeat = void 0;
 	};
+	const clearPauseTimer = () => {
+		if (pauseTimer !== void 0) clearTimeout(pauseTimer);
+		pauseTimer = void 0;
+	};
 	const startRun = () => {
 		if (stopped || running) return;
 		running = true;
@@ -2042,6 +2673,10 @@ function startSessionLifecycle(options, hooks) {
 		rebaseCounts(record);
 		hooks.onStart?.(record);
 		post("active", false);
+		startHeartbeat();
+	};
+	const startHeartbeat = () => {
+		stopHeartbeat();
 		heartbeat = setInterval(() => {
 			if (typeof document !== "undefined" && document.visibilityState !== "visible") return;
 			if (isSessionExpired(liveRecord())) {
@@ -2058,9 +2693,32 @@ function startSessionLifecycle(options, hooks) {
 		if (!running) return;
 		running = false;
 		stopHeartbeat();
-		if (suspend.flush) post("ended", suspend.keepalive);
+		clearPauseTimer();
+		if (suspend.flush && !paused) post("ended", suspend.keepalive);
+		paused = false;
 		return hooks.onSuspend?.(suspend);
 	};
+	const pauseRun = (onPause) => {
+		if (!running || paused) return;
+		paused = true;
+		stopHeartbeat();
+		post("ended", true);
+		onPause({ keepalive: true });
+		const idleIn = liveRecord().lastActivityAt + IDLE_TIMEOUT_MS - Date.now();
+		pauseTimer = setTimeout(() => {
+			pauseTimer = void 0;
+			endRun({
+				flush: true,
+				keepalive: false
+			});
+		}, Math.max(0, idleIn) + 1e3);
+	};
+	const resumeRun = () => {
+		clearPauseTimer();
+		paused = false;
+		post("active", false);
+		startHeartbeat();
+	};
 	const stopRotationListener = onSessionRotate((previous, next) => {
 		if (stopped || previous.id !== current.id) return;
 		endRun({
@@ -2079,7 +2737,8 @@ function startSessionLifecycle(options, hooks) {
 		const doc = browserDocument();
 		if (!doc) return;
 		if (doc.visibilityState === "hidden") {
-			endRun({
+			if (hooks.onPause) pauseRun(hooks.onPause);
+			else endRun({
 				flush: true,
 				keepalive: true
 			});
@@ -2089,7 +2748,8 @@ function startSessionLifecycle(options, hooks) {
 			getSession();
 			return;
 		}
-		startRun();
+		if (paused) resumeRun();
+		else startRun();
 	};
 	const visibilityTarget = typeof document !== "undefined" && typeof document.addEventListener === "function" ? document : typeof globalThis.addEventListener === "function" ? globalThis : void 0;
 	const pageHideTarget = typeof globalThis.addEventListener === "function" ? globalThis : void 0;
@@ -2101,7 +2761,7 @@ function startSessionLifecycle(options, hooks) {
 			return current.id;
 		},
 		announce: () => {
-			if (running) post("active", false);
+			if (running) post(paused ? "ended" : "active", false);
 		},
 		shutdown: async (shutdownOptions) => {
 			if (stopped) return;
@@ -2187,4 +2847,4 @@ function readSessionSink() {
 	return globalThis[SESSION_SINK_KEY];
 }
 //#endregion
-export { selectorOf as A, mayPersistIdentifier as B, otlpKeepaliveRoom as C, reserveKeepalive as D, postToIngest as E, withStartedTraceId as F, scrubUrl as G, setConsent as H, configurePrivacy as I, mayUseStorage as K, consentAllowedSince as L, safeEmit as M, activeTraceId as N, sdkHint as O, setActiveTraceIdProvider as P, consentRevokedAt as R, ingestHeaders as S, postSessionMeta as T, setVisitorTracking as U, onConsentChange as V, isJsonObject as W, rotateSession as _, recordTraceId as a, OTLP_UNLOAD_TAIL_BYTES as b, getActiveSink as c, startEventSink as d, claimReplayMode as f, nextChunkSeq as g, markReplayTriggered as h, readSessionSink as i, BLOCK_SELECTOR as j, warnDropped 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, postSessionBlob as w, gzip as x, isLikelyBot as y, hasConsent as z };
+export { postToIngest as A, withStartedTraceId as B, OTLP_UNLOAD_TAIL_BYTES as C, otlpKeepaliveRoom as D, ingestHeaders as E, BLOCK_SELECTOR as F, mayPersistIdentifier as G, consentAllowedSince as H, safeEmit as I, setVisitorTracking as J, onConsentChange as K, truncateText as L, sdkHint as M, warnDropped as N, postSessionBlob as O, selectorOf as P, activeTraceId as R, isLikelyBot as S, gzipStored as T, consentRevokedAt as U, configurePrivacy as V, hasConsent as W, scrubUrl as X, isJsonObject as Y, mayUseStorage as Z, markReplayTriggered as _, recordTraceId as a, patchMethod as b, getActiveSink as c, startEventSink as d, claimReplayMode as f, markReplayHalted as g, markActivity as h, readSessionSink as i, reserveKeepalive as j, postSessionMeta as k, onSessionEvent as l, isReplayHalted as m, getObservedTraceIds as n, startSessionLifecycle as o, getSession as p, setConsent as q, publishSessionSink as r, clearPendingEvents as s, clearSessionSink as t, queuePending as u, nextChunkSeq as v, gzip as w, postSessionMetaRow as x, rotateSession as y, setActiveTraceIdProvider as z };