@maple-dev/browser 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { C as setActiveTraceIdProvider, T as setVisitorTracking, a as recordTraceId, b as sdkHint, c as getActiveSink, d as getSession, g as SDK_HINT_HEADER, h as postSessionMetaRow, i as readSessionSink, l as queuePending, m as rotateSession, n as getObservedTraceIds, o as startSessionLifecycle, r as publishSessionSink, s as clearPendingEvents, t as clearSessionSink, u as startEventSink, w as configureVisitorCookie } from "./sink-D9w1kg0Q.mjs";
-import { trace } from "@opentelemetry/api";
+import { A as setVisitorTracking, D as setActiveTraceIdProvider, M as scrubUrl, S as sdkHint, _ as isLikelyBot, a as recordTraceId, c as getActiveSink, d as claimReplaySample, f as getSession, g as postSessionMetaRow, h as rotateSession, i as readSessionSink, j as addUrlSanitizer, k as configureVisitorCookie, l as queuePending, n as getObservedTraceIds, o as startSessionLifecycle, r as publishSessionSink, s as clearPendingEvents, t as clearSessionSink, u as startEventSink, v as SDK_HINT_HEADER } from "./sink-DHPiMgU0.mjs";
+import { ProxyTracerProvider, SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
@@ -76,6 +76,7 @@ function configurePrivacy(options) {
 		crossSubdomainCookie: options?.crossSubdomainCookie,
 		cookieDomain: options?.cookieDomain
 	});
+	if (options?.sanitizeUrl) addUrlSanitizer(options.sanitizeUrl);
 	updateEffectiveConsent(previous);
 }
 /** Record the user's consent decision. No-op unless `requireConsent` is set. */
@@ -151,7 +152,7 @@ function normalizeTraits(traits) {
 		if (!key) continue;
 		if (!warnedAboutTraitKeys && looksLikeId(key)) {
 			warnedAboutTraitKeys = true;
-			console.warn(`[maple] identity trait key "${key}" looks like an id. Trait keys share a ClickHouse dictionary — put ids in the value, or in id/groupId, not the key.`);
+			console.warn(`[maple] identity trait key "${key}" looks like an id. A key per user widens every session row's trait map; put ids in the value, or in id/groupId, not the key.`);
 		}
 		out[key] = value;
 	}
@@ -209,18 +210,11 @@ function startMetadataSession(options) {
 	});
 }
 //#endregion
-//#region ../browser-session/src/events/track.ts
-/**
-* Caps mirroring what the ingest gateway enforces. Applying them here too means
-* an over-sized event is trimmed before it costs bandwidth, and the developer
-* sees the same shape locally that the warehouse will store.
-*/
-const MAX_NAME_LENGTH = 128;
+//#region ../browser-session/src/events/props.ts
 const MAX_PROPS = 32;
 const MAX_PROP_KEY_LENGTH = 64;
 const MAX_PROP_VALUE_LENGTH = 1024;
 const MAX_TOTAL_PROP_BYTES = 8192;
-let warnedAboutName = false;
 /**
 * Coerce one property value to the string the warehouse column holds.
 *
@@ -244,7 +238,8 @@ function coerce(value) {
 		return;
 	}
 }
-function coerceProps(props) {
+/** Coerce and cap a `track()` property bag to the `Map(String, String)` the warehouse stores. */
+function coerceTrackProps(props) {
 	if (!props) return {};
 	const out = {};
 	let bytes = 0;
@@ -260,6 +255,9 @@ function coerceProps(props) {
 	}
 	return out;
 }
+//#endregion
+//#region ../browser-session/src/events/track.ts
+let warnedAboutName = false;
 /**
 * Record a custom product event against the current session.
 *
@@ -281,8 +279,8 @@ function track(name, props) {
 	}
 	const ev = {
 		type: "custom",
-		message: name.trim().slice(0, MAX_NAME_LENGTH),
-		attrs: coerceProps(props),
+		message: name.trim().slice(0, 128),
+		attrs: coerceTrackProps(props),
 		timestamp: Date.now(),
 		url: typeof location !== "undefined" ? location.href : void 0
 	};
@@ -291,48 +289,69 @@ function track(name, props) {
 	else queuePending(ev);
 }
 //#endregion
-//#region src/config.ts
-const DEFAULT_ENDPOINT = "https://ingest.maple.dev";
+//#region ../browser-session/src/platform/region.ts
+const MAPLE_REGIONS = ["us", "eu"];
+const INGEST_ENDPOINTS = {
+	us: "https://ingest.maple.dev",
+	eu: "https://ingest.eu.maple.dev"
+};
 /**
-* Resolve the identity from either the new `user` object or the legacy
-* `userId` string. `user` wins when both are set.
+* Narrow an untyped region (an env var, or a JS caller outside the type
+* checker) to a known one. Case and surrounding whitespace are ignored;
+* anything else is `undefined`.
 */
-function resolveIdentity(config) {
-	return normalizeIdentity(config.user ?? config.userId);
+function parseRegion(raw) {
+	if (typeof raw !== "string") return void 0;
+	const value = raw.trim().toLowerCase();
+	return MAPLE_REGIONS.find((region) => region === value);
 }
-function resolveConfig(config) {
-	return {
-		ingestKey: config.ingestKey,
-		serviceName: config.serviceName,
-		endpoint: (config.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, ""),
-		serviceNamespace: config.serviceNamespace,
-		serviceVersion: config.serviceVersion,
-		environment: config.environment,
-		identity: resolveIdentity(config),
-		tracingEnabled: config.tracing?.enabled ?? true,
-		tracingInstrumentFetch: config.tracing?.instrumentFetch ?? true,
-		replayEnabled: config.replay?.enabled ?? true,
-		replaySampleRate: config.replay?.sampleRate ?? 1,
-		maskAllInputs: config.privacy?.maskAllInputs ?? true,
-		maskAllText: config.privacy?.maskAllText ?? false,
-		persistVisitorId: config.privacy?.persistVisitorId ?? true,
-		crossSubdomainCookie: config.privacy?.crossSubdomainCookie ?? true,
-		cookieDomain: config.privacy?.cookieDomain,
-		requireConsent: config.privacy?.requireConsent ?? false,
-		captureUserEmail: config.privacy?.captureUserEmail ?? true,
-		respectDoNotTrack: config.privacy?.respectDoNotTrack ?? false
-	};
+let warnedRegions = /* @__PURE__ */ new Set();
+/**
+* The ingest base URL for a region. An unrecognized value falls back to the
+* default region with a console warning rather than throwing: the ingest key
+* belongs to one instance, so the other one rejects it and no data lands in
+* the wrong place.
+*/
+function ingestEndpointForRegion(region) {
+	if (region === void 0 || region === null || region === "") return INGEST_ENDPOINTS["us"];
+	const parsed = parseRegion(region);
+	if (parsed) return INGEST_ENDPOINTS[parsed];
+	const label = String(region);
+	if (!warnedRegions.has(label)) {
+		warnedRegions.add(label);
+		console.warn(`[maple] unknown region "${label}"; expected one of ${MAPLE_REGIONS.join(", ")}. Using "us".`);
+	}
+	return INGEST_ENDPOINTS["us"];
+}
+/** Loop rather than `/\/+$/`: that pattern backtracks polynomially on a long run of slashes. */
+function trimTrailingSlashes(value) {
+	let end = value.length;
+	while (end > 0 && value.charCodeAt(end - 1) === 47) end--;
+	return value.slice(0, end);
+}
+/**
+* Resolve the ingest base URL. An explicit URL always beats a region, whichever
+* source each came from, so a collector or proxy endpoint is never bypassed by
+* a region set elsewhere. Candidates are tried in order; the first non-empty
+* one wins.
+*/
+function resolveIngestEndpoint(options) {
+	for (const endpoint of options.endpoints) if (endpoint) return trimTrailingSlashes(endpoint);
+	return ingestEndpointForRegion(options.regions.find((value) => value !== void 0 && value !== null && value !== ""));
 }
 //#endregion
 //#region src/version.ts
-const SDK_VERSION = "0.8.0";
+const SDK_VERSION = "0.9.0";
 /** The `x-maple-sdk` value this build sends. */
 const SDK_NAME = "maple-browser";
 //#endregion
 //#region src/tracing.ts
+/** Span attributes that carry a page or request URL. */
+const URL_ATTRIBUTES = ["url.full", "http.url"];
 /**
-* Captures every span's trace id into the session sink. Lightweight — runs
-* alongside the BatchSpanProcessor, does no export of its own.
+* Captures every span's trace id into the session sink, and redacts URL
+* attributes before anything can export them. Lightweight: runs alongside the
+* BatchSpanProcessor, does no export of its own.
 */
 var TraceIdCollector = class {
 	getUserId;
@@ -340,6 +359,10 @@ var TraceIdCollector = class {
 		this.getUserId = getUserId;
 	}
 	onStart(span) {
+		for (const key of URL_ATTRIBUTES) {
+			const value = span.attributes[key];
+			if (typeof value === "string") span.setAttribute(key, scrubUrl(value));
+		}
 		if (!hasConsent()) return;
 		recordTraceId(span.spanContext().traceId);
 		const sessionId = readSessionSink()?.sessionId;
@@ -395,6 +418,16 @@ var ConsentSpanExporter = class {
 */
 const EXPORT_INTERVAL_MS = 2e3;
 /**
+* The provider this SDK registered, while it is live. `captureException` spans
+* through it directly: the global provider may belong to the host app, which
+* registered first and so kept the global.
+*/
+let mapleProvider;
+/** A tracer on Maple's provider when tracing is live, otherwise the global one. */
+function mapleTracer(name, version) {
+	return (mapleProvider ?? trace.getTracerProvider()).getTracer(name, version);
+}
+/**
 * Set up browser OTel tracing exporting to Maple's ingest. When
 * `tracingInstrumentFetch` is true, fetch() calls are auto-instrumented and
 * their trace ids feed the session. Disable it when an external tracer (e.g.
@@ -416,7 +449,7 @@ function setupTracing(config) {
 	if (config.serviceNamespace) attributes["service.namespace"] = config.serviceNamespace;
 	if (config.serviceVersion) {
 		attributes[ATTR_SERVICE_VERSION] = config.serviceVersion;
-		attributes["deployment.commit_sha"] = config.serviceVersion;
+		if (/^[0-9a-f]{7,40}$/i.test(config.serviceVersion)) attributes["vcs.ref.head.revision"] = config.serviceVersion;
 	}
 	if (config.environment) {
 		attributes["deployment.environment"] = config.environment;
@@ -434,6 +467,9 @@ function setupTracing(config) {
 		spanProcessors: [new TraceIdCollector(() => config.identity?.id), new BatchSpanProcessor(exporter, { scheduledDelayMillis: EXPORT_INTERVAL_MS })]
 	});
 	provider.register();
+	mapleProvider = provider;
+	const globalProvider = trace.getTracerProvider();
+	const ownsGlobals = globalProvider === provider || globalProvider instanceof ProxyTracerProvider && globalProvider.getDelegate() === provider;
 	const onExit = () => {
 		provider.forceFlush().catch(() => {});
 	};
@@ -445,26 +481,187 @@ function setupTracing(config) {
 		document.addEventListener("visibilitychange", onVisibilityChange);
 		window.addEventListener("pagehide", onExit);
 	}
-	const unregisterInstrumentations = config.tracingInstrumentFetch ? registerInstrumentations({ instrumentations: [new FetchInstrumentation({ ignoreUrls: [new RegExp(`${escapeRegExp(config.endpoint)}/v1/`)] })] }) : void 0;
+	const unregisterInstrumentations = config.tracingInstrumentFetch ? registerInstrumentations({
+		tracerProvider: provider,
+		instrumentations: [new FetchInstrumentation({
+			ignoreUrls: [new RegExp(`${escapeRegExp(config.endpoint)}/v1/`)],
+			propagateTraceHeaderCorsUrls: [...config.propagateTraceHeaderCorsUrls]
+		})]
+	}) : void 0;
 	return async () => {
 		if (canListen) {
 			document.removeEventListener("visibilitychange", onVisibilityChange);
 			window.removeEventListener("pagehide", onExit);
 		}
 		unregisterInstrumentations?.();
+		if (mapleProvider === provider) mapleProvider = void 0;
 		await provider.shutdown();
+		if (ownsGlobals) {
+			trace.disable();
+			context.disable();
+			propagation.disable();
+		}
 	};
 }
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 //#endregion
+//#region src/errors.ts
+const asError = (value) => {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	if (typeof value === "object" && value !== null) {
+		const message = value.message;
+		if (typeof message === "string") return new Error(message);
+	}
+	try {
+		return new Error(String(value));
+	} catch {
+		return /* @__PURE__ */ new Error("Unknown error");
+	}
+};
+/**
+* Errors already reported, by identity. Module-level so the global handlers and
+* `captureException` share it: a framework boundary that reports an error and
+* then rethrows it would otherwise produce two issues for one crash.
+*/
+let reported = /* @__PURE__ */ new WeakSet();
+/** Whether this exact error object was already recorded. */
+const alreadyReported = (error) => typeof error === "object" && error !== null && reported.has(error);
+/**
+* Record `error` on a one-off span. The error is claimed only when the span is
+* recording: before `init()` the tracer is a no-op, and claiming it then would
+* swallow the same error reported again once tracing is live.
+*/
+function recordException(error, options) {
+	const normalized = asError(error);
+	const span = mapleTracer(SDK_NAME, SDK_VERSION).startSpan(options.name ?? "exception", {
+		kind: SpanKind.INTERNAL,
+		attributes: {
+			...typeof location !== "undefined" ? { "url.full": scrubUrl(location.href) } : void 0,
+			...options.attributes
+		}
+	});
+	if (span.isRecording() && typeof error === "object" && error !== null) reported.add(error);
+	span.recordException(normalized);
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message: normalized.message
+	});
+	span.end();
+}
+/**
+* Record an error that no span was watching. Safe before `init()`: without a
+* registered provider the OTel API hands back a no-op tracer and this does
+* nothing. Reporting the same error object twice records it once.
+*/
+function captureException(error, options = {}) {
+	if (alreadyReported(error)) return;
+	recordException(error, options);
+}
+/**
+* Register global handlers for uncaught errors and unhandled rejections.
+* Returns a teardown that removes them.
+*/
+function setupErrorCapture() {
+	if (typeof window === "undefined" || typeof window.addEventListener !== "function") return () => {};
+	const onError = (event) => {
+		const error = event.error ?? (event.message && event.filename ? new Error(event.message) : void 0);
+		if (error === void 0 || alreadyReported(error)) return;
+		recordException(error, {
+			name: "browser.uncaught_error",
+			attributes: {
+				"maple.exception.source": "window.onerror",
+				...event.filename ? { "code.file.path": event.filename } : void 0,
+				...event.lineno ? { "code.line.number": event.lineno } : void 0
+			}
+		});
+	};
+	const onUnhandledRejection = (event) => {
+		if (alreadyReported(event.reason)) return;
+		recordException(event.reason, {
+			name: "browser.unhandled_rejection",
+			attributes: { "maple.exception.source": "unhandledrejection" }
+		});
+	};
+	window.addEventListener("error", onError);
+	window.addEventListener("unhandledrejection", onUnhandledRejection);
+	return () => {
+		window.removeEventListener("error", onError);
+		window.removeEventListener("unhandledrejection", onUnhandledRejection);
+	};
+}
+//#endregion
+//#region src/config.ts
+/**
+* Resolve the identity from either the new `user` object or the legacy
+* `userId` string. `user` wins when both are set.
+*/
+function resolveIdentity(config) {
+	return normalizeIdentity(config.user ?? config.userId);
+}
+/**
+* A sample rate outside 0–1 (or not a number) is a typo, not a policy. Clamp it
+* and say so, rather than recording everyone or no one without a word.
+*/
+function resolveSampleRate(raw) {
+	if (raw === void 0) return 1;
+	if (typeof raw !== "number" || Number.isNaN(raw)) {
+		console.warn(`[maple] replay.sampleRate must be a number between 0 and 1; got ${String(raw)}. Using 1.`);
+		return 1;
+	}
+	if (raw < 0 || raw > 1) {
+		const clamped = Math.min(1, Math.max(0, raw));
+		console.warn(`[maple] replay.sampleRate must be between 0 and 1; got ${raw}. Using ${clamped}.`);
+		return clamped;
+	}
+	return raw;
+}
+function resolveConfig(config) {
+	if (!config.ingestKey) console.warn("[maple] MapleBrowser.init() has no ingestKey; ingest will reject every request.");
+	return {
+		ingestKey: config.ingestKey,
+		serviceName: config.serviceName,
+		endpoint: resolveIngestEndpoint({
+			endpoints: [config.endpoint],
+			regions: [config.region]
+		}),
+		serviceNamespace: config.serviceNamespace,
+		serviceVersion: config.serviceVersion,
+		environment: config.environment,
+		identity: resolveIdentity(config),
+		tracingEnabled: config.tracing?.enabled ?? true,
+		tracingInstrumentFetch: config.tracing?.instrumentFetch ?? true,
+		tracingCaptureErrors: config.tracing?.captureErrors ?? true,
+		propagateTraceHeaderCorsUrls: config.tracing?.propagateTraceHeaderCorsUrls ?? [],
+		replayEnabled: config.replay?.enabled ?? true,
+		replaySampleRate: resolveSampleRate(config.replay?.sampleRate),
+		maskAllInputs: config.privacy?.maskAllInputs ?? true,
+		maskAllText: config.privacy?.maskAllText ?? false,
+		persistVisitorId: config.privacy?.persistVisitorId ?? true,
+		crossSubdomainCookie: config.privacy?.crossSubdomainCookie ?? true,
+		cookieDomain: config.privacy?.cookieDomain,
+		requireConsent: config.privacy?.requireConsent ?? false,
+		captureUserEmail: config.privacy?.captureUserEmail ?? true,
+		respectDoNotTrack: config.privacy?.respectDoNotTrack ?? false,
+		sanitizeUrl: config.privacy?.sanitizeUrl
+	};
+}
+//#endregion
 //#region src/init.ts
 /** `x-maple-sdk` value for every request this build makes to ingest. */
 const SDK_HINT = sdkHint(SDK_NAME, SDK_VERSION);
 let active;
 let activeConfig;
 /**
+* An `identify()` made before `init()`, applied when it runs. Auth callbacks
+* routinely resolve before the SDK is initialized; dropping the call meant the
+* whole first session went anonymous. Wrapped so a pending *clear* (`undefined`)
+* is distinguishable from no call at all.
+*/
+let pendingIdentity;
+/**
 * Initialize Maple browser telemetry. With consent gating enabled the returned
 * handle remains live while denied: granting starts capture, revoking detaches
 * it without flushing, and a later grant starts cleanly again.
@@ -476,30 +673,36 @@ function init(rawConfig) {
 		shutdown: () => Promise.resolve()
 	};
 	const config = resolveConfig(rawConfig);
+	if (pendingIdentity) config.identity = normalizeIdentity(pendingIdentity.input);
+	pendingIdentity = void 0;
 	activeConfig = config;
 	configurePrivacy(config);
 	if (!hasConsent()) clearPendingEvents();
 	setActiveTraceIdProvider(() => trace.getActiveSpan()?.spanContext().traceId);
-	const recordReplay = config.replayEnabled && Math.random() < config.replaySampleRate;
+	const replayEligible = config.replayEnabled && !isLikelyBot(navigator.userAgent);
 	let runtime;
 	let stopped = false;
 	let rotateOnNextStart = false;
 	let shutdownTracing;
+	let stopErrorCapture;
 	let generation = 0;
 	const startRuntime = () => {
 		if (stopped || runtime || !hasConsent()) return;
 		setVisitorTracking(config.persistVisitorId && mayPersistIdentifier());
 		const session = (rotateOnNextStart ? rotateSession() : void 0) ?? getSession();
 		rotateOnNextStart = false;
+		const recordReplay = replayEligible && claimReplaySample(config.replaySampleRate);
 		publishSessionSink(session.id);
 		const sink = startEventSink({
 			endpoint: config.endpoint,
 			ingestKey: config.ingestKey,
 			sdk: SDK_HINT,
 			maskAllInputs: config.maskAllInputs,
-			maskAllText: config.maskAllText
+			maskAllText: config.maskAllText,
+			getIdentity: () => activeConfig?.identity
 		}, session.id);
 		if (config.tracingEnabled && !shutdownTracing) shutdownTracing = setupTracing(config);
+		if (config.tracingEnabled && config.tracingCaptureErrors && !stopErrorCapture) stopErrorCapture = setupErrorCapture();
 		const shared = {
 			endpoint: config.endpoint,
 			ingestKey: config.ingestKey,
@@ -530,7 +733,7 @@ function init(rawConfig) {
 		runtime = next;
 		const ownGeneration = ++generation;
 		const stale = () => stopped || !hasConsent() || generation !== ownGeneration || runtime !== next;
-		next.replayPending = import("./replay-session-BYZfi3iZ.mjs").then(({ startReplaySession }) => {
+		next.replayPending = import("./replay-session-gSlAYwqV.mjs").then(({ startReplaySession }) => {
 			if (stale()) return;
 			next.replay = startReplaySession({
 				...shared,
@@ -582,6 +785,8 @@ function init(rawConfig) {
 			stopped = true;
 			stopConsentListener();
 			await stopRuntime(true);
+			stopErrorCapture?.();
+			stopErrorCapture = void 0;
 			await shutdownTracing?.();
 			shutdownTracing = void 0;
 			setActiveTraceIdProvider(() => void 0);
@@ -607,9 +812,16 @@ function init(rawConfig) {
 *
 * Each call replaces the identity rather than merging — merging would leak a
 * signed-out user's email into whoever signs in next on a shared device.
+*
+* Safe before `init()`: the latest call is held and applied when `init()` runs,
+* taking precedence over the `user` passed to it.
 */
 function identify(input) {
-	if (typeof window === "undefined" || !activeConfig) return;
+	if (typeof window === "undefined") return;
+	if (!activeConfig) {
+		pendingIdentity = { input };
+		return;
+	}
 	activeConfig.identity = normalizeIdentity(input);
 }
 //#endregion
@@ -625,6 +837,7 @@ function identify(input) {
 * MapleBrowser.init({
 *   ingestKey: "maple_pk_...",
 *   serviceName: "acme-web",
+*   region: "eu", // omit for the US region
 * })
 *
 * MapleBrowser.identify({ id: user.id, email: user.email, groupId: org.id, groupName: org.name })
@@ -635,6 +848,7 @@ const MapleBrowser = {
 	init,
 	identify,
 	track,
+	captureException,
 	setConsent
 };
 //#endregion

package/dist/{replay-session-BYZfi3iZ.mjs → replay-session-gSlAYwqV.mjs}

@@ -1,4 +1,4 @@
-import { S as activeTraceId, _ as gzip, f as markActivity, n as getObservedTraceIds, o as startSessionLifecycle, p as nextChunkSeq, r as publishSessionSink, u as startEventSink, v as postSessionBlob, x as safeEmit, y as postSessionMeta } from "./sink-D9w1kg0Q.mjs";
+import { C as warnDropped, E as activeTraceId, M as scrubUrl, O as withStartedTraceId, T as safeEmit, b as postSessionBlob, m as nextChunkSeq, n as getObservedTraceIds, o as startSessionLifecycle, p as markActivity, r as publishSessionSink, u as startEventSink, w as BLOCK_SELECTOR, x as postSessionMeta, y as gzip } from "./sink-DHPiMgU0.mjs";
 import { record } from "rrweb";
 //#region ../browser-session/src/replay/capture/console.ts
 const LEVELS = [
@@ -9,6 +9,8 @@ const LEVELS = [
 	"debug"
 ];
 const MAX_MESSAGE = 2e3;
+/** No array logged into a 2,000-character message needs more elements than this. */
+const MAX_ARRAY_ELEMENTS = 100;
 /**
 * Capture `console.*` calls as session events. Wraps each method, emits a
 * distilled record, then forwards to the original so the host app's console
@@ -40,13 +42,29 @@ function formatArgs(args) {
 		if (typeof a === "string") return a;
 		if (a instanceof Error) return `${a.name}: ${a.message}`;
 		try {
-			return JSON.stringify(a);
+			return boundedStringify(a, MAX_MESSAGE) ?? String(a);
 		} catch {
 			return String(a);
 		}
 	}).join(" ");
 	return text.length > MAX_MESSAGE ? `${text.slice(0, MAX_MESSAGE)}…` : text;
 }
+/**
+* `JSON.stringify` that stops descending once roughly `budget` characters have
+* been produced. The message is cut to `MAX_MESSAGE` anyway, and serializing a
+* whole store object on every `console.log` first was a main-thread cost paid
+* on the host app's hot path. A replacer returning `undefined` skips a value
+* without visiting its children, so the walk is bounded by the budget.
+*/
+function boundedStringify(value, budget) {
+	let used = 0;
+	return JSON.stringify(value, (key, nested) => {
+		if (used > budget) return void 0;
+		used += key.length + (typeof nested === "string" ? nested.length : 4);
+		if (Array.isArray(nested) && nested.length > MAX_ARRAY_ELEMENTS) return nested.slice(0, MAX_ARRAY_ELEMENTS);
+		return nested;
+	});
+}
 //#endregion
 //#region ../browser-session/src/replay/capture/network.ts
 /**
@@ -59,10 +77,13 @@ function installNetworkCapture(emit, ignoreUrl) {
 	if (origFetch) window.fetch = async (input, init) => {
 		const url = requestUrl(input);
 		const method = requestMethod(input, init);
-		const traceId = activeTraceId();
+		const ambientTraceId = activeTraceId();
 		const start = performance.now();
+		let traceId = ambientTraceId;
 		try {
-			const res = await origFetch(input, init);
+			const call = withStartedTraceId(() => origFetch(input, init));
+			traceId = call.traceId ?? ambientTraceId;
+			const res = await call.result;
 			record(url, method, res.status, start, traceId);
 			return res;
 		} catch (error) {
@@ -100,11 +121,13 @@ function installNetworkCapture(emit, ignoreUrl) {
 		XHR.prototype.send = function(...args) {
 			const meta = this;
 			const start = performance.now();
-			const traceId = activeTraceId();
+			let traceId = activeTraceId();
 			this.addEventListener("loadend", () => {
 				record(meta.__mapleUrl ?? "", meta.__mapleMethod ?? "GET", this.status, start, traceId);
 			});
-			return origSend.apply(this, args);
+			const call = withStartedTraceId(() => origSend.apply(this, args));
+			traceId = call.traceId ?? traceId;
+			return call.result;
 		};
 	}
 	return () => {
@@ -146,6 +169,7 @@ function startEventCapture(config, sessionId) {
 //#endregion
 //#region ../browser-session/src/replay/record.ts
 const FULL_SNAPSHOT = 2;
+const META = 4;
 const INCREMENTAL = 3;
 const SOURCE_MOUSE_INTERACTION = 2;
 const MOUSE_CLICK = 2;
@@ -188,7 +212,13 @@ function startRecording(config, sessionId) {
 		const durationMs = Math.max(0, lastTimestamp - firstTimestamp);
 		const seq = nextChunkSeq();
 		resetBuffer();
-		const gzipped = await gzip(new TextEncoder().encode(body));
+		let gzipped;
+		try {
+			gzipped = await gzip(new TextEncoder().encode(body));
+		} catch (error) {
+			warnDropped("chunk compression", error);
+			return;
+		}
 		if (await postSessionBlob(config, {
 			sessionId,
 			chunkSeq: seq,
@@ -207,6 +237,7 @@ function startRecording(config, sessionId) {
 			const active = markActivity();
 			if (active && active.id !== sessionId) return;
 			const e = event;
+			if (e.type === META && e.data && typeof e.data.href === "string") e.data.href = scrubUrl(e.data.href);
 			const isFullSnapshot = isCheckpoint === true || e.type === FULL_SNAPSHOT;
 			if (e.type === INCREMENTAL && e.data?.source === SOURCE_MOUSE_INTERACTION && e.data.type === MOUSE_CLICK) clickCount++;
 			let json;
@@ -231,6 +262,7 @@ function startRecording(config, sessionId) {
 			if (bufferBytes >= FLUSH_BYTES) flush();
 		},
 		maskAllInputs: config.maskAllInputs,
+		blockSelector: BLOCK_SELECTOR,
 		...config.maskAllText ? { maskTextSelector: "*" } : void 0,
 		checkoutEveryNms: CHECKOUT_EVERY_MS
 	});
@@ -283,7 +315,8 @@ function startReplaySession(options) {
 		ingestKey: options.ingestKey,
 		sdk: options.sdk,
 		maskAllInputs: options.maskAllInputs,
-		maskAllText: options.maskAllText
+		maskAllText: options.maskAllText,
+		getIdentity: options.getIdentity
 	};
 	let recorder;
 	let events;