@maple-dev/browser 0.12.0 → 0.14.0

package/dist/{src-DfU4Cnb1.mjs → src-B3Giah8c.mjs}

@@ -1,13 +1,118 @@
-import { B as mayPersistIdentifier, C as otlpKeepaliveRoom, E as postToIngest, G as scrubUrl, H as setConsent, I as configurePrivacy, L as consentAllowedSince, O as sdkHint, P as setActiveTraceIdProvider, S as ingestHeaders, U as setVisitorTracking, V as onConsentChange, _ as rotateSession, a as recordTraceId, b as OTLP_UNLOAD_TAIL_BYTES, 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, y as isLikelyBot, z as hasConsent } from "./sink-DbEuphC-.mjs";
-import { ProxyTracerProvider, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, createTraceState, isSpanContextValid, propagation, trace } from "@opentelemetry/api";
-import { BatchSpanProcessor, SamplingDecision } from "@opentelemetry/sdk-trace-base";
+import { A as postToIngest, C as OTLP_UNLOAD_TAIL_BYTES, D as otlpKeepaliveRoom, E as ingestHeaders, G as mayPersistIdentifier, H as consentAllowedSince, J as setVisitorTracking, K as onConsentChange, L as truncateText, M as sdkHint, S as isLikelyBot, V as configurePrivacy, W as hasConsent, X as scrubUrl, a as recordTraceId, c as getActiveSink, d as startEventSink, f as claimReplayMode, i as readSessionSink, n as getObservedTraceIds, o as startSessionLifecycle, p as getSession, q as setConsent, r as publishSessionSink, s as clearPendingEvents, t as clearSessionSink, u as queuePending, x as postSessionMetaRow, y as rotateSession, z as setActiveTraceIdProvider } from "./sink-Ji0J42ul.mjs";
+import { INVALID_SPAN_CONTEXT, ProxyTracerProvider, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, createTraceState, isSpanContextValid, propagation, trace } from "@opentelemetry/api";
+import { BatchSpanProcessor, SamplingDecision, StackContextManager, TracerProvider } from "@opentelemetry/sdk-trace";
+import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
 import { XMLHttpRequestInstrumentation } from "@opentelemetry/instrumentation-xml-http-request";
 import { JsonTraceSerializer } from "@opentelemetry/otlp-transformer";
 import { resourceFromAttributes } from "@opentelemetry/resources";
-import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, ATTR_TELEMETRY_SDK_LANGUAGE, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_VERSION, TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS } from "@opentelemetry/semantic-conventions";
+//#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;
+/** A surrogate pair, or a lone half of one. No lookbehind: older Safari cannot parse it. */
+const SURROGATES = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g;
+/**
+* `text` with every lone surrogate replaced by U+FFFD. Strict JSON parsers
+* (ingest's among them) reject the escape for one, and the whole batch with it.
+*/
+function wellFormed(text) {
+	return text.replace(SURROGATES, (match) => match.length === 2 ? match : "�");
+}
+/** Cut to `max` UTF-16 units, never leaving half a surrogate pair behind. */
+function capText(text, max) {
+	return wellFormed(truncateText(text, max));
+}
+/**
+* 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 capText(value, 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();
+		const json = JSON.stringify(value);
+		return json === void 0 ? void 0 : capText(json, MAX_PROP_VALUE_LENGTH);
+	} catch {
+		return;
+	}
+}
+/**
+* Whether `value` is a property bag. Arrays and primitives are not: a string
+* would otherwise become `{0: "h", 1: "i"}`. `Array.isArray` throws on a
+* revoked Proxy, hence the guard.
+*/
+function isPropertyBag(value) {
+	try {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	} catch {
+		return false;
+	}
+}
+/** Own enumerable string keys of `bag`, or none when a Proxy's `ownKeys` trap throws. */
+function bagKeys(bag) {
+	try {
+		return Object.keys(bag);
+	} catch {
+		return [];
+	}
+}
+/**
+* `parse(bag[key])`, or `undefined` when the getter (or Proxy `get` trap) throws.
+* BOUNDARY: `parse` receives a host-app value straight off an untyped bag.
+*/
+function readEntry(bag, key, parse) {
+	try {
+		return parse(bag[key]);
+	} catch {
+		return;
+	}
+}
+/**
+* Store `value` as an own data property. Plain assignment of `"__proto__"`
+* would try to swap the prototype and silently drop the key instead.
+*/
+function defineEntry(out, key, value) {
+	Object.defineProperty(out, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+/** Coerce and cap a `track()` property bag to the `Map(String, String)` the warehouse stores. */
+function coerceTrackProps(props) {
+	const out = {};
+	if (!isPropertyBag(props)) return out;
+	let count = 0;
+	let bytes = 0;
+	for (const rawKey of bagKeys(props)) {
+		if (count >= MAX_PROPS) break;
+		const value = readEntry(props, rawKey, coerce);
+		if (value === void 0) continue;
+		const key = capText(rawKey, MAX_PROP_KEY_LENGTH);
+		if (!key || Object.prototype.hasOwnProperty.call(out, key)) continue;
+		bytes += key.length + value.length;
+		if (bytes > MAX_TOTAL_PROP_BYTES) break;
+		defineEntry(out, key, value);
+		count++;
+	}
+	return out;
+}
+//#endregion
 //#region ../browser-session/src/identity/identity.ts
 /**
 * Trait caps. The warehouse column is `Map(String, String)` — plain keys
@@ -19,35 +124,48 @@ import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic
 const MAX_TRAITS = 24;
 const MAX_TRAIT_KEY_LENGTH = 64;
 const MAX_TRAIT_VALUE_LENGTH = 256;
+/** Ids, emails and names; matches the gateway's per-id byte cap in UTF-16 units. */
+const MAX_FIELD_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);
+	switch (typeof value) {
+		case "string": return capText(value, MAX_TRAIT_VALUE_LENGTH);
+		case "number":
+		case "boolean":
+		case "bigint": return String(value);
+		default: return;
+	}
 }
 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 (!isPropertyBag(traits)) return out;
+	let count = 0;
+	for (const rawKey of bagKeys(traits)) {
+		if (count >= MAX_TRAITS) break;
+		const value = readEntry(traits, rawKey, coerceTraitValue);
 		if (value === void 0) continue;
-		const key = rawKey.slice(0, MAX_TRAIT_KEY_LENGTH);
-		if (!key) continue;
+		const key = capText(rawKey, MAX_TRAIT_KEY_LENGTH);
+		if (!key || Object.prototype.hasOwnProperty.call(out, 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;
+		defineEntry(out, key, value);
+		count++;
 	}
 	return out;
 }
-function trimmed(value) {
-	const text = value?.trim();
-	return text ? text : void 0;
+/**
+* A trimmed, capped string field. Numeric ids (`{ id: 42 }`) are common enough in
+* untyped callers to keep; anything else that is not a string is ignored.
+*/
+function field(value) {
+	const trimmed = (typeof value === "string" ? value : typeof value === "number" && Number.isFinite(value) || typeof value === "bigint" ? String(value) : void 0)?.trim();
+	return trimmed ? capText(trimmed, MAX_FIELD_LENGTH) : void 0;
 }
 /**
 * Normalize whatever a host app passed into the shape the metadata row wants.
@@ -58,21 +176,20 @@ function trimmed(value) {
 * already did.
 */
 function normalizeIdentity(input) {
-	if (input === null || input === void 0) return void 0;
-	if (typeof input === "string") {
-		const id = trimmed(input);
+	if (!isPropertyBag(input)) {
+		const id = field(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)
+		id: readEntry(input, "id", field),
+		email: readEntry(input, "email", field),
+		username: readEntry(input, "username", field),
+		groupId: readEntry(input, "groupId", field),
+		groupName: readEntry(input, "groupName", field),
+		traits: readEntry(input, "traits", normalizeTraits) ?? {}
 	};
 	return resolved.id || resolved.email || resolved.username || resolved.groupId || resolved.groupName || Object.keys(resolved.traits).length > 0 ? resolved : void 0;
 }
@@ -109,54 +226,9 @@ function clearPendingChunk() {
 	}
 }
 //#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;
+let warnedAboutReservedName = false;
 /**
 * Record a custom product event against the current session.
 *
@@ -176,9 +248,17 @@ function track(name, props) {
 		}
 		return;
 	}
+	const trimmedName = name.trim();
+	if (trimmedName.startsWith("$")) {
+		if (!warnedAboutReservedName) {
+			warnedAboutReservedName = true;
+			console.warn(`[maple] track() event names starting with "$" are reserved; "${trimmedName}" was ignored.`);
+		}
+		return;
+	}
 	const ev = {
 		type: "custom",
-		message: name.trim().slice(0, 128),
+		message: capText(trimmedName, 128),
 		attrs: coerceTrackProps(props),
 		timestamp: Date.now(),
 		url: typeof location !== "undefined" ? location.href : void 0
@@ -265,41 +345,133 @@ function warnIfKeylessMapleIngest(options) {
 //#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;
+/** A thrown plain object is summarised by its first few primitive fields, never walked. */
+const MAX_SUMMARY_FIELDS = 8;
+const MAX_SUMMARY_VALUE = 80;
+const MAX_SUMMARY = 300;
 const isRecord = (value) => typeof value === "object" && value !== null;
+/** A property read that a throwing getter or Proxy trap cannot turn into a second error. */
+function read(value, key) {
+	try {
+		return value[key];
+	} catch {
+		return;
+	}
+}
+function isErrorInstance(value) {
+	try {
+		return value instanceof Error;
+	} catch {
+		return false;
+	}
+}
 /** 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");
+function isErrorLike(value) {
+	if (isErrorInstance(value)) return true;
+	if (!isRecord(value)) return false;
+	const stack = read(value, "stack");
+	return typeof read(value, "name") === "string" && typeof read(value, "message") === "string" && (stack === void 0 || typeof stack === "string");
+}
+/** Cut at a code point boundary, so a clipped value never ends in half a surrogate pair. */
+function clip(text, max) {
+	if (text.length <= max) return text;
+	const end = /[\uD800-\uDBFF]/.test(text.charAt(max - 1)) ? max - 1 : max;
+	return `${text.slice(0, end)}…`;
+}
+function tagOf(value) {
+	try {
+		return Object.prototype.toString.call(value);
+	} catch {
+		return "[object Object]";
+	}
+}
+/** `{"code":1,"reason":"busy"}`: what a thrown plain object says about itself, bounded. */
+function summarize(value) {
+	let keys;
+	try {
+		keys = Object.keys(value);
+	} catch {
+		return tagOf(value);
+	}
+	const fields = [];
+	for (const key of keys) {
+		if (fields.length >= MAX_SUMMARY_FIELDS) break;
+		let field;
+		try {
+			field = value[key];
+		} catch {
+			continue;
+		}
+		const rendered = typeof field === "string" ? JSON.stringify(clip(field, MAX_SUMMARY_VALUE)) : typeof field === "number" || typeof field === "boolean" || field === null ? String(field) : typeof field === "bigint" ? `${field}n` : void 0;
+		if (rendered !== void 0) fields.push(`${JSON.stringify(clip(key, MAX_SUMMARY_VALUE))}:${rendered}`);
+	}
+	return fields.length > 0 ? clip(`{${fields.join(",")}}`, MAX_SUMMARY) : tagOf(value);
+}
+/**
+* An `Error` made here for a value thrown elsewhere. Its own stack would point
+* into the SDK, which is not where anything was thrown, and would group every
+* such throw into one issue, so it carries the source's stack or none.
+*/
+function madeError(message, name, stack) {
+	const error = new Error(message);
+	if (name !== void 0 && name !== "") error.name = name;
+	try {
+		Object.defineProperty(error, "stack", {
+			value: stack,
+			writable: true,
+			configurable: true
+		});
+	} catch {}
+	return error;
+}
+function stringOf(value) {
+	try {
+		return String(value);
+	} catch {
+		return "Unknown error";
+	}
+}
 /**
 * 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");
+	if (isErrorInstance(value)) {
+		const name = read(value, "name");
+		const message = read(value, "message");
+		const stack = read(value, "stack");
+		if (typeof name === "string" && typeof message === "string" && (stack === void 0 || typeof stack === "string")) return value;
+		return madeError(typeof message === "string" ? message : "", typeof name === "string" ? name : void 0, typeof stack === "string" ? stack : void 0);
+	}
+	if (typeof value === "string") return madeError(value);
+	if (isRecord(value)) {
+		const message = read(value, "message");
+		if (typeof message === "string") {
+			const name = read(value, "name");
+			const stack = read(value, "stack");
+			return madeError(message, typeof name === "string" ? name : void 0, typeof stack === "string" ? stack : void 0);
+		}
+		return madeError(summarize(value));
 	}
+	return madeError(stringOf(value));
 }
 /** What an error links to: its `cause`, and its `errors` list (duck-typed, so copies qualify). */
 const linksOf = (value) => {
-	if (!isErrorLike(value)) return [];
+	if (!isRecord(value) || !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);
+		const errors = read(value, "errors");
+		if (Array.isArray(errors)) next.push(...errors.slice(0, MAX_LINKED));
 	} catch {}
+	const cause = read(value, "cause");
+	if (cause !== void 0) next.push(cause);
 	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);
-	}
+	if (!isRecord(value)) return stringOf(value);
+	const message = read(value, "message");
+	return typeof message === "string" ? message : summarize(value);
 }
 function linkedErrors(error) {
 	const linked = [];
@@ -313,23 +485,31 @@ function linkedErrors(error) {
 	}
 	return linked;
 }
+function stringField(value, key) {
+	const field = read(value, key);
+	return typeof field === "string" ? field : "";
+}
 /** 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;
+	const stack = stringField(error, "stack");
+	const name = stringField(error, "name");
+	const message = stringField(error, "message");
+	const header = message ? `${name}: ${message}` : name;
 	return stack.startsWith(header) ? stack.slice(header.length).replace(/^\n/, "") : stack;
 }
 function describe(value) {
-	if (!isErrorLike(value)) return `Caused by: ${render(value)}`;
+	if (!isRecord(value) || !isErrorLike(value)) return `Caused by: ${render(value)}`;
 	const frames = framesOf(value);
-	const header = `Caused by: ${value.name}: ${value.message}`;
+	const header = `Caused by: ${stringField(value, "name")}: ${stringField(value, "message")}`;
 	return frames ? `${header}\n${frames}` : header;
 }
 /** The stack trace to record for `error`, with its linked errors appended. */
 function stackWithCauses(error) {
+	const own = read(error, "stack");
+	const stack = typeof own === "string" ? own : void 0;
 	const linked = linkedErrors(error);
-	if (linked.length === 0) return error.stack;
-	return [error.stack ?? `${error.name}: ${error.message}`, ...linked.map(describe)].join("\n");
+	if (linked.length === 0) return stack;
+	return [stack ?? `${stringField(error, "name")}: ${stringField(error, "message")}`, ...linked.map(describe)].join("\n");
 }
 //#endregion
 //#region ../sdk-core/src/error-filters.ts
@@ -475,6 +655,8 @@ function sessionRoll(sessionId) {
 	return (hash >>> 0) / 2 ** 32;
 }
 const MAX_56 = 2 ** 56;
+/** The largest double below 2^56: `2 ** 56 - 1` rounds up to 2^56, which needs a 15th hex digit. */
+const TOP_56 = MAX_56 - 8;
 /** 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");
 /**
@@ -482,14 +664,14 @@ const hex56 = (value) => value.toString(16).padStart(14, "0");
 * 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";
+	return hex56(Math.min(TOP_56, 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));
+	return Math.min(TOP_56, Math.floor((1 - roll) * MAX_56));
 }
 const KEEP$1 = { sampled: true };
 const DROP = { sampled: false };
@@ -725,7 +907,10 @@ var HttpStatusExporter = class {
 		this.captureStatus = captureStatus;
 	}
 	apply(span) {
-		const read = (key) => span.attributes[key];
+		const read = (key) => {
+			const value = span.attributes[key];
+			return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : void 0;
+		};
 		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;
@@ -754,9 +939,13 @@ var HttpStatusExporter = class {
 const MAX_HELD = 20;
 let stash;
 let held = [];
+/** Attach the deferred chunk's stash, or detach it on shutdown, dropping what is held: it belongs to that session. */
 function attachSpanStash(next) {
 	stash = next;
-	if (!next) return;
+	if (!next) {
+		held = [];
+		return;
+	}
 	const pending = held;
 	held = [];
 	for (const spans of pending) next(spans);
@@ -895,13 +1084,14 @@ function newestFirst(items, serializer) {
 * newest items first, in a body small enough for keepalive, then the rest,
 * which keeps keepalive while it fits and leaves `olderReserve` bytes of room
 * for what is flushed after it. Each goes through `inner` on its own, so only
-* the part that failed is queued.
+* the part that failed is queued. `leaving` covers a pipeline whose exit flush
+* exports after `flushUnloading` has returned.
 */
-function newestFirstOnExit(inner, serializer, olderReserve = 0) {
+function newestFirstOnExit(inner, serializer, olderReserve = 0, leaving = () => false) {
 	return {
 		export(items, callback) {
 			const hidden = globalThis.document?.visibilityState === "hidden";
-			const parts = unloading || hidden ? newestFirst(items, serializer) : [items];
+			const parts = unloading || hidden || leaving() ? newestFirst(items, serializer) : [items];
 			let pending = parts.length;
 			let failed;
 			for (const [index, part] of parts.entries()) {
@@ -923,7 +1113,7 @@ function newestFirstOnExit(inner, serializer, olderReserve = 0) {
 }
 //#endregion
 //#region src/version.ts
-const SDK_VERSION = "0.12.0";
+const SDK_VERSION = "0.14.0";
 /** The `x-maple-sdk` value this build sends. */
 const SDK_NAME = "maple-browser";
 //#endregion
@@ -941,7 +1131,7 @@ var TraceIdCollector = class {
 		this.getUserId = getUserId;
 	}
 	onStart(span) {
-		for (const key of URL_ATTRIBUTES) {
+		if (span.instrumentationScope?.name !== "maple-browser") for (const key of URL_ATTRIBUTES) {
 			const value = span.attributes[key];
 			if (typeof value === "string") span.setAttribute(key, scrubUrl(value));
 		}
@@ -1015,12 +1205,15 @@ function liveMapleTracer(name, version) {
 function resourceAttributes(config) {
 	const attributes = {
 		[ATTR_SERVICE_NAME]: config.serviceName,
+		[ATTR_TELEMETRY_SDK_NAME]: "@maple-dev/browser",
+		[ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS,
+		[ATTR_TELEMETRY_SDK_VERSION]: SDK_VERSION,
 		"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 (isCommitSha(config.serviceVersion)) attributes["vcs.ref.head.revision"] = config.serviceVersion;
 	}
 	if (config.environment) {
 		attributes["deployment.environment"] = config.environment;
@@ -1029,6 +1222,13 @@ function resourceAttributes(config) {
 	return attributes;
 }
 /**
+* A full 40-hex SHA, or an abbreviated one (7 to 39 hex) with at least one
+* letter: an all-digit version like a date build number is not a commit.
+*/
+function isCommitSha(value) {
+	return /^[0-9a-f]{40}$/i.test(value) || /^[0-9a-f]{7,39}$/i.test(value) && /[a-f]/i.test(value);
+}
+/**
 * 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.
@@ -1048,18 +1248,6 @@ function setupTracing(config) {
 		sdk: sdkHint(SDK_NAME, SDK_VERSION)
 	}), JsonTraceSerializer);
 	const exporter = new ConsentSpanExporter(new HttpStatusExporter(newestFirstOnExit(config.offlineQueue ? new OfflineSpanExporter(otlp) : otlp, JsonTraceSerializer, EXIT_LOGS_RESERVE_BYTES), 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(() => {});
-	};
 	let connectionLosses = 0;
 	let lastLossReason = "";
 	const lossesAtStart = /* @__PURE__ */ new WeakMap();
@@ -1069,10 +1257,44 @@ function setupTracing(config) {
 	};
 	const connectionLost = (span) => {
 		if (typeof navigator !== "undefined" && navigator.onLine === false) return "offline";
-		if (typeof document !== "undefined" && document.visibilityState === "hidden") return "page_hidden";
 		const atStart = lossesAtStart.get(span);
 		return atStart !== void 0 && atStart !== connectionLosses ? lastLossReason : void 0;
 	};
+	const lostXhrSpans = /* @__PURE__ */ new WeakSet();
+	const provider = new TracerProvider({
+		resource: resourceFromAttributes(resourceAttributes(config)),
+		sampler: new SessionSampler(config.tracingSampleRate),
+		spanProcessors: [
+			new TraceIdCollector(() => config.identity?.id),
+			{
+				onStart: (span) => {
+					lossesAtStart.set(span, connectionLosses);
+				},
+				onEnding: (span) => {
+					if (!lostXhrSpans.has(span)) return;
+					span.status.code = SpanStatusCode.UNSET;
+					delete span.status.message;
+					delete span.attributes["error.type"];
+				},
+				onEnd: () => {},
+				forceFlush: () => Promise.resolve(),
+				shutdown: () => Promise.resolve()
+			},
+			new BatchSpanProcessor({
+				exporter,
+				scheduledDelayMillis: EXPORT_INTERVAL_MS
+			})
+		]
+	});
+	trace.setGlobalTracerProvider(provider);
+	propagation.setGlobalPropagator(new CompositePropagator({ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()] }));
+	context.setGlobalContextManager(new StackContextManager().enable());
+	mapleProvider = provider;
+	const globalProvider = trace.getTracerProvider();
+	const ownsGlobals = globalProvider === provider || globalProvider instanceof ProxyTracerProvider && globalProvider.getDelegate() === provider;
+	const onExit = () => {
+		provider.forceFlush().catch(() => {});
+	};
 	const onOffline = () => noteLost("offline");
 	const onVisibilityChange = () => {
 		if (document.visibilityState !== "hidden") return;
@@ -1105,9 +1327,6 @@ function setupTracing(config) {
 	const headers = config.captureHeaders;
 	const instrumentations = [...config.tracingInstrumentFetch ? [new FetchInstrumentation({
 		...requestOptions,
-		requestHook: (span) => {
-			lossesAtStart.set(span, connectionLosses);
-		},
 		applyCustomAttributesOnSpan: (span, request, result) => {
 			noteSettled(span);
 			const sent = request instanceof Request ? request.headers : new Headers(request.headers);
@@ -1129,6 +1348,11 @@ function setupTracing(config) {
 		...requestOptions,
 		applyCustomAttributesOnSpan: (span, xhr) => {
 			noteSettled(span);
+			const lost = xhr.status === 0 ? connectionLost(span) : void 0;
+			if (lost !== void 0) {
+				span.setAttribute("maple.connection_lost", lost);
+				lostXhrSpans.add(span);
+			}
 			if (headers.response.length === 0) return;
 			const exposed = responseHeaders(xhr.getAllResponseHeaders());
 			setHeaderAttributes(span, "response", headers.response, (name) => exposed.get(name));
@@ -1146,12 +1370,12 @@ function setupTracing(config) {
 		}
 		unregisterInstrumentations?.();
 		if (mapleProvider === provider) mapleProvider = void 0;
-		await provider.shutdown();
 		if (ownsGlobals) {
 			trace.disable();
 			context.disable();
 			propagation.disable();
 		}
+		await provider.shutdown();
 	};
 }
 /** `AbortSignal.timeout()` aborts with, and rejects the fetch with, a `TimeoutError` DOMException. */
@@ -1178,8 +1402,7 @@ const alreadyReported = wasReported;
 * 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);
+function recordFailure(span, error, normalized = asError(error)) {
 	if (!alreadyReported(error)) {
 		const exported = span.isRecording() && hasConsent();
 		if (exported) markReported(error);
@@ -1193,33 +1416,71 @@ function recordFailure(span, error) {
 }
 /**
 * Record `error` on a one-off span, exported whatever the session's trace
-* sampling, unless the app's error filters drop it.
+* sampling, unless the app's error filters drop it. Without tracing there is no
+* span, but a buffered replay still keeps itself for the error.
 */
-function recordException(error, options, source, filename, filtered = false) {
+function recordException(error, options, record) {
 	if (!hasConsent()) return;
-	if (!filtered && !shouldCapture(asError(error), {
-		source,
+	const normalized = record.normalized ?? asError(error);
+	if (!record.filtered && !shouldCapture(normalized, {
+		source: record.source,
 		originalError: error
-	}, filename)) return;
+	}, record.filename)) return;
 	const tracer = liveMapleTracer(SDK_NAME, SDK_VERSION);
-	if (!tracer) return;
+	if (!tracer) {
+		notifyErrorRecorded(INVALID_SPAN_CONTEXT);
+		return;
+	}
 	const span = tracer.startSpan(options.name ?? "exception", {
 		kind: SpanKind.INTERNAL,
+		startTime: record.startTime,
 		attributes: {
 			...typeof location !== "undefined" ? { "url.full": scrubUrl(location.href) } : void 0,
 			...options.attributes
 		}
 	}, keepContext(context.active()));
-	recordFailure(span, error);
+	recordFailure(span, error, normalized);
 	span.end();
 }
+/** Held until `init()` starts capture; beyond this, the oldest are dropped. */
+const MAX_PENDING = 30;
+let accepting = false;
+let pending = [];
 /**
-* Record an error that no span was watching. Safe before `init()`, where it
-* does nothing. Reporting the same error object twice records it once.
+* Record an error that no span was watching. Safe before `init()`: the call is
+* held (capped) and recorded when it runs. Reporting the same error object
+* twice records it once.
 */
 function captureException(error, options = {}) {
+	if (typeof window === "undefined") return;
+	if (!accepting && !liveMapleTracer("maple-browser", "0.14.0")) {
+		pending.push({
+			error,
+			options,
+			at: Date.now()
+		});
+		if (pending.length > MAX_PENDING) pending.shift();
+		return;
+	}
 	if (alreadyReported(error)) return;
-	recordException(error, options, "captureException");
+	recordException(error, options, { source: "captureException" });
+}
+/** Called by `init()` once tracing (if any) is up: records what was held, then records directly. */
+function openExceptionCapture() {
+	accepting = true;
+	const held = pending;
+	pending = [];
+	for (const { error, options, at } of held) {
+		if (alreadyReported(error)) continue;
+		recordException(error, options, {
+			source: "captureException",
+			startTime: at
+		});
+	}
+}
+/** Called by `shutdown()`: later calls are held for the next `init()`. */
+function closeExceptionCapture() {
+	accepting = false;
 }
 /** Whether the app's error filters keep `error`, for failures recorded on an existing span. */
 function passesErrorFilters(error) {
@@ -1231,33 +1492,47 @@ function passesErrorFilters(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);
+	recordException(error, options, {
+		source: "captureException",
+		filtered: true
+	});
 }
 /**
 * Register global handlers for uncaught errors and unhandled rejections.
-* Returns a teardown that removes them.
+* Returns a teardown that removes them. With `record: false` (tracing or
+* `captureErrors` off) they record nothing and only tell the replay an error happened.
 */
-function setupErrorCapture() {
+function setupErrorCapture(record = true) {
 	if (typeof window === "undefined" || typeof window.addEventListener !== "function") return () => {};
+	const handle = (error, options, recordOptions) => {
+		if (record) recordException(error, options, recordOptions);
+		else notifyUnrecorded(error, recordOptions);
+	};
 	const onError = (event) => {
-		const error = event.error ?? (event.message && event.filename ? new Error(event.message) : void 0);
+		const error = event.error ?? (event.message && event.filename ? event.message : void 0);
 		if (error === void 0 || alreadyReported(error)) return;
-		recordException(error, {
+		const thrownError = event.error instanceof Error;
+		const filename = event.filename ? scrubUrl(event.filename) : void 0;
+		handle(error, {
 			name: "browser.uncaught_error",
 			attributes: {
 				"maple.exception.source": "window.onerror",
-				...event.filename ? { "code.file.path": event.filename } : void 0,
+				...filename ? { "code.file.path": 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);
+		}, {
+			source: "window.onerror",
+			filename: thrownError ? void 0 : event.filename || void 0,
+			normalized: thrownError ? void 0 : withThrowSite(asError(error), filename, event)
+		});
 	};
 	const onUnhandledRejection = (event) => {
 		if (alreadyReported(event.reason)) return;
-		recordException(event.reason, {
+		handle(event.reason, {
 			name: "browser.unhandled_rejection",
 			attributes: { "maple.exception.source": "unhandledrejection" }
-		}, "unhandledrejection");
+		}, { source: "unhandledrejection" });
 	};
 	window.addEventListener("error", onError);
 	window.addEventListener("unhandledrejection", onUnhandledRejection);
@@ -1266,6 +1541,35 @@ function setupErrorCapture() {
 		window.removeEventListener("unhandledrejection", onUnhandledRejection);
 	};
 }
+/** An error the app wants no span for still keeps a buffered replay, if the filters keep it. */
+function notifyUnrecorded(error, record) {
+	if (!hasConsent()) return;
+	const normalized = record.normalized ?? asError(error);
+	if (!shouldCapture(normalized, {
+		source: record.source,
+		originalError: error
+	}, record.filename)) return;
+	notifyErrorRecorded(INVALID_SPAN_CONTEXT);
+}
+/**
+* A thrown non-Error has no frames of its own, only the event's location. One
+* V8-style frame there makes it groupable by where it was thrown.
+*/
+function withThrowSite(error, filename, event) {
+	if (!filename || error.stack !== void 0) return error;
+	const position = [
+		filename,
+		event.lineno || void 0,
+		event.colno || void 0
+	].filter((part) => part !== void 0).join(":");
+	const header = error.message ? `${error.name}: ${error.message}` : error.name;
+	Object.defineProperty(error, "stack", {
+		value: `${header}\n    at ${position}`,
+		writable: true,
+		configurable: true
+	});
+	return error;
+}
 //#endregion
 //#region src/config.ts
 /**
@@ -1275,7 +1579,14 @@ function setupErrorCapture() {
 function resolveIdentity(config) {
 	return normalizeIdentity(config.user ?? config.userId);
 }
+let warnedServiceName = false;
 function resolveConfig(config) {
+	if (typeof config.serviceName !== "string" || config.serviceName.trim() === "") {
+		if (!warnedServiceName) {
+			warnedServiceName = true;
+			console.warn("[maple] init() needs a `serviceName`; telemetry is reported without one. Pass the name of your app.");
+		}
+	}
 	const endpoint = resolveIngestEndpoint({
 		endpoints: [config.endpoint],
 		regions: [config.region]
@@ -1290,7 +1601,7 @@ function resolveConfig(config) {
 	return {
 		...resolveSignalOptions(config),
 		ingestKey: config.ingestKey,
-		serviceName: config.serviceName,
+		serviceName: typeof config.serviceName === "string" ? config.serviceName : "",
 		endpoint,
 		serviceNamespace: config.serviceNamespace,
 		serviceVersion: config.serviceVersion,
@@ -1520,6 +1831,9 @@ function parseTraceparent(value) {
 /** `x-maple-sdk` value for every request this build makes to ingest. */
 const SDK_HINT = sdkHint(SDK_NAME, SDK_VERSION);
 let active;
+/** What the live handle was made from, to tell a repeated `init()` from a reconfiguration. */
+let activeRawConfig;
+let warnedReinit = false;
 let activeConfig;
 /**
 * An `identify()` made before `init()`, applied when it runs. Auth callbacks
@@ -1529,12 +1843,42 @@ let activeConfig;
 */
 let pendingIdentity;
 /**
+* The flushing half of every `shutdown()` still running. A new `init()` starts
+* its session and deferred signals behind it: the session sink, replay and log
+* pipeline are page-wide, and the old teardown would otherwise stop the new ones.
+*/
+let teardown;
+/** The longest a new `init()` waits for the previous handle's final flush. */
+const TEARDOWN_WAIT_MS = 3e3;
+/** Run one teardown step; a failure must not leave the rest of the SDK half torn down. */
+async function attempt(step) {
+	try {
+		await step();
+	} catch {}
+}
+/** Same settings, by value: a re-render passing a fresh but equal object is not a reconfiguration. */
+function sameConfig(a, b) {
+	if (a === b) return true;
+	try {
+		return JSON.stringify(a) === JSON.stringify(b);
+	} catch {
+		return false;
+	}
+}
+/**
 * 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.
+* it without flushing, and a later grant starts cleanly again. While a handle
+* is live, `init()` returns it and ignores the new config.
 */
 function init(rawConfig) {
-	if (active) return active;
+	if (active) {
+		if (activeRawConfig && !warnedReinit && !sameConfig(activeRawConfig, rawConfig)) {
+			warnedReinit = true;
+			console.warn("[maple] init() was called again with a different config while the SDK is running; the new config is ignored. Call shutdown() on the first handle before re-initializing.");
+		}
+		return active;
+	}
 	if (typeof window === "undefined") return {
 		sessionId: "",
 		shutdown: () => Promise.resolve()
@@ -1543,11 +1887,15 @@ function init(rawConfig) {
 	if (pendingIdentity) config.identity = normalizeIdentity(pendingIdentity.input);
 	pendingIdentity = void 0;
 	activeConfig = config;
-	configurePrivacy(config);
+	activeRawConfig = rawConfig;
+	const removeSanitizer = configurePrivacy(config);
 	configureErrorFilters(config.errorFilters);
 	if (!hasConsent()) clearPendingEvents();
 	setActiveTraceIdProvider(() => trace.getActiveSpan()?.spanContext().traceId);
 	const replayEligible = config.replayEnabled && !isLikelyBot(navigator.userAgent);
+	const recordErrors = config.tracingEnabled && config.tracingCaptureErrors;
+	const behind = teardown && Promise.race([teardown, new Promise((resolve) => setTimeout(resolve, TEARDOWN_WAIT_MS))]);
+	let ready = behind === void 0;
 	let runtime;
 	let stopped = false;
 	let rotateOnNextStart = false;
@@ -1556,8 +1904,14 @@ function init(rawConfig) {
 	let deferredPending;
 	let stopDeferred;
 	let generation = 0;
+	const startTelemetry = () => {
+		if (stopped || !hasConsent()) return;
+		if (config.tracingEnabled && !shutdownTracing) shutdownTracing = setupTracing(config);
+		if (!stopErrorCapture && (recordErrors || replayEligible && config.replayOnErrorSampleRate > 0)) stopErrorCapture = setupErrorCapture(recordErrors);
+	};
 	const startRuntime = () => {
-		if (stopped || runtime || !hasConsent()) return;
+		startTelemetry();
+		if (stopped || !ready || runtime || !hasConsent()) return;
 		setVisitorTracking(config.persistVisitorId && mayPersistIdentifier());
 		const session = (rotateOnNextStart ? rotateSession() : void 0) ?? getSession();
 		rotateOnNextStart = false;
@@ -1569,13 +1923,11 @@ function init(rawConfig) {
 			sdk: SDK_HINT,
 			maskAllInputs: config.maskAllInputs,
 			maskAllText: config.maskAllText,
-			getIdentity: () => activeConfig?.identity
+			getIdentity: () => config.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-BDKAWiKZ.mjs").then(({ startDeferred }) => {
+			setLogIdentity(() => config.identity?.id);
+			deferredPending = import("./deferred-BcyLmMyV.mjs").then(({ startDeferred }) => {
 				stopDeferred = startDeferred(config);
 			}).catch(() => {});
 		}
@@ -1586,7 +1938,7 @@ function init(rawConfig) {
 			serviceName: config.serviceName,
 			environment: config.environment,
 			serviceVersion: config.serviceVersion,
-			getIdentity: () => activeConfig?.identity,
+			getIdentity: () => config.identity,
 			captureUserEmail: config.captureUserEmail
 		};
 		const startMetadata = () => startMetadataSession({
@@ -1609,7 +1961,7 @@ function init(rawConfig) {
 		runtime = next;
 		const ownGeneration = ++generation;
 		const stale = () => stopped || !hasConsent() || generation !== ownGeneration || runtime !== next;
-		next.replayPending = import("./replay-session-Cg3U1RS0.mjs").then(({ startReplaySession }) => {
+		next.replayPending = import("./replay-session-DFPRE4Ee.mjs").then(({ startReplaySession }) => {
 			if (stale()) return;
 			next.replay = startReplaySession({
 				...shared,
@@ -1634,11 +1986,12 @@ function init(rawConfig) {
 		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);
+		const flushed = flush ? sink.flush(true) : void 0;
 		sink.stop();
 		if (sink !== previous.sink) previous.sink.stop();
 		clearSessionSink(currentSessionId ?? previous.initialSessionId);
-		await Promise.all([
+		await flushed;
+		await Promise.allSettled([
 			replayShutdown,
 			metadataShutdown,
 			previous.replayPending
@@ -1648,7 +2001,12 @@ function init(rawConfig) {
 		runtime?.replay?.trigger();
 	});
 	startRuntime();
-	const stopConsentListener = config.requireConsent ? onConsentChange((allowed) => {
+	openExceptionCapture();
+	if (!ready) behind?.then(() => {
+		ready = true;
+		startRuntime();
+	});
+	const stopConsentListener = onConsentChange((allowed) => {
 		if (allowed) {
 			startRuntime();
 			return;
@@ -1658,29 +2016,45 @@ function init(rawConfig) {
 		clearPendingChunk();
 		setVisitorTracking(false);
 		stopRuntime(false);
-	}) : () => {};
+	});
 	const handle = {
 		get sessionId() {
 			return runtime?.replay?.sessionId ?? runtime?.metadata?.sessionId ?? runtime?.initialSessionId ?? "";
 		},
-		shutdown: async () => {
-			if (stopped) return;
+		shutdown: () => {
+			if (stopped) return Promise.resolve();
 			stopped = true;
+			if (active === handle) {
+				active = void 0;
+				activeRawConfig = void 0;
+				activeConfig = void 0;
+			}
 			stopConsentListener();
 			stopReplayTrigger();
-			await stopRuntime(true);
+			closeExceptionCapture();
 			stopErrorCapture?.();
 			stopErrorCapture = void 0;
 			configureErrorFilters(void 0);
+			removeSanitizer();
+			setActiveTraceIdProvider(() => void 0);
 			resetNavigation();
-			await deferredPending;
-			await shutdownTracing?.();
+			const runtimeStopped = attempt(() => stopRuntime(true));
+			const tracingStopped = attempt(() => shutdownTracing?.());
 			shutdownTracing = void 0;
-			await stopDeferred?.();
-			stopDeferred = void 0;
-			setActiveTraceIdProvider(() => void 0);
-			active = void 0;
-			activeConfig = void 0;
+			const flushed = (async () => {
+				await attempt(() => runtimeStopped);
+				await attempt(() => deferredPending);
+				await attempt(() => tracingStopped);
+				await attempt(() => stopDeferred?.());
+				stopDeferred = void 0;
+				if (active === void 0) attachSpanStash(void 0);
+			})();
+			const all = Promise.all([behind, flushed]).then(() => {});
+			teardown = all;
+			all.finally(() => {
+				if (teardown === all) teardown = void 0;
+			});
+			return all;
 		}
 	};
 	active = handle;
@@ -1763,4 +2137,4 @@ const MapleBrowser = {
 	logger
 };
 //#endregion
-export { severityOf as _, detachLogSink as a, resourceAttributes as c, OtlpExporter as d, newestFirstOnExit as f, Severity as g, onErrorRecorded as h, attachLogSink as i, SDK_NAME as l, claimPageSignal as m, navigationSpanAt as n, emitLog as o, attachSpanStash as p, onDocumentPageload as r, liveMapleTracer as s, MapleBrowser as t, SDK_VERSION as u, PENDING_CHUNK_KEY as v, clearPendingChunk as y };
+export { Severity as _, attachLogSink as a, clearPendingChunk as b, liveMapleTracer as c, SDK_VERSION as d, OtlpExporter as f, onErrorRecorded as g, claimPageSignal as h, onDocumentPageload as i, resourceAttributes as l, attachSpanStash as m, interruptNavigation as n, detachLogSink as o, newestFirstOnExit as p, navigationSpanAt as r, emitLog as s, MapleBrowser as t, SDK_NAME as u, severityOf as v, PENDING_CHUNK_KEY as y };