@maple-dev/browser 0.8.0 → 0.10.0

package/dist/src-Bzmp8rVr.mjs

@@ -0,0 +1,1722 @@
+import { A as setActiveTraceIdProvider, F as scrubUrl, M as configureVisitorCookie, N as setVisitorTracking, P as addUrlSanitizer, _ as rotateSession, a as recordTraceId, c as getActiveSink, d as startEventSink, f as claimReplayMode, i as readSessionSink, n as getObservedTraceIds, o as startSessionLifecycle, p as getSession, r as publishSessionSink, s as clearPendingEvents, t as clearSessionSink, u as queuePending, v as postSessionMetaRow, w as sdkHint, x as ingestHeaders, y as isLikelyBot } from "./sink-BOR9_z4b.mjs";
+import { ProxyTracerProvider, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, createTraceState, isSpanContextValid, propagation, trace } from "@opentelemetry/api";
+import { BatchSpanProcessor, SamplingDecision } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
+import { XMLHttpRequestInstrumentation } from "@opentelemetry/instrumentation-xml-http-request";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+//#region ../browser-session/src/identity/consent.ts
+/**
+* Consent gating for session capture.
+*
+* The posture, deliberately:
+*
+* - `requireConsent` defaults to **false**. Flipping that default would
+*   silently stop telemetry for every existing install — an availability
+*   incident dressed up as a privacy win. Apps that need a consent gate opt in.
+* - Global Privacy Control **is** honored by default, but only against the
+*   persistent visitor id, not the session itself. GPC is a legally recognized
+*   signal in several US states and it maps exactly onto the one cross-session
+*   identifier this SDK stores; the session-scoped capture that powers replay
+*   and error triage is unaffected.
+* - `doNotTrack` is **not** honored by default. It is deprecated, removed from
+*   Safari, and ignored across the industry, so respecting it would mostly mean
+*   dropping data from users who never intended to opt out. Apps can turn it on.
+*/
+/**
+* Consent lives on `globalThis`, for the same reason the event sink does
+* (`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
+* required. There is one user and one decision, so there is one state.
+*/
+const CONSENT_KEY = "__MAPLE_BROWSER_CONSENT__";
+function consentState() {
+	const owner = globalThis;
+	const existing = owner[CONSENT_KEY];
+	if (existing) return existing;
+	const fresh = {
+		allowedSince: 0,
+		granted: false,
+		listeners: /* @__PURE__ */ new Set(),
+		requireConsent: false,
+		respectDoNotTrack: false
+	};
+	owner[CONSENT_KEY] = fresh;
+	return fresh;
+}
+/** When consent was last withdrawn, on any page of this origin. Persisted: the grant time resets every load. */
+const REVOKED_AT_KEY = "maple-consent-revoked-at";
+function writeRevokedAt(at) {
+	try {
+		localStorage.setItem(REVOKED_AT_KEY, String(at));
+	} catch {}
+}
+/** Epoch ms of the last consent withdrawal on this origin, 0 if never. Data kept from before it must not be sent. */
+function consentRevokedAt() {
+	try {
+		return Number(localStorage.getItem(REVOKED_AT_KEY)) || 0;
+	} catch {
+		return 0;
+	}
+}
+function updateEffectiveConsent(previous) {
+	const state = consentState();
+	const allowed = hasConsent();
+	if (allowed === previous) return;
+	state.allowedSince = allowed ? Date.now() : Number.POSITIVE_INFINITY;
+	for (const listener of state.listeners) try {
+		listener(allowed);
+	} catch {}
+}
+/**
+* Apply the host app's privacy config. Call before anything captures.
+*
+* Both SDKs call this at startup, and an app can init one of them without a
+* `privacy` block — so the gates only ever **tighten**. Letting the second
+* caller's absent option reset `requireConsent` back to false would silently
+* disable a gate the first caller asked for, and the resulting
+* denied→allowed transition would start capture on a user who never consented.
+* To genuinely relax a gate, reload without it.
+*/
+function configurePrivacy(options) {
+	const state = consentState();
+	const previous = hasConsent();
+	state.requireConsent = state.requireConsent || (options?.requireConsent ?? false);
+	state.respectDoNotTrack = state.respectDoNotTrack || (options?.respectDoNotTrack ?? false);
+	configureVisitorCookie({
+		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. */
+function setConsent(nextGranted) {
+	const previous = hasConsent();
+	const state = consentState();
+	if (state.granted && !nextGranted) writeRevokedAt(Date.now());
+	state.granted = nextGranted;
+	updateEffectiveConsent(previous);
+}
+/** Whether capture may proceed at all. */
+function hasConsent() {
+	const state = consentState();
+	return !state.requireConsent || state.granted;
+}
+/**
+* Subscribe to effective capture permission changes. The listener is invoked
+* only when capture actually transitions between allowed and denied; changing
+* the stored decision while `requireConsent` is off is deliberately silent.
+*/
+function onConsentChange(listener) {
+	const { listeners } = consentState();
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+/**
+* Earliest epoch-ms timestamp telemetry may export for the current grant.
+* `Infinity` means capture is denied. Exporters use this to discard anything
+* buffered before a late grant or across a revoke/re-grant cycle.
+*/
+function consentAllowedSince() {
+	return hasConsent() ? consentState().allowedSince : Number.POSITIVE_INFINITY;
+}
+/**
+* Whether a *persistent* identifier may be stored. Separate from `hasConsent`
+* because GPC/DNT suppress the cross-session id without suppressing capture.
+*/
+function mayPersistIdentifier() {
+	if (!hasConsent()) return false;
+	if (typeof navigator === "undefined") return true;
+	const nav = navigator;
+	if (nav.globalPrivacyControl === true) return false;
+	if (consentState().respectDoNotTrack && nav.doNotTrack === "1") return false;
+	return true;
+}
+//#endregion
+//#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
+* is row size and query-time map width rather than a churned dictionary. The
+* cap bounds one row's damage; `warnOnIdLikeTraitKey` surfaces the pattern to
+* whoever wrote it, since an id in a trait key is nearly always a mistake.
+*/
+const MAX_TRAITS = 24;
+const MAX_TRAIT_KEY_LENGTH = 64;
+const MAX_TRAIT_VALUE_LENGTH = 256;
+let warnedAboutTraitKeys = false;
+/** Heuristic: a trait *key* that looks like an id is almost always a mistake. */
+function looksLikeId(key) {
+	return /^[0-9a-f]{8,}$/i.test(key) || /^(usr|user|org|cus|acct)_/i.test(key);
+}
+function coerceTraitValue(value) {
+	if (value === null || value === void 0) return void 0;
+	return (typeof value === "string" ? value : String(value)).slice(0, MAX_TRAIT_VALUE_LENGTH);
+}
+function normalizeTraits(traits) {
+	if (!traits) return {};
+	const out = {};
+	for (const [rawKey, rawValue] of Object.entries(traits)) {
+		if (Object.keys(out).length >= MAX_TRAITS) break;
+		const value = coerceTraitValue(rawValue);
+		if (value === void 0) continue;
+		const key = rawKey.slice(0, MAX_TRAIT_KEY_LENGTH);
+		if (!key) continue;
+		if (!warnedAboutTraitKeys && looksLikeId(key)) {
+			warnedAboutTraitKeys = true;
+			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;
+	}
+	return out;
+}
+function trimmed(value) {
+	const text = value?.trim();
+	return text ? text : void 0;
+}
+/**
+* Normalize whatever a host app passed into the shape the metadata row wants.
+*
+* Each call *replaces* the identity rather than merging into the previous one.
+* Merging would leak a signed-out user's email into the next person to use a
+* shared device, and replacement is what the existing string-only `identify`
+* already did.
+*/
+function normalizeIdentity(input) {
+	if (input === null || input === void 0) return void 0;
+	if (typeof input === "string") {
+		const id = trimmed(input);
+		return id ? {
+			id,
+			traits: {}
+		} : void 0;
+	}
+	const resolved = {
+		id: trimmed(input.id),
+		email: trimmed(input.email),
+		username: trimmed(input.username),
+		groupId: trimmed(input.groupId),
+		groupName: trimmed(input.groupName),
+		traits: normalizeTraits(input.traits)
+	};
+	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/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
+* event sink runs on every page load regardless, so this owner only has to post
+* rows and flush that sink on the way out.
+*/
+function startMetadataSession(options) {
+	return startSessionLifecycle(options, {
+		recorded: false,
+		post: (row, keepalive) => {
+			postSessionMetaRow(options, row, keepalive);
+		},
+		onSuspend: ({ flush, keepalive }) => {
+			if (flush && keepalive) getActiveSink()?.flush(true);
+		},
+		onSessionChange: options.onSessionChange
+	});
+}
+//#endregion
+//#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;
+/**
+* Coerce one property value to the string the warehouse column holds.
+*
+* `null`/`undefined`/functions/symbols are dropped rather than stringified —
+* `"undefined"` as a stored value is worse than an absent key.
+*/
+function coerce(value) {
+	if (value === null || value === void 0) return void 0;
+	switch (typeof value) {
+		case "string": return value.slice(0, MAX_PROP_VALUE_LENGTH);
+		case "number":
+		case "boolean":
+		case "bigint": return String(value);
+		case "function":
+		case "symbol": return;
+	}
+	try {
+		if (value instanceof Date) return value.toISOString();
+		return JSON.stringify(value)?.slice(0, MAX_PROP_VALUE_LENGTH);
+	} catch {
+		return;
+	}
+}
+/** 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;
+	for (const [rawKey, rawValue] of Object.entries(props)) {
+		if (Object.keys(out).length >= MAX_PROPS) break;
+		const value = coerce(rawValue);
+		if (value === void 0) continue;
+		const key = rawKey.slice(0, MAX_PROP_KEY_LENGTH);
+		if (!key) continue;
+		bytes += key.length + value.length;
+		if (bytes > MAX_TOTAL_PROP_BYTES) break;
+		out[key] = value;
+	}
+	return out;
+}
+//#endregion
+//#region ../browser-session/src/events/track.ts
+let warnedAboutName = false;
+/**
+* Record a custom product event against the current session.
+*
+* Stored as a `session_events` row with `Type='custom'`, so it shows up inline
+* in the session transcript alongside the clicks and network calls that
+* surround it — not in a separate analytics silo.
+*
+* Safe to call before the SDK finishes initializing: events are queued (capped)
+* and drained once the sink starts. Never throws.
+*/
+function track(name, props) {
+	if (!hasConsent()) return;
+	if (typeof name !== "string" || name.trim().length === 0) {
+		if (!warnedAboutName) {
+			warnedAboutName = true;
+			console.warn("[maple] track() needs a non-empty event name; the call was ignored.");
+		}
+		return;
+	}
+	const ev = {
+		type: "custom",
+		message: name.trim().slice(0, 128),
+		attrs: coerceTrackProps(props),
+		timestamp: Date.now(),
+		url: typeof location !== "undefined" ? location.href : void 0
+	};
+	const sink = getActiveSink();
+	if (sink) sink.emit(ev);
+	else queuePending(ev);
+}
+//#endregion
+//#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"
+};
+/**
+* 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 parseRegion(raw) {
+	if (typeof raw !== "string") return void 0;
+	const value = raw.trim().toLowerCase();
+	return MAPLE_REGIONS.find((region) => region === value);
+}
+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 !== ""));
+}
+/** Maple's hosted ingest, which rejects every write that carries no ingest key. */
+function isMapleIngestEndpoint(endpoint) {
+	let parsed;
+	try {
+		parsed = new URL(endpoint);
+	} catch {
+		return false;
+	}
+	if (trimTrailingSlashes(parsed.pathname) !== "") return false;
+	return MAPLE_REGIONS.some((region) => INGEST_ENDPOINTS[region] === parsed.origin);
+}
+let keylessWarned = /* @__PURE__ */ new Set();
+/**
+* Warn once per SDK about the one keyless setup that cannot work. The ingest
+* key is auth only, so every SDK still sends without one (a proxy or local sink
+* in front of a custom endpoint completes it), but Maple's hosted ingest 401s.
+*/
+function warnIfKeylessMapleIngest(options) {
+	if (options.hasIngestKey || !isMapleIngestEndpoint(options.endpoint)) return;
+	if (keylessWarned.has(options.logPrefix)) return;
+	keylessWarned.add(options.logPrefix);
+	console.warn(`${options.logPrefix} sending to the public Maple ingest without an ingest key; every request will be rejected with 401. ${options.hint}`);
+}
+//#endregion
+//#region ../sdk-core/src/errors.ts
+/** Deep enough for real wrapping chains, bounded against a cause cycle or a huge aggregate. */
+const MAX_LINKED = 5;
+const isRecord = (value) => typeof value === "object" && value !== null;
+/** Error-shaped: an `Error`, or a copy with its fields (Effect's pretty errors, a structured clone). */
+const isErrorLike = (value) => value instanceof Error || isRecord(value) && typeof value.name === "string" && typeof value.message === "string" && (value.stack === void 0 || typeof value.stack === "string");
+/**
+* BOUNDARY: a thrown value is unparsed by definition, JavaScript can throw anything.
+* Narrow it into an `Error` without ever throwing from the error path.
+*/
+function asError(value) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	if (isRecord(value) && typeof value.message === "string") return new Error(value.message);
+	try {
+		return new Error(String(value));
+	} catch {
+		return /* @__PURE__ */ new Error("Unknown error");
+	}
+}
+/** What an error links to: its `cause`, and its `errors` list (duck-typed, so copies qualify). */
+const linksOf = (value) => {
+	if (!isErrorLike(value)) return [];
+	const next = [];
+	try {
+		if ("errors" in value && Array.isArray(value.errors)) next.push(...value.errors);
+		if (value.cause !== void 0) next.push(value.cause);
+	} catch {}
+	return next;
+};
+/** A null-prototype object or a throwing `toString` must not break the error path. */
+function render(value) {
+	if (isRecord(value) && typeof value.message === "string") return value.message;
+	try {
+		return String(value);
+	} catch {
+		return Object.prototype.toString.call(value);
+	}
+}
+function linkedErrors(error) {
+	const linked = [];
+	const seen = /* @__PURE__ */ new Set([error]);
+	const queue = [error];
+	while (queue.length > 0 && linked.length < MAX_LINKED) for (const candidate of linksOf(queue.shift())) {
+		if (seen.has(candidate) || linked.length >= MAX_LINKED) continue;
+		seen.add(candidate);
+		linked.push(candidate);
+		queue.push(candidate);
+	}
+	return linked;
+}
+/** V8 starts a stack with a `Name: message` header; the other engines start at the first frame. */
+function framesOf(error) {
+	const stack = typeof error.stack === "string" ? error.stack : "";
+	const header = error.message ? `${error.name}: ${error.message}` : error.name;
+	return stack.startsWith(header) ? stack.slice(header.length).replace(/^\n/, "") : stack;
+}
+function describe(value) {
+	if (!isErrorLike(value)) return `Caused by: ${render(value)}`;
+	const frames = framesOf(value);
+	const header = `Caused by: ${value.name}: ${value.message}`;
+	return frames ? `${header}\n${frames}` : header;
+}
+/** The stack trace to record for `error`, with its linked errors appended. */
+function stackWithCauses(error) {
+	const linked = linkedErrors(error);
+	if (linked.length === 0) return error.stack;
+	return [error.stack ?? `${error.name}: ${error.message}`, ...linked.map(describe)].join("\n");
+}
+//#endregion
+//#region ../sdk-core/src/error-filters.ts
+const EXTENSION_URL = /^(?:chrome|moz|safari(?:-web)?|ms-browser)-extension:\/\//;
+const BENIGN_MESSAGES = [/^ResizeObserver loop (?:limit exceeded|completed with undelivered notifications)/];
+const URL_SCHEME = /^[a-z][\w+.-]*:\/\//i;
+const DIGITS = /^\d+$/;
+/**
+* The script URL of one frame: `at fn (url:1:2)`, `at url:1:2` (V8) or `fn@url:1:2`
+* (SpiderMonkey, JavaScriptCore). Parsed by position, not one regex: a stack is page
+* data, and a backtracking pattern over it can be made to run in polynomial time.
+*/
+function frameUrl(line) {
+	let frame = line.trim();
+	if (frame.endsWith(")")) {
+		const open = frame.lastIndexOf("(");
+		if (open === -1) return void 0;
+		frame = frame.slice(open + 1, -1);
+	} else if (frame.startsWith("at ")) frame = frame.slice(3);
+	else {
+		const at = frame.lastIndexOf("@");
+		if (at === -1) return void 0;
+		frame = frame.slice(at + 1);
+	}
+	for (let parts = 0; parts < 2; parts++) {
+		const colon = frame.lastIndexOf(":");
+		if (colon === -1 || !DIGITS.test(frame.slice(colon + 1))) {
+			if (parts === 0) return void 0;
+			break;
+		}
+		frame = frame.slice(0, colon);
+	}
+	if (!URL_SCHEME.test(frame) || /[\s()]/.test(frame)) return void 0;
+	return frame;
+}
+/** The script URL of each stack frame, top first. */
+function frameUrls(stack) {
+	if (!stack) return [];
+	const urls = [];
+	for (const line of stack.split("\n")) {
+		const url = frameUrl(line);
+		if (url) urls.push(url);
+	}
+	return urls;
+}
+const matches = (value, patterns) => patterns.some((pattern) => {
+	if (typeof pattern === "string") return value.includes(pattern);
+	pattern.lastIndex = 0;
+	return pattern.test(value);
+});
+/**
+* Build the filter for `options`. Without a `frameUrl`, only a thrown `Error`
+* has frames of its own: an `Error` wrapped around anything else points at the
+* SDK, so no URL list applies to it.
+*/
+function makeErrorFilter(options = {}) {
+	return (error, hint, frameUrl) => {
+		const text = `${error.name}: ${error.message}`;
+		const topUrl = frameUrl ?? (hint.originalError instanceof Error ? frameUrls(error.stack)[0] : void 0);
+		if (options.defaultFilters !== false) {
+			if (matches(error.message, BENIGN_MESSAGES)) return false;
+			if (topUrl && EXTENSION_URL.test(topUrl)) return false;
+		}
+		if (options.ignore && matches(text, options.ignore)) return false;
+		if (topUrl && options.denyUrls && matches(topUrl, options.denyUrls)) return false;
+		if (topUrl && options.allowUrls?.length && !matches(topUrl, options.allowUrls)) return false;
+		if (!options.beforeCapture) return true;
+		try {
+			return options.beforeCapture(error, hint) !== false;
+		} catch {
+			return true;
+		}
+	};
+}
+//#endregion
+//#region ../sdk-core/src/http-headers.ts
+/** Never recorded, even when listed: they carry credentials. */
+const CREDENTIAL_HEADERS = /* @__PURE__ */ new Set([
+	"authorization",
+	"proxy-authorization",
+	"cookie",
+	"set-cookie",
+	"x-api-key"
+]);
+function resolveHeaderCapture(raw) {
+	const clean = (names) => (names ?? []).map((name) => name.toLowerCase()).filter((name) => !CREDENTIAL_HEADERS.has(name));
+	return {
+		request: clean(raw?.request),
+		response: clean(raw?.response)
+	};
+}
+//#endregion
+//#region ../sdk-core/src/http-status.ts
+const inStatusRanges = (status, ranges) => ranges.some((range) => typeof range === "number" ? range === status : status >= range[0] && status <= range[1]);
+/** The status on a span's attributes, current or pre-1.23 semconv key. */
+function responseStatus(read) {
+	const value = read("http.response.status_code") ?? read("http.status_code");
+	if (typeof value === "number") return value;
+	if (typeof value === "string" && /^\d{3}$/.test(value)) return Number(value);
+}
+/**
+* The `error.type` / `error.message` pair for a listed status or a network
+* failure (`TypeError`, `timeout`), e.g. `POST https://api.example.com/users/42 -> 503`.
+* The query is dropped; ids in the path are redacted by the issue fingerprint.
+*/
+function httpStatusError(read, status) {
+	const method = read("http.request.method") ?? read("http.method") ?? "GET";
+	const url = String(read("url.full") ?? read("http.url") ?? "").replace(/[?#].*$/, "");
+	return {
+		"error.type": String(status),
+		"error.message": `${String(method)} ${url} -> ${status}`
+	};
+}
+//#endregion
+//#region ../sdk-core/src/log-record.ts
+/** OTel severity numbers for the levels the SDKs emit. */
+const Severity = {
+	DEBUG: 5,
+	INFO: 9,
+	WARN: 13,
+	ERROR: 17
+};
+/** A `Map`, not an object: a level string like `"constructor"` must not reach the prototype. */
+const LEVELS = /* @__PURE__ */ new Map([
+	["error", "ERROR"],
+	["warn", "WARN"],
+	["debug", "DEBUG"]
+]);
+/** Severity for a console level: `log` and `info` are INFO. */
+function severityOf(level) {
+	const text = (level !== void 0 ? LEVELS.get(level) : void 0) ?? "INFO";
+	return {
+		number: Severity[text],
+		text
+	};
+}
+//#endregion
+//#region ../sdk-core/src/sampling.ts
+/** FNV-1a over the session id, mapped to [0, 1). */
+function sessionRoll(sessionId) {
+	let hash = 2166136261;
+	for (let i = 0; i < sessionId.length; i++) {
+		hash ^= sessionId.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0) / 2 ** 32;
+}
+const MAX_56 = 2 ** 56;
+/** 56 bits as the 14-hex-digit form `ot=th`/`ot=rv` use; `th` drops trailing zeros. */
+const hex56 = (value) => value.toString(16).padStart(14, "0");
+/**
+* The W3C `ot=th:` rejection threshold for a sampling probability: 56 bits,
+* hex, trailing zeros dropped. Ingest reads it back as the span's weight.
+*/
+function rejectionThreshold(probability) {
+	return hex56(Math.round((1 - probability) * MAX_56)).replace(/0+$/, "") || "0";
+}
+/**
+* The session's randomness as the W3C `ot=rv:` value. The decision is `rv >= th`,
+* so a downstream consistent-probability sampler reaches the same answer.
+*/
+function randomnessValue(roll) {
+	return Math.min(MAX_56 - 1, Math.floor((1 - roll) * MAX_56));
+}
+const KEEP$1 = { sampled: true };
+const DROP = { sampled: false };
+/**
+* Whether a new root trace in `sessionId` is exported at `rate`. Without a
+* session (SSR, consent withheld) the roll is per trace.
+*/
+function sampleSession(sessionId, rate) {
+	if (rate >= 1) return KEEP$1;
+	if (rate <= 0) return DROP;
+	const rv = randomnessValue(sessionId ? sessionRoll(sessionId) : Math.random());
+	if (rv < Math.round((1 - rate) * MAX_56)) return DROP;
+	return {
+		sampled: true,
+		traceState: `ot=th:${rejectionThreshold(rate)};rv:${hex56(rv)}`
+	};
+}
+/** A rate outside 0 to 1 is a typo, not a policy: clamp it and say so. */
+function resolveSampleRate(option, raw, fallback = 1) {
+	if (raw === void 0) return fallback;
+	if (typeof raw !== "number" || Number.isNaN(raw)) {
+		console.warn(`[maple] ${option} must be a number between 0 and 1; got ${String(raw)}. Using ${fallback}.`);
+		return fallback;
+	}
+	if (raw < 0 || raw > 1) {
+		const clamped = Math.min(1, Math.max(0, raw));
+		console.warn(`[maple] ${option} must be between 0 and 1; got ${raw}. Using ${clamped}.`);
+		return clamped;
+	}
+	return raw;
+}
+//#endregion
+//#region ../sdk-core/src/options.ts
+function resolveSignalOptions(options) {
+	return {
+		tracingSampleRate: resolveSampleRate("tracing.sampleRate", options.tracing?.sampleRate),
+		captureHeaders: resolveHeaderCapture(options.tracing?.captureHeaders),
+		longFrames: options.tracing?.longFrames ?? false,
+		slowInteractions: options.tracing?.slowInteractions ?? false,
+		errorFilters: options.errors ?? {},
+		webVitals: options.webVitals ?? true,
+		breadcrumbs: options.breadcrumbs ?? true,
+		captureConsole: options.logs?.captureConsole ?? [],
+		reportCsp: options.reporting?.csp ?? true,
+		reportBrowser: options.reporting?.browserReports ?? false,
+		offlineQueue: options.transport?.offline ?? false
+	};
+}
+/** Ingest keeps 1,024 bytes of a session-event attribute; this leaves room for the cut marker. */
+const MAX_BODY_LENGTH = 1e3;
+function resolveReplayOptions(replay) {
+	return {
+		enabled: replay?.enabled ?? true,
+		sampleRate: resolveSampleRate("replay.sampleRate", replay?.sampleRate),
+		onErrorSampleRate: resolveSampleRate("replay.onErrorSampleRate", replay?.onErrorSampleRate, 0),
+		canvasFps: replay?.canvasFps,
+		networkBodies: replay?.networkBodies?.urls.length ? {
+			urls: replay.networkBodies.urls,
+			maxLength: Math.min(MAX_BODY_LENGTH, replay.networkBodies.maxLength ?? MAX_BODY_LENGTH)
+		} : void 0
+	};
+}
+//#endregion
+//#region ../sdk-core/src/page.ts
+/** Versioned: a copy with another layout gets its own slot instead of overwriting this one. */
+const KEY = "__MAPLE_SDK_PAGE_V1__";
+/** This bundled copy: instances of one copy share a lease, another copy does not. */
+const COPY = Symbol("maple-sdk-copy");
+const isPageState = (value) => typeof value === "object" && value !== null && "version" in value && value.version === 1;
+function page() {
+	const owner = globalThis;
+	const existing = owner[KEY];
+	if (isPageState(existing)) return existing;
+	const fresh = {
+		version: 1,
+		reported: /* @__PURE__ */ new WeakSet(),
+		errorListeners: /* @__PURE__ */ new Set(),
+		leases: /* @__PURE__ */ new Map()
+	};
+	owner[KEY] = fresh;
+	return fresh;
+}
+/** Whether this exact error object was already recorded, by either SDK. */
+function wasReported(error) {
+	return typeof error === "object" && error !== null && page().reported.has(error);
+}
+/** Claim `error` as recorded, so a rethrow or a second handler does not record it again. */
+function markReported(error) {
+	if (typeof error === "object" && error !== null) page().reported.add(error);
+}
+/** Told about every recorded error: breadcrumbs export their trail, a buffered replay keeps itself. */
+function onErrorRecorded(listener) {
+	page().errorListeners.add(listener);
+	return () => page().errorListeners.delete(listener);
+}
+function notifyErrorRecorded(link) {
+	for (const listener of page().errorListeners) try {
+		listener(link);
+	} catch {}
+}
+/**
+* Lease one page collector for this bundled copy. `undefined` means another
+* copy already runs it, and starting it again would report everything twice.
+*/
+function claimPageSignal(signal) {
+	const leases = page().leases;
+	const lease = leases.get(signal);
+	if (lease && lease.owner !== COPY) return void 0;
+	const held = lease ?? {
+		owner: COPY,
+		count: 0
+	};
+	held.count++;
+	leases.set(signal, held);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		held.count--;
+		if (held.count <= 0 && leases.get(signal) === held) leases.delete(signal);
+	};
+}
+//#endregion
+//#region src/error-causes.ts
+/**
+* What to hand `span.recordException`: the error itself when nothing is linked,
+* otherwise a copy carrying the longer stack. `code` is kept because OTel
+* prefers it over `name` for `exception.type`.
+*/
+function exceptionOf(error) {
+	const stack = stackWithCauses(error);
+	if (stack === error.stack) return error;
+	const code = "code" in error ? error.code : void 0;
+	const base = {
+		name: error.name,
+		message: error.message,
+		stack
+	};
+	return typeof code === "string" || typeof code === "number" ? {
+		...base,
+		code
+	} : base;
+}
+//#endregion
+//#region src/error-filters.ts
+let filter = makeErrorFilter();
+function configureErrorFilters(next) {
+	filter = makeErrorFilter(next);
+}
+const shouldCapture = (error, hint, frameUrl) => filter(error, hint, frameUrl);
+//#endregion
+//#region src/sampling.ts
+const KEEP = createContextKey("maple.sampling.keep");
+/**
+* A context whose next span is always sampled, for errors. An unsampled parent
+* is dropped first, so the error exports as a root rather than an orphan.
+*/
+function keepContext(ctx) {
+	const parent = trace.getSpanContext(ctx);
+	return (parent && (parent.traceFlags & TraceFlags.SAMPLED) === 0 ? trace.deleteSpan(ctx) : ctx).setValue(KEEP, true);
+}
+var SessionSampler = class {
+	rate;
+	constructor(rate) {
+		this.rate = rate;
+	}
+	shouldSample(ctx) {
+		if (ctx.getValue(KEEP) === true) return { decision: SamplingDecision.RECORD_AND_SAMPLED };
+		const parent = trace.getSpanContext(ctx);
+		if (parent && isSpanContextValid(parent)) return { decision: (parent.traceFlags & TraceFlags.SAMPLED) === 0 ? SamplingDecision.NOT_RECORD : SamplingDecision.RECORD_AND_SAMPLED };
+		const decision = sampleSession(readSessionSink()?.sessionId, this.rate);
+		if (!decision.sampled) return { decision: SamplingDecision.NOT_RECORD };
+		return {
+			decision: SamplingDecision.RECORD_AND_SAMPLED,
+			...decision.traceState ? { traceState: createTraceState(decision.traceState) } : void 0
+		};
+	}
+	toString() {
+		return `MapleSessionSampler{${this.rate}}`;
+	}
+};
+//#endregion
+//#region src/http-headers.ts
+/** `getAllResponseHeaders()` text as a lower-cased map: only the headers CORS exposes are in it. */
+function responseHeaders(raw) {
+	const headers = /* @__PURE__ */ new Map();
+	for (const line of raw.split(/\r?\n/)) {
+		const colon = line.indexOf(":");
+		if (colon > 0) headers.set(line.slice(0, colon).trim().toLowerCase(), line.slice(colon + 1).trim());
+	}
+	return headers;
+}
+/** Stamp the listed headers that `read` finds. Cross-origin responses expose only CORS-safelisted headers unless the server lists more in `Access-Control-Expose-Headers`. */
+function setHeaderAttributes(span, direction, names, read) {
+	for (const name of names) {
+		const value = read(name);
+		if (value) span.setAttribute(`http.${direction}.header.${name}`, [value]);
+	}
+}
+//#endregion
+//#region src/http-status.ts
+const HTTP_STATUS = /^\d{3}$/;
+/** An Error set only because of the response status: `error.type` is the status code itself. */
+function isStatusOnlyError(span) {
+	return span.kind === SpanKind.CLIENT && span.status.code === SpanStatusCode.ERROR && HTTP_STATUS.test(String(span.attributes["error.type"] ?? "")) && !span.events.some((event) => event.name === "exception");
+}
+function withStatus(span, status, attributes) {
+	return {
+		name: span.name,
+		kind: span.kind,
+		spanContext: () => span.spanContext(),
+		parentSpanContext: span.parentSpanContext,
+		startTime: span.startTime,
+		endTime: span.endTime,
+		status,
+		attributes,
+		links: span.links,
+		events: span.events,
+		duration: span.duration,
+		ended: span.ended,
+		resource: span.resource,
+		instrumentationScope: span.instrumentationScope,
+		droppedAttributesCount: span.droppedAttributesCount,
+		droppedEventsCount: span.droppedEventsCount,
+		droppedLinksCount: span.droppedLinksCount
+	};
+}
+var HttpStatusExporter = class {
+	inner;
+	captureStatus;
+	constructor(inner, captureStatus = []) {
+		this.inner = inner;
+		this.captureStatus = captureStatus;
+	}
+	apply(span) {
+		const read = (key) => span.attributes[key];
+		const status = responseStatus(read);
+		if (span.kind === SpanKind.CLIENT && status !== void 0 && inStatusRanges(status, this.captureStatus)) {
+			if (span.events.some((event) => event.name === "exception")) return span;
+			return withStatus(span, { code: SpanStatusCode.ERROR }, {
+				...span.attributes,
+				...httpStatusError(read, status)
+			});
+		}
+		const errorType = span.attributes["error.type"];
+		if (span.kind === SpanKind.CLIENT && span.status.code === SpanStatusCode.ERROR && typeof errorType === "string" && !HTTP_STATUS.test(errorType) && span.attributes["error.message"] === void 0 && !span.events.some((event) => event.name === "exception")) return withStatus(span, span.status, {
+			...span.attributes,
+			"error.message": httpStatusError(read, errorType)["error.message"]
+		});
+		if (!isStatusOnlyError(span)) return span;
+		const { "error.type": _errorType, ...attributes } = span.attributes;
+		return withStatus(span, { code: SpanStatusCode.UNSET }, attributes);
+	}
+	export(spans, callback) {
+		this.inner.export(spans.map((span) => this.apply(span)), callback);
+	}
+	forceFlush() {
+		return this.inner.forceFlush?.() ?? Promise.resolve();
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+//#endregion
+//#region src/offline.ts
+/** Failed batches held until the deferred chunk lands. */
+const MAX_HELD = 20;
+let stash;
+let held = [];
+function attachSpanStash(next) {
+	stash = next;
+	if (!next) return;
+	const pending = held;
+	held = [];
+	for (const spans of pending) next(spans);
+}
+var OfflineSpanExporter = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+	export(spans, callback) {
+		this.inner.export(spans, (result) => {
+			if (result.code !== 0) {
+				if (stash) stash(spans);
+				else {
+					held.push(spans);
+					if (held.length > MAX_HELD) held.shift();
+				}
+			}
+			callback(result);
+		});
+	}
+	forceFlush() {
+		return this.inner.forceFlush?.() ?? Promise.resolve();
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+//#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, and redacts URL
+* attributes before anything can export them. Lightweight: runs alongside the
+* BatchSpanProcessor, does no export of its own.
+*/
+var TraceIdCollector = class {
+	getUserId;
+	constructor(getUserId = () => void 0) {
+		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;
+		if (sessionId !== void 0) span.setAttribute("session.id", sessionId);
+		const userId = this.getUserId();
+		if (userId !== void 0) span.setAttribute("user.id", userId);
+	}
+	onEnd(_span) {}
+	forceFlush() {
+		return Promise.resolve();
+	}
+	shutdown() {
+		return Promise.resolve();
+	}
+};
+/**
+* Drops buffered spans captured while consent was absent. Checking start time,
+* rather than only permission at flush time, also prevents a late grant from
+* releasing spans that began before that grant.
+*/
+var ConsentSpanExporter = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+	export(spans, callback) {
+		const since = consentAllowedSince();
+		if (!hasConsent() || !Number.isFinite(since)) {
+			callback({ code: 0 });
+			return;
+		}
+		const eligible = spans.filter((span) => span.startTime[0] * 1e3 + span.startTime[1] / 1e6 >= since);
+		if (eligible.length === 0) {
+			callback({ code: 0 });
+			return;
+		}
+		this.inner.export(eligible, callback);
+	}
+	forceFlush() {
+		return this.inner.forceFlush?.() ?? Promise.resolve();
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+/**
+* 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. Everything Maple spans
+* goes 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 while tracing is live, with no global fallback. */
+function liveMapleTracer(name, version) {
+	return mapleProvider?.getTracer(name, version);
+}
+/** Resource attributes shared by every signal this SDK exports. */
+function resourceAttributes(config) {
+	const attributes = {
+		[ATTR_SERVICE_NAME]: config.serviceName,
+		"maple.sdk.type": "browser"
+	};
+	if (config.serviceNamespace) attributes["service.namespace"] = config.serviceNamespace;
+	if (config.serviceVersion) {
+		attributes[ATTR_SERVICE_VERSION] = 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;
+		attributes["deployment.environment.name"] = config.environment;
+	}
+	return attributes;
+}
+/**
+* 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.
+* the Effect client SDK) already instruments requests — that tracer feeds the
+* session via the published sink instead, and this avoids redundant duplicate
+* network spans. Returns a shutdown function.
+*
+* `session.id` is deliberately **not** a resource attribute: the resource is
+* fixed for the provider's lifetime, but sessions rotate under it (idle
+* rotation, consent revoke→re-grant), so a resource-level id would attribute
+* every post-rotation span to the ended session. `TraceIdCollector` stamps the
+* live id per span instead.
+*/
+function setupTracing(config) {
+	const otlp = new OTLPTraceExporter({
+		url: `${config.endpoint}/v1/traces`,
+		headers: ingestHeaders({
+			ingestKey: config.ingestKey,
+			sdk: sdkHint(SDK_NAME, SDK_VERSION)
+		})
+	});
+	const exporter = new ConsentSpanExporter(new HttpStatusExporter(config.offlineQueue ? new OfflineSpanExporter(otlp) : otlp, config.errorFilters.captureHttpStatus));
+	const provider = new WebTracerProvider({
+		resource: resourceFromAttributes(resourceAttributes(config)),
+		sampler: new SessionSampler(config.tracingSampleRate),
+		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(() => {});
+	};
+	const onVisibilityChange = () => {
+		if (document.visibilityState === "hidden") onExit();
+	};
+	const settledRequests = /* @__PURE__ */ new Map();
+	const onPageHide = () => {
+		for (const [span, endTime] of settledRequests) if (span.isRecording()) span.end(endTime);
+		settledRequests.clear();
+		onExit();
+	};
+	const noteSettled = (span) => {
+		for (const settled of settledRequests.keys()) if (!settled.isRecording()) settledRequests.delete(settled);
+		settledRequests.set(span, Date.now());
+	};
+	const canListen = typeof document !== "undefined" && typeof document.addEventListener === "function";
+	if (canListen) {
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		window.addEventListener("pagehide", onPageHide);
+	}
+	const requestOptions = {
+		ignoreUrls: [new RegExp(`${escapeRegExp(config.endpoint)}/v1/`)],
+		propagateTraceHeaderCorsUrls: [...config.propagateTraceHeaderCorsUrls]
+	};
+	const headers = config.captureHeaders;
+	const instrumentations = [...config.tracingInstrumentFetch ? [new FetchInstrumentation({
+		...requestOptions,
+		applyCustomAttributesOnSpan: (span, request, result) => {
+			noteSettled(span);
+			const sent = request instanceof Request ? request.headers : new Headers(request.headers);
+			setHeaderAttributes(span, "request", headers.request, (name) => sent.get(name));
+			if (result instanceof Response) setHeaderAttributes(span, "response", headers.response, (name) => result.headers.get(name));
+			else if (result instanceof Error && result.name !== "AbortError" && !request.signal?.aborted) {
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: result.message
+				});
+				span.setAttribute("error.type", result.name);
+			}
+		}
+	})] : [], ...config.tracingInstrumentXhr ? [new XMLHttpRequestInstrumentation({
+		...requestOptions,
+		applyCustomAttributesOnSpan: (span, xhr) => {
+			noteSettled(span);
+			if (headers.response.length === 0) return;
+			const exposed = responseHeaders(xhr.getAllResponseHeaders());
+			setHeaderAttributes(span, "response", headers.response, (name) => exposed.get(name));
+		}
+	})] : []];
+	const unregisterInstrumentations = instrumentations.length > 0 ? registerInstrumentations({
+		tracerProvider: provider,
+		instrumentations
+	}) : void 0;
+	return async () => {
+		if (canListen) {
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			window.removeEventListener("pagehide", onPageHide);
+		}
+		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
+/**
+* Errors already reported, by identity, page-wide: a framework boundary that
+* reports an error and then rethrows it, or both Maple SDKs on one page, would
+* otherwise produce two issues for one crash.
+*/
+const alreadyReported = wasReported;
+/**
+* Mark `span` as failed by `error`. The exception event goes on the first span
+* that records this error object; a later one (an outer `traced`, say) only
+* takes the Error status, so one error stays one issue. 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. Without consent the span is never exported, so the error is not claimed either.
+*/
+function recordFailure(span, error) {
+	const normalized = asError(error);
+	if (!alreadyReported(error)) {
+		const exported = span.isRecording() && hasConsent();
+		if (exported) markReported(error);
+		span.recordException(exceptionOf(normalized));
+		if (exported) notifyErrorRecorded(span.spanContext());
+	}
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message: normalized.message
+	});
+}
+/**
+* Record `error` on a one-off span, exported whatever the session's trace
+* sampling, unless the app's error filters drop it.
+*/
+function recordException(error, options, source, filename, filtered = false) {
+	if (!hasConsent()) return;
+	if (!filtered && !shouldCapture(asError(error), {
+		source,
+		originalError: error
+	}, filename)) return;
+	const tracer = liveMapleTracer(SDK_NAME, SDK_VERSION);
+	if (!tracer) return;
+	const span = tracer.startSpan(options.name ?? "exception", {
+		kind: SpanKind.INTERNAL,
+		attributes: {
+			...typeof location !== "undefined" ? { "url.full": scrubUrl(location.href) } : void 0,
+			...options.attributes
+		}
+	}, keepContext(context.active()));
+	recordFailure(span, error);
+	span.end();
+}
+/**
+* Record an error that no span was watching. Safe before `init()`, where it
+* does nothing. Reporting the same error object twice records it once.
+*/
+function captureException(error, options = {}) {
+	if (alreadyReported(error)) return;
+	recordException(error, options, "captureException");
+}
+/** Whether the app's error filters keep `error`, for failures recorded on an existing span. */
+function passesErrorFilters(error) {
+	return shouldCapture(asError(error), {
+		source: "captureException",
+		originalError: error
+	});
+}
+/** `captureException` for an error `passesErrorFilters` already let through: `beforeCapture` runs once. */
+function captureFilteredException(error, options = {}) {
+	if (alreadyReported(error)) return;
+	recordException(error, options, "captureException", void 0, true);
+}
+/**
+* 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,
+				...event.colno ? { "code.column.number": event.colno } : void 0
+			}
+		}, "window.onerror", event.error instanceof Error ? void 0 : event.filename || void 0);
+	};
+	const onUnhandledRejection = (event) => {
+		if (alreadyReported(event.reason)) return;
+		recordException(event.reason, {
+			name: "browser.unhandled_rejection",
+			attributes: { "maple.exception.source": "unhandledrejection" }
+		}, "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);
+}
+function resolveConfig(config) {
+	const endpoint = resolveIngestEndpoint({
+		endpoints: [config.endpoint],
+		regions: [config.region]
+	});
+	warnIfKeylessMapleIngest({
+		logPrefix: "[maple]",
+		endpoint,
+		hasIngestKey: Boolean(config.ingestKey),
+		hint: "Pass `ingestKey`, or point `endpoint` at a proxy that adds it."
+	});
+	const replay = resolveReplayOptions(config.replay);
+	return {
+		...resolveSignalOptions(config),
+		ingestKey: config.ingestKey,
+		serviceName: config.serviceName,
+		endpoint,
+		serviceNamespace: config.serviceNamespace,
+		serviceVersion: config.serviceVersion,
+		environment: config.environment,
+		identity: resolveIdentity(config),
+		tracingEnabled: config.tracing?.enabled ?? true,
+		tracingInstrumentFetch: config.tracing?.instrumentFetch ?? true,
+		tracingInstrumentXhr: config.tracing?.instrumentXhr ?? true,
+		tracingCaptureErrors: config.tracing?.captureErrors ?? true,
+		propagateTraceHeaderCorsUrls: config.tracing?.propagateTraceHeaderCorsUrls ?? [],
+		replayEnabled: replay.enabled,
+		replaySampleRate: replay.sampleRate,
+		replayOnErrorSampleRate: replay.onErrorSampleRate,
+		canvasFps: replay.canvasFps,
+		networkBodies: replay.networkBodies,
+		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/logs.ts
+/** Held until the deferred chunk lands; beyond this, a page logging in a loop drops the oldest. */
+const MAX_QUEUED = 200;
+let queue = [];
+let sink;
+let getUserId = () => void 0;
+function emitLog(record) {
+	if (!hasConsent()) return;
+	const sessionId = readSessionSink()?.sessionId;
+	const userId = getUserId();
+	const attributes = {
+		...record.attributes,
+		...sessionId !== void 0 ? { "session.id": sessionId } : void 0,
+		...userId !== void 0 ? { "user.id": userId } : void 0
+	};
+	const queued = {
+		...record,
+		attributes,
+		timestamp: record.timestamp ?? Date.now(),
+		link: record.link ?? trace.getSpanContext(context.active())
+	};
+	if (sink) {
+		sink(queued);
+		return;
+	}
+	queue.push(queued);
+	if (queue.length > MAX_QUEUED) queue.shift();
+}
+/** Called by `init()`: where `user.id` comes from. */
+function setLogIdentity(read) {
+	getUserId = read;
+}
+/** Called by the deferred chunk: drains the queue into `next`, then sends straight to it. */
+function attachLogSink(next) {
+	sink = next;
+	const pending = queue;
+	queue = [];
+	for (const record of pending) next(record);
+}
+function detachLogSink() {
+	sink = void 0;
+	getUserId = () => void 0;
+}
+//#endregion
+//#region src/navigation.ts
+/**
+* The navigation in flight. Only ever set in a browser: a server shares module
+* state across requests.
+*/
+let navigation;
+/**
+* Whether the next navigation is a `pageload`: the first since the document
+* loaded, or since `shutdown()`. Consumed even when nothing is spanned (tracing
+* not live yet, consent pending): a later click is not the page load. Router
+* adapters must therefore be attached after `init()`.
+*/
+let firstLoad = true;
+/**
+* Whether the document's own page load is still to come. Unlike `firstLoad`,
+* never reset: a `pageload` after `shutdown()` and a new `init()` is long past
+* the server render, and must not join its trace.
+*/
+let documentLoad = true;
+/** Set by the deferred chunk, which spans the document's own load under `pageload`. */
+let pageloadListener;
+/** A document page load that began before the deferred chunk landed. */
+let pendingPageload;
+function onDocumentPageload(listener) {
+	pageloadListener = listener;
+	if (listener && pendingPageload) listener(pendingPageload.tracer, pendingPageload.span);
+	pendingPageload = void 0;
+}
+/** Spans `traced` opened, which a nested `traced` may parent to instead of the navigation. */
+const tracedSpans = /* @__PURE__ */ new WeakSet();
+/**
+* Maple's tracer, while tracing is live and consent is given. A consent revoke
+* leaves the provider up but drops what it spans: an error recorded then would
+* be claimed without ever being exported.
+*/
+const tracer = () => hasConsent() ? liveMapleTracer(SDK_NAME, SDK_VERSION) : void 0;
+/** The open navigation span, if it had already started at `epochMs`: a child must not begin before its parent. */
+function navigationSpanAt(epochMs) {
+	return navigation && navigation.startedAt <= epochMs ? navigation.span : void 0;
+}
+/** End the open navigation as interrupted: something other than its route finishing ended it. */
+function interruptNavigation() {
+	navigation?.span.setAttribute("app.navigation.interrupted", true);
+	navigation?.span.end();
+	navigation = void 0;
+}
+function startNavigation(path) {
+	if (typeof window === "undefined") return;
+	interruptNavigation();
+	const kind = firstLoad ? "pageload" : "navigate";
+	const joinServer = documentLoad;
+	firstLoad = false;
+	documentLoad = false;
+	const live = tracer();
+	if (!live) return;
+	const parent = (joinServer ? serverContext() : void 0) ?? context.active();
+	const startTime = joinServer ? Math.max(performance.timeOrigin, consentAllowedSince()) : void 0;
+	const span = live.startSpan(kind, {
+		startTime,
+		attributes: { "url.path": scrubUrl(path) }
+	}, parent);
+	navigation = {
+		kind,
+		span,
+		startedAt: startTime ?? Date.now()
+	};
+	if (joinServer) {
+		if (pageloadListener) pageloadListener(live, span);
+		else pendingPageload = {
+			tracer: live,
+			span
+		};
+	}
+	window.addEventListener("pagehide", interruptNavigation, { capture: true });
+}
+function endNavigation(route) {
+	if (!navigation) return;
+	if (route) navigation.span.updateName(`${navigation.kind} ${scrubUrl(route)}`);
+	navigation.span.end();
+	navigation = void 0;
+}
+async function traced(name, fn, options = {}) {
+	const live = tracer();
+	if (!live) return fn();
+	return live.startActiveSpan(name, {}, parentContext(), async (span) => {
+		tracedSpans.add(span);
+		try {
+			return await fn();
+		} catch (error) {
+			if (isFailure(options, error) && passesErrorFilters(error)) {
+				if (span.isRecording()) recordFailure(span, error);
+				else captureFilteredException(error, { name });
+			}
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+/**
+* The open navigation, unless a `traced` span is active: a `traced` inside
+* another `traced` nests under that one.
+*/
+function parentContext() {
+	const active = context.active();
+	const activeSpan = trace.getSpan(active);
+	if (!navigation || activeSpan && tracedSpans.has(activeSpan)) return active;
+	return trace.setSpan(active, navigation.span);
+}
+/** `isFailure` is the app's code: if it throws, the original error still propagates. */
+function isFailure(options, error) {
+	try {
+		return options.isFailure?.(error) ?? true;
+	} catch {
+		return true;
+	}
+}
+/**
+* End the open navigation so it exports with the provider's last flush, and
+* start the next `init()` at a page load. Called by `shutdown()`.
+*/
+function resetNavigation() {
+	interruptNavigation();
+	firstLoad = true;
+	pendingPageload = void 0;
+}
+/**
+* The trace the server rendered this page under: a `Server-Timing:
+* traceparent;desc="…"` entry on the document response, else a `<meta
+* name="traceparent">` tag.
+*/
+function serverContext() {
+	const [page] = performance.getEntriesByType("navigation");
+	const spanContext = parseTraceparent(page?.serverTiming?.find((entry) => entry.name === "traceparent")?.description) ?? parseTraceparent(document.querySelector("meta[name=\"traceparent\"]")?.content);
+	return spanContext && trace.setSpanContext(context.active(), spanContext);
+}
+/**
+* W3C `version-traceid-parentid-flags`. Parsed here rather than through the
+* global propagator, which the host app may own, or may not have registered.
+*/
+const TRACEPARENT = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-.*)?$/;
+function parseTraceparent(value) {
+	const match = value?.trim().match(TRACEPARENT);
+	if (!match || match[1] === "ff" || match[1] === "00" && match[5] !== void 0) return void 0;
+	const spanContext = {
+		traceId: match[2],
+		spanId: match[3],
+		traceFlags: Number.parseInt(match[4], 16),
+		isRemote: true
+	};
+	return isSpanContextValid(spanContext) ? spanContext : void 0;
+}
+//#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.
+*/
+function init(rawConfig) {
+	if (active) return active;
+	if (typeof window === "undefined") return {
+		sessionId: "",
+		shutdown: () => Promise.resolve()
+	};
+	const config = resolveConfig(rawConfig);
+	if (pendingIdentity) config.identity = normalizeIdentity(pendingIdentity.input);
+	pendingIdentity = void 0;
+	activeConfig = config;
+	configurePrivacy(config);
+	configureErrorFilters(config.errorFilters);
+	if (!hasConsent()) clearPendingEvents();
+	setActiveTraceIdProvider(() => trace.getActiveSpan()?.spanContext().traceId);
+	const replayEligible = config.replayEnabled && !isLikelyBot(navigator.userAgent);
+	let runtime;
+	let stopped = false;
+	let rotateOnNextStart = false;
+	let shutdownTracing;
+	let stopErrorCapture;
+	let deferredPending;
+	let stopDeferred;
+	let generation = 0;
+	const startRuntime = () => {
+		if (stopped || runtime || !hasConsent()) return;
+		setVisitorTracking(config.persistVisitorId && mayPersistIdentifier());
+		const session = (rotateOnNextStart ? rotateSession() : void 0) ?? getSession();
+		rotateOnNextStart = false;
+		const replayMode = replayEligible ? claimReplayMode(config.replaySampleRate, config.replayOnErrorSampleRate) : "off";
+		publishSessionSink(session.id);
+		const sink = startEventSink({
+			endpoint: config.endpoint,
+			ingestKey: config.ingestKey,
+			sdk: SDK_HINT,
+			maskAllInputs: config.maskAllInputs,
+			maskAllText: config.maskAllText,
+			getIdentity: () => activeConfig?.identity
+		}, session.id);
+		if (config.tracingEnabled && !shutdownTracing) shutdownTracing = setupTracing(config);
+		if (config.tracingEnabled && config.tracingCaptureErrors && !stopErrorCapture) stopErrorCapture = setupErrorCapture();
+		if (!deferredPending) {
+			setLogIdentity(() => activeConfig?.identity?.id);
+			deferredPending = import("./deferred-CdtlxG0Q.mjs").then(({ startDeferred }) => {
+				stopDeferred = startDeferred(config);
+			}).catch(() => {});
+		}
+		const shared = {
+			endpoint: config.endpoint,
+			ingestKey: config.ingestKey,
+			sdk: SDK_HINT,
+			serviceName: config.serviceName,
+			environment: config.environment,
+			serviceVersion: config.serviceVersion,
+			getIdentity: () => activeConfig?.identity,
+			captureUserEmail: config.captureUserEmail
+		};
+		const startMetadata = () => startMetadataSession({
+			...shared,
+			getTraceIds: getObservedTraceIds,
+			onSessionChange: publishSessionSink
+		});
+		if (replayMode === "off") {
+			runtime = {
+				initialSessionId: session.id,
+				sink,
+				metadata: startMetadata()
+			};
+			return;
+		}
+		const next = {
+			initialSessionId: session.id,
+			sink
+		};
+		runtime = next;
+		const ownGeneration = ++generation;
+		const stale = () => stopped || !hasConsent() || generation !== ownGeneration || runtime !== next;
+		next.replayPending = import("./replay-session-DdVYdHc_.mjs").then(({ startReplaySession }) => {
+			if (stale()) return;
+			next.replay = startReplaySession({
+				...shared,
+				maskAllInputs: config.maskAllInputs,
+				maskAllText: config.maskAllText,
+				mode: replayMode,
+				canvasFps: config.canvasFps,
+				networkBodies: config.networkBodies
+			});
+		}).catch(() => {
+			if (stale()) return;
+			next.metadata = startMetadata();
+		});
+	};
+	const stopRuntime = async (flush) => {
+		generation++;
+		const previous = runtime;
+		runtime = void 0;
+		if (!previous) return;
+		const replayShutdown = previous.replay?.shutdown({ flush });
+		const metadataShutdown = previous.metadata?.shutdown({ flush });
+		const currentSessionId = previous.replay?.sessionId ?? previous.metadata?.sessionId;
+		const liveSink = getActiveSink();
+		const sink = liveSink && currentSessionId && liveSink.sessionId === currentSessionId ? liveSink : previous.sink;
+		if (flush) await sink.flush(true);
+		sink.stop();
+		if (sink !== previous.sink) previous.sink.stop();
+		clearSessionSink(currentSessionId ?? previous.initialSessionId);
+		await Promise.all([
+			replayShutdown,
+			metadataShutdown,
+			previous.replayPending
+		]);
+	};
+	const stopReplayTrigger = onErrorRecorded(() => {
+		runtime?.replay?.trigger();
+	});
+	startRuntime();
+	const stopConsentListener = config.requireConsent ? onConsentChange((allowed) => {
+		if (allowed) {
+			startRuntime();
+			return;
+		}
+		rotateOnNextStart = runtime !== void 0;
+		clearPendingEvents();
+		setVisitorTracking(false);
+		stopRuntime(false);
+	}) : () => {};
+	const handle = {
+		get sessionId() {
+			return runtime?.replay?.sessionId ?? runtime?.metadata?.sessionId ?? runtime?.initialSessionId ?? "";
+		},
+		shutdown: async () => {
+			if (stopped) return;
+			stopped = true;
+			stopConsentListener();
+			stopReplayTrigger();
+			await stopRuntime(true);
+			stopErrorCapture?.();
+			stopErrorCapture = void 0;
+			configureErrorFilters(void 0);
+			resetNavigation();
+			await deferredPending;
+			await shutdownTracing?.();
+			shutdownTracing = void 0;
+			await stopDeferred?.();
+			stopDeferred = void 0;
+			setActiveTraceIdProvider(() => void 0);
+			active = void 0;
+			activeConfig = void 0;
+		}
+	};
+	active = handle;
+	return handle;
+}
+/**
+* Attach, replace, or clear the end-user identity on the active session.
+* Idempotent and safe to call on every render. Future browser-created spans
+* read the id when they start, and future session metadata rows read the whole
+* identity when they post.
+*
+* Accepts a bare user id or the full object:
+*
+* ```ts
+* MapleBrowser.identify("user_123")
+* MapleBrowser.identify({ id: "user_123", email: "a@b.com", groupId: "org_1", groupName: "Acme" })
+* ```
+*
+* 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") return;
+	if (!activeConfig) {
+		pendingIdentity = { input };
+		return;
+	}
+	activeConfig.identity = normalizeIdentity(input);
+}
+//#endregion
+//#region src/logger.ts
+const method = (level) => (message, attributes) => {
+	try {
+		emitLog({
+			severityNumber: Severity[level],
+			severityText: level,
+			body: String(message),
+			attributes
+		});
+	} catch {}
+};
+//#endregion
+//#region src/index.ts
+/**
+* Maple browser SDK. One call wires up OpenTelemetry tracing and rrweb session
+* replay, both tagged with a shared session id.
+*
+* @example
+* ```ts
+* import { MapleBrowser } from "@maple-dev/browser"
+*
+* 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 })
+* MapleBrowser.track("checkout_completed", { plan: "pro", seats: 5 })
+* ```
+*/
+const MapleBrowser = {
+	init,
+	identify,
+	track,
+	captureException,
+	setConsent,
+	startNavigation,
+	endNavigation,
+	traced,
+	logger: {
+		debug: method("DEBUG"),
+		info: method("INFO"),
+		warn: method("WARN"),
+		error: method("ERROR")
+	}
+};
+//#endregion
+export { consentRevokedAt as _, detachLogSink as a, resourceAttributes as c, attachSpanStash as d, claimPageSignal as f, consentAllowedSince as g, severityOf as h, attachLogSink as i, SDK_NAME as l, Severity as m, navigationSpanAt as n, emitLog as o, onErrorRecorded as p, onDocumentPageload as r, liveMapleTracer as s, MapleBrowser as t, SDK_VERSION as u, hasConsent as v, onConsentChange as y };