@maple-dev/browser 0.4.0 → 0.9.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { S as setVisitorTracking, a as recordTraceId, b as postSessionMetaRow, c as clearPendingEvents, d as setActiveTraceIdProvider, f as startEventSink, g as rotateSession, i as readSessionSink, l as getActiveSink, n as getObservedTraceIds, o as startSessionLifecycle, p as getSession, r as publishSessionSink, t as clearSessionSink, u as queuePending, x as configureVisitorCookie } from "./sink-DHTfvFgl.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";
@@ -7,7 +7,7 @@ import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
-//#region ../browser-session/src/consent.ts
+//#region ../browser-session/src/identity/consent.ts
 /**
 * Consent gating for session capture.
 *
@@ -27,7 +27,7 @@ import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic
 */
 /**
 * Consent lives on `globalThis`, for the same reason the event sink does
-* (`events-sink.ts`): an app that bundles both `@maple-dev/browser` and the
+* (`events/events-sink.ts`): an app that bundles both `@maple-dev/browser` and the
 * Effect SDK gets **two copies** of this module, and per-copy state would mean
 * `setConsent(true)` on one never releases the other copy's exporters — or, the
 * other way round, one copy capturing while the other believes consent is
@@ -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. */
@@ -120,7 +121,7 @@ function mayPersistIdentifier() {
 	return true;
 }
 //#endregion
-//#region ../browser-session/src/identity.ts
+//#region ../browser-session/src/identity/identity.ts
 /**
 * Trait caps. The warehouse column is `Map(String, String)` — plain keys
 * precisely because they are arbitrary — so the cost of a unique key per user
@@ -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;
 	}
@@ -189,7 +190,7 @@ function normalizeIdentity(input) {
 	return resolved.id || resolved.email || resolved.username || resolved.groupId || resolved.groupName || Object.keys(resolved.traits).length > 0 ? resolved : void 0;
 }
 //#endregion
-//#region ../browser-session/src/metadata-session.ts
+//#region ../browser-session/src/session/metadata-session.ts
 /**
 * Metadata-only session lifecycle used whenever rrweb is disabled or unsampled.
 * It is the shared lifecycle driver with no capture of its own: the distilled
@@ -200,7 +201,7 @@ function startMetadataSession(options) {
 	return startSessionLifecycle(options, {
 		recorded: false,
 		post: (row, keepalive) => {
-			postSessionMetaRow(options.endpoint, options.ingestKey, row, keepalive);
+			postSessionMetaRow(options, row, keepalive);
 		},
 		onSuspend: ({ flush, keepalive }) => {
 			if (flush && keepalive) getActiveSink()?.flush(true);
@@ -209,18 +210,11 @@ function startMetadataSession(options) {
 	});
 }
 //#endregion
-//#region ../browser-session/src/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,43 +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.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;
@@ -335,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;
@@ -381,6 +409,25 @@ var ConsentSpanExporter = class {
 	}
 };
 /**
+* How long a span may sit in the batch queue before export.
+*
+* Shorter than OTel's 5s default: in a browser the queue is only as durable as
+* the tab, and the unload flush below is a best-effort catch rather than a
+* guarantee (a crashed or killed tab fires neither event). 2s trades a few more
+* requests for a materially smaller loss window.
+*/
+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.
@@ -402,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;
@@ -410,27 +457,211 @@ function setupTracing(config) {
 	}
 	const exporter = new ConsentSpanExporter(new OTLPTraceExporter({
 		url: `${config.endpoint}/v1/traces`,
-		headers: { Authorization: `Bearer ${config.ingestKey}` }
+		headers: {
+			Authorization: `Bearer ${config.ingestKey}`,
+			[SDK_HINT_HEADER]: sdkHint(SDK_NAME, SDK_VERSION)
+		}
 	}));
 	const provider = new WebTracerProvider({
 		resource: resourceFromAttributes(attributes),
-		spanProcessors: [new TraceIdCollector(() => config.identity?.id), new BatchSpanProcessor(exporter)]
+		spanProcessors: [new TraceIdCollector(() => config.identity?.id), new BatchSpanProcessor(exporter, { scheduledDelayMillis: EXPORT_INTERVAL_MS })]
 	});
 	provider.register();
-	const unregisterInstrumentations = config.tracingInstrumentFetch ? registerInstrumentations({ instrumentations: [new FetchInstrumentation({ ignoreUrls: [new RegExp(`${escapeRegExp(config.endpoint)}/v1/`)] })] }) : void 0;
+	mapleProvider = provider;
+	const globalProvider = trace.getTracerProvider();
+	const ownsGlobals = globalProvider === provider || globalProvider instanceof ProxyTracerProvider && globalProvider.getDelegate() === provider;
+	const onExit = () => {
+		provider.forceFlush().catch(() => {});
+	};
+	const onVisibilityChange = () => {
+		if (document.visibilityState === "hidden") onExit();
+	};
+	const canListen = typeof document !== "undefined" && typeof document.addEventListener === "function";
+	if (canListen) {
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		window.addEventListener("pagehide", onExit);
+	}
+	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.
@@ -442,32 +673,40 @@ 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,
+			sdk: SDK_HINT,
 			serviceName: config.serviceName,
 			environment: config.environment,
 			serviceVersion: config.serviceVersion,
@@ -494,7 +733,7 @@ function init(rawConfig) {
 		runtime = next;
 		const ownGeneration = ++generation;
 		const stale = () => stopped || !hasConsent() || generation !== ownGeneration || runtime !== next;
-		next.replayPending = import("./replay-session-B_ACRogX.mjs").then(({ startReplaySession }) => {
+		next.replayPending = import("./replay-session-gSlAYwqV.mjs").then(({ startReplaySession }) => {
 			if (stale()) return;
 			next.replay = startReplaySession({
 				...shared,
@@ -546,6 +785,8 @@ function init(rawConfig) {
 			stopped = true;
 			stopConsentListener();
 			await stopRuntime(true);
+			stopErrorCapture?.();
+			stopErrorCapture = void 0;
 			await shutdownTracing?.();
 			shutdownTracing = void 0;
 			setActiveTraceIdProvider(() => void 0);
@@ -571,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
@@ -589,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 })
@@ -599,6 +848,7 @@ const MapleBrowser = {
 	init,
 	identify,
 	track,
+	captureException,
 	setConsent
 };
 //#endregion