@flareapp/js 2.6.0 → 2.8.0

package/dist/componentProfiler-C6qY96Bt.cjs

@@ -0,0 +1,2497 @@
+let _flareapp_core = require("@flareapp/core");
+
+//#region src/browser/BrowserFlushScheduler.ts
+var BrowserFlushScheduler = class {
+	register(flush) {
+		if (typeof document === "undefined" || !document) return;
+		document.addEventListener("visibilitychange", () => {
+			if (document.visibilityState === "hidden") flush({ keepalive: true });
+		});
+		if (typeof window !== "undefined" && window) window.addEventListener("pagehide", () => flush({ keepalive: true }));
+	}
+};
+
+//#endregion
+//#region src/browser/context/cookie.ts
+/**
+* Parses `document.cookie` into `http.request.cookies`, redacting the value of any cookie whose name
+* matches `denylist`. Null-prototype accumulator so a cookie named `__proto__` is stored, not dropped.
+*/
+function cookie(denylist) {
+	if (!window.document.cookie) return {};
+	const cookies = Object.create(null);
+	window.document.cookie.split("; ").forEach((rawCookie) => {
+		const idx = rawCookie.indexOf("=");
+		if (idx === -1) {
+			cookies[rawCookie] = denylist.test(rawCookie) ? "[redacted]" : "";
+			return;
+		}
+		const name = rawCookie.slice(0, idx);
+		const value = rawCookie.slice(idx + 1);
+		cookies[name] = denylist.test(name) ? "[redacted]" : value;
+	});
+	return { "http.request.cookies": cookies };
+}
+
+//#endregion
+//#region src/browser/context/request.ts
+/**
+* @param hrefOverride when set, the `url.*` attributes come from it instead of the live
+* `window.location.href` (a framework navigation root whose router knows the destination
+* before the URL commits). The override is pre-validated by the caller.
+*/
+function request(urlDenylist, hrefOverride) {
+	return {
+		...(0, _flareapp_core.urlAttributes)(hrefOverride ?? window.location.href, urlDenylist),
+		"user_agent.original": window.navigator.userAgent,
+		"http.request.referrer": (0, _flareapp_core.redactUrlQuery)(window.document.referrer, urlDenylist),
+		"document.ready_state": window.document.readyState
+	};
+}
+
+//#endregion
+//#region src/browser/context/collectBrowser.ts
+function browserEntryPoint(config, urlOverride) {
+	if (typeof window === "undefined") return { "flare.entry_point.type": "web" };
+	const attrs = { "flare.entry_point.type": "web" };
+	const href = urlOverride ? urlOverride.href : window?.location?.href;
+	if (href) {
+		attrs["flare.entry_point.value"] = (0, _flareapp_core.redactUrlQuery)(href, config.urlDenylist);
+		const pathname = urlOverride ? urlOverride.pathname : window?.location?.pathname;
+		if (pathname) {
+			attrs["flare.entry_point.handler.identifier"] = pathname;
+			attrs["http.route"] = pathname;
+			attrs["flare.entry_point.handler.type"] = "browser";
+		}
+	}
+	return attrs;
+}
+const collectBrowser = (config) => {
+	const attrs = { ...browserEntryPoint(config) };
+	if (typeof window === "undefined") return attrs;
+	if (window?.location?.hostname) attrs["host.name"] = window.location.hostname;
+	Object.assign(attrs, request(config.urlDenylist));
+	Object.assign(attrs, cookie(config.urlDenylist));
+	return attrs;
+};
+
+//#endregion
+//#region src/tracing/internalRequest.ts
+/**
+* Marks a request the SDK makes for its own bookkeeping (right now: fetching a source file so a
+* stack frame can show a code snippet). The fetch patch passes those straight through: they are
+* not the app's traffic, so tracing them puts a span in the customer's waterfall for a request
+* their code never made, and propagating a `traceparent` on them is just as wrong.
+*
+* Flare's ingest calls are excluded by URL instead (`isFlareIngestUrl`), because their endpoints
+* are known up front. A snippet fetch targets the customer's own asset, so only the caller knows.
+*/
+const INTERNAL_REQUEST_KEY = "__flare_internal_request__";
+/** An init that marks the request as Flare's own. Unknown init keys are ignored by `fetch`. */
+function internalRequestInit(init) {
+	return {
+		...init,
+		[INTERNAL_REQUEST_KEY]: true
+	};
+}
+function isInternalRequest(init) {
+	return init?.[INTERNAL_REQUEST_KEY] === true;
+}
+
+//#endregion
+//#region src/browser/FetchFileReader.ts
+/**
+* Fetches source files so the stack-trace builder can render a snippet around the offending line.
+* Only http(s) is fetched: other schemes (chrome-extension://, file://, blob:, data:) would cross a
+* privilege boundary or hit a CORS/CSP wall for nothing. Returns null on any failure, never throws.
+*/
+var FetchFileReader = class {
+	read(url) {
+		if (!/^https?:\/\//i.test(url)) return Promise.resolve(null);
+		return fetch(url, internalRequestInit()).then((response) => {
+			if (response.status !== 200) return null;
+			return response.text();
+		}).catch(() => null);
+	}
+};
+
+//#endregion
+//#region src/env/index.ts
+const CLIENT_VERSION = typeof process !== "undefined" && true ? "2.8.0" : "?";
+
+//#endregion
+//#region src/tracing/fill.ts
+/**
+* Replace `source[name]` with `replacer(original)`, tagging the wrapper with a
+* non-enumerable `__flare_original__` so the patch is idempotent and reversible.
+* Ported from Sentry's `fill` (packages/core/src/utils/object.ts), minus the
+* prototype/own-property copying we do not need for `fetch`.
+*/
+function fill(source, name, replacer) {
+	const original = source[name];
+	if (typeof original !== "function") return;
+	if (original.__flare_original__) return;
+	const wrapped = replacer(original);
+	Object.defineProperty(wrapped, "__flare_original__", {
+		value: original,
+		enumerable: false,
+		configurable: true,
+		writable: true
+	});
+	source[name] = wrapped;
+}
+/** Restore a previously `fill`ed property to its original. Safe if never filled. */
+function unfill(source, name) {
+	const current = source[name];
+	if (current && current.__flare_original__) source[name] = current.__flare_original__;
+}
+
+//#endregion
+//#region src/tracing/createPatcher.ts
+/**
+* One `installed` flag for the whole patch set, not per method: XHR's `open` records what `send` reads,
+* so a third party wrapping one of them must never leave the set half patched.
+*
+* Target is passed per call, not captured, because callers look it up fresh (`globalThis.fetch` may not
+* exist yet under SSR).
+*/
+function createPatcher() {
+	let installed = false;
+	let names = [];
+	return {
+		get installed() {
+			return installed;
+		},
+		install(target, patches) {
+			if (installed) return;
+			function applyOne(name) {
+				const wrap = patches[name];
+				if (wrap) fill(target, name, wrap);
+			}
+			names = Object.keys(patches);
+			for (const name of names) applyOne(name);
+			installed = true;
+		},
+		uninstall(target) {
+			if (!installed) return;
+			if (!names.every((name) => {
+				const current = target[name];
+				return typeof current !== "function" || Boolean(current.__flare_original__);
+			})) return;
+			for (const name of names) unfill(target, name);
+			installed = false;
+		}
+	};
+}
+
+//#endregion
+//#region src/tracing/propagation.ts
+/** Follows OTel/Sentry `tracePropagationTargets`: same-origin by default, `[]` disables all. */
+function shouldPropagate(url, absoluteUrl, currentOrigin, targets) {
+	if (targets) {
+		if (targets.length === 0) return false;
+		return targets.some((t) => typeof t === "string" ? url.includes(t) : t.test(url));
+	}
+	return absoluteUrl !== null && absoluteUrl.origin === currentOrigin;
+}
+/** Null on a throwing or malformed entry: the caller then passes the source through untouched, so a
+*  bad merge never breaks the host request. */
+function headerPairsFrom(source) {
+	try {
+		const pairs = [];
+		for (const entry of source) {
+			if (entry === null || typeof entry !== "object") return null;
+			const pair = Array.from(entry);
+			if (pair.length !== 2) return null;
+			pairs.push([String(pair[0]), String(pair[1])]);
+		}
+		return pairs;
+	} catch {
+		return null;
+	}
+}
+/** Fetch accepts any iterable of string pairs as HeadersInit (Map, URLSearchParams, cross-realm Headers). */
+function isIterable(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.iterator] === "function";
+}
+/**
+* A new `RequestInit` carrying `traceparent`, without mutating the caller's `Request` or `init`.
+* Caller-wins: a `traceparent` the caller already set is left alone, matching XHR's
+* `hasAppTraceparent` skip. Returning an init rather than a rebuilt `Request` keeps the caller's
+* single-shot body intact.
+*/
+function mergeTraceparentHeader(input, init, traceparent) {
+	const source = init?.headers ?? (typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0);
+	let headers;
+	if (source instanceof Headers) {
+		if (source.has("traceparent")) return init;
+		headers = new Headers(source);
+		headers.set("traceparent", traceparent);
+	} else if (Array.isArray(source)) {
+		if (source.some(([k]) => String(k).toLowerCase() === "traceparent")) return init;
+		headers = [...source, ["traceparent", traceparent]];
+	} else if (isIterable(source)) {
+		const pairs = headerPairsFrom(source);
+		if (pairs === null) headers = source;
+		else if (pairs.some(([k]) => k.toLowerCase() === "traceparent")) return init;
+		else headers = [...pairs, ["traceparent", traceparent]];
+	} else if (source) {
+		if (Object.keys(source).some((k) => k.toLowerCase() === "traceparent")) return init;
+		headers = {
+			...source,
+			traceparent
+		};
+	} else headers = { traceparent };
+	const result = { headers };
+	if (init) {
+		const descriptors = Object.getOwnPropertyDescriptors(init);
+		delete descriptors.headers;
+		Object.defineProperties(result, descriptors);
+	}
+	if (result.duplex === void 0 && typeof Request !== "undefined" && input instanceof Request && input.body != null) result.duplex = "half";
+	return result;
+}
+
+//#endregion
+//#region src/tracing/httpRequestSpan.ts
+const INLINE_SCHEMES = new Set(["data:", "blob:"]);
+/** The real browser context. Falls back to the origin where there is no document (SSR, tests). */
+function browserUrlContext() {
+	const origin = globalThis.location?.origin ?? "";
+	return {
+		origin,
+		base: () => globalThis.document?.baseURI || origin
+	};
+}
+/** Resolve `url` to an absolute URL against `base`, or null if it cannot be parsed. */
+function safeAbsolute(url, base) {
+	try {
+		return new URL(url, base || void 0);
+	} catch {
+		return null;
+	}
+}
+let ingestCacheKey = null;
+let ingestCacheHrefs = [];
+function resolvedIngestHrefs(config, base) {
+	const raw = [
+		config.ingestUrl,
+		config.logsIngestUrl,
+		config.tracesIngestUrl
+	];
+	const key = `${base} ${raw.join(" ")}`;
+	if (key !== ingestCacheKey) {
+		ingestCacheKey = key;
+		ingestCacheHrefs = raw.filter((u) => typeof u === "string" && u.length > 0).map((u) => safeAbsolute(u, base)).filter((u) => u !== null).map((u) => u.href);
+	}
+	return ingestCacheHrefs;
+}
+function matchesIngestHref(href, ingestHref) {
+	if (!href.startsWith(ingestHref)) return false;
+	const next = href.charAt(ingestHref.length);
+	return next === "" || next === "/" || next === "?" || next === "#";
+}
+/**
+* True when `resolved` targets one of Flare's own ingest endpoints (never traced). The configured
+* URLs are resolved against `base` first: a relative one (a customer proxying ingest through their
+* own origin) would otherwise never match, so every flush POST would open a span that arms the next
+* flush, forever.
+*/
+function isFlareIngestUrl(resolved, config, base) {
+	if (!resolved) return false;
+	return resolvedIngestHrefs(config, base).some((ingestHref) => matchesIngestHref(resolved.href, ingestHref));
+}
+/**
+* Shared request-span attributes for a fetch/XHR call. The `url.*` attributes are redacted the same
+* way as error reports, so tokens and reset codes never leak.
+*/
+function requestSpanAttributes(method, resolved, url, config) {
+	return {
+		"http.request.method": method,
+		...(0, _flareapp_core.urlAttributes)(resolved ? resolved.href : url, config.urlDenylist),
+		...resolved ? { "server.address": resolved.hostname } : {},
+		...resolved && resolved.port ? { "server.port": Number(resolved.port) } : {}
+	};
+}
+/**
+* Completion mapping shared by fetch and XHR: record the status and mark an error on 5xx.
+* `zeroIsError` additionally maps status 0 to error. XHR passes it only for http(s), where status
+* 0 at DONE is always a network/CORS failure or abort; file:// and custom schemes return 0 on
+* success, so it isn't set there. Fetch never passes it (an opaque no-cors response is 0, not error).
+*/
+function endHttpRequestSpan(span, status, opts) {
+	span.setAttribute("http.response.status_code", status);
+	if (status >= 500 || opts?.zeroIsError && status === 0) span.setStatus({ code: _flareapp_core.SpanStatusCode.Error });
+	span.end();
+}
+function finishHttpSpanError(span, error) {
+	span.setStatus({
+		code: _flareapp_core.SpanStatusCode.Error,
+		message: error instanceof Error ? error.message : String(error)
+	});
+	span.end();
+}
+/**
+* Propagation gate plus `traceparent` build shared by fetch and XHR. Returns null when
+* `shouldPropagate` rejects the URL (caller then skips header injection).
+*/
+function traceparentFor(span, resolved, url, origin, config) {
+	if (!shouldPropagate(resolved ? resolved.href : url, resolved, origin, config.tracePropagationTargets)) return null;
+	return (0, _flareapp_core.buildTraceparent)(span.traceId, span.spanId, span.isRecording);
+}
+/**
+* Open a request span for one outgoing fetch or XHR call. Null means the URL is one of Flare's own
+* ingest endpoints, so the caller passes the request through untraced.
+*
+* `absoluteUrl` comes back with the span because both callers need it afterwards: for the traceparent
+* gate, and for XHR's http(s)-only status-0 rule.
+*/
+function startHttpRequestSpan(tracer, request) {
+	const { method, url, urls, spanType } = request;
+	const config = tracer.config;
+	const base = urls.base();
+	const resolved = safeAbsolute(url, base);
+	if (isFlareIngestUrl(resolved, config, base)) return null;
+	if (resolved && INLINE_SCHEMES.has(resolved.protocol)) return null;
+	const pathname = resolved ? resolved.pathname : url;
+	return {
+		span: tracer.startSpan(`${method} ${pathname}`, {
+			spanType,
+			attributes: requestSpanAttributes(method, resolved, url, config)
+		}),
+		absoluteUrl: resolved
+	};
+}
+
+//#endregion
+//#region src/tracing/instrumentationGuard.ts
+/** For a callback the host invokes: a router guard, a store subscriber, ... */
+function insulate(fn) {
+	return (...args) => {
+		try {
+			fn(...args);
+		} catch {}
+	};
+}
+/** Invoke a teardown fn now (if present), swallowing any throw. For cleanup chains. */
+function safeInvoke(fn) {
+	try {
+		fn?.();
+	} catch {}
+}
+const instrumented = /* @__PURE__ */ new WeakMap();
+/**
+* Instrument `target` at most once at a time, tearing down any prior instrumentation of the same object
+* first. Vite HMR re-runs boot code against a router that survives the reload, so without this every
+* cycle appends another listener set that is never removed. Keyed on the object, so a genuinely new
+* router is unaffected.
+*
+* `install` hands each teardown to `track` as it produces it. A router's own `subscribe` / `on` / guard
+* registration can throw, and `install` runs during the host's bootstrap, so a throw part-way through
+* unwinds what already succeeded (newest first) and stops here rather than reaching the host.
+*
+* @returns the cleanup, or a no-op when the install failed and already unwound itself.
+*/
+function instrumentOnce(target, install) {
+	instrumented.get(target)?.();
+	const teardowns = [];
+	function unwind() {
+		for (let i = teardowns.length - 1; i >= 0; i--) safeInvoke(teardowns[i]);
+	}
+	try {
+		install((teardown) => {
+			teardowns.push(teardown);
+		});
+	} catch {
+		unwind();
+		return () => {};
+	}
+	function cleanup() {
+		unwind();
+		if (instrumented.get(target) === cleanup) instrumented.delete(target);
+	}
+	instrumented.set(target, cleanup);
+	return cleanup;
+}
+
+//#endregion
+//#region src/tracing/supportsNativeFetch.ts
+/** True if `fn` is the browser's native fetch (not a polyfill/wrapper). */
+function isNativeFetch(fn) {
+	return typeof fn === "function" && /native code/.test(Function.prototype.toString.call(fn));
+}
+/**
+* Whether the current global `fetch` is native. A polyfilled fetch (e.g. whatwg-fetch) is
+* XHR-backed; skip instrumenting it so the XHR patch is the single source for those requests.
+* Ported from Sentry, including the hidden-iframe fallback used when another library has already
+* wrapped `fetch` and the direct toString check is unreliable.
+*/
+function supportsNativeFetch() {
+	const globals = globalThis;
+	if (typeof globals.fetch !== "function") return false;
+	if (isNativeFetch(globals.fetch)) return true;
+	let result = false;
+	const document = globals.document;
+	if (document && typeof document.createElement === "function") {
+		let sandbox = null;
+		try {
+			sandbox = document.createElement("iframe");
+			sandbox.hidden = true;
+			document.head.appendChild(sandbox);
+			const sandboxWindow = sandbox.contentWindow;
+			if (sandboxWindow && typeof sandboxWindow.fetch === "function") result = isNativeFetch(sandboxWindow.fetch);
+		} catch {
+			result = false;
+		} finally {
+			try {
+				sandbox?.remove();
+			} catch {}
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/tracing/instrumentFetch.ts
+function resolveRequest(input, init) {
+	let url;
+	let method = init?.method;
+	if (typeof Request !== "undefined" && input instanceof Request) {
+		url = input.url;
+		method = method ?? input.method;
+	} else url = typeof input === "string" ? input : String(input);
+	return {
+		method: (method ?? "GET").toUpperCase(),
+		url
+	};
+}
+/**
+* Build a fetch replacement that opens a `browser_fetch` span per call, injects `traceparent` on
+* propagation-eligible URLs, and ends the span on settle. Pure factory: `urls` is injected (node
+* test env has no `location` or `document`), so this is unit-testable without a browser.
+*/
+function createFetchWrapper(tracer, original, urls) {
+	return function(input, init) {
+		const call = (i) => original.call(this, input, i);
+		let started = null;
+		let url = "";
+		let passthrough = false;
+		try {
+			passthrough = !tracer.config.enableTracing || isInternalRequest(init);
+			if (!passthrough) {
+				const resolved = resolveRequest(input, init);
+				url = resolved.url;
+				started = startHttpRequestSpan(tracer, {
+					method: resolved.method,
+					url,
+					urls,
+					spanType: _flareapp_core.BrowserSpanType.Fetch
+				});
+			}
+		} catch {
+			started = null;
+		}
+		if (passthrough || !started) return call(init);
+		const { span, absoluteUrl } = started;
+		let finalInit = init;
+		try {
+			const traceparent = traceparentFor(span, absoluteUrl, url, urls.origin, tracer.config);
+			if (traceparent) finalInit = mergeTraceparentHeader(input, init, traceparent);
+		} catch {
+			finalInit = init;
+		}
+		const endSpan = insulate((response) => endHttpRequestSpan(span, response.status));
+		const failSpan = insulate((error) => finishHttpSpanError(span, error));
+		const finishError = (error) => {
+			failSpan(error);
+			return Promise.reject(error);
+		};
+		let promise;
+		try {
+			promise = call(finalInit);
+		} catch (error) {
+			return finishError(error);
+		}
+		return promise.then((response) => {
+			endSpan(response);
+			return response;
+		}, finishError);
+	};
+}
+const patcher$1 = createPatcher();
+/**
+* Patch the global `fetch` so outgoing requests are traced. No-op when there is no `fetch` or it
+* is not native (a polyfilled/XHR-backed fetch is left for the XHR patch). Idempotent via `fill`.
+* Reversible via `unpatchFetch`.
+*/
+function instrumentFetch(tracer) {
+	if (patcher$1.installed) return;
+	const globals = globalThis;
+	if (typeof globals.fetch !== "function") return;
+	if (!supportsNativeFetch()) return;
+	const urls = browserUrlContext();
+	patcher$1.install(globals, { fetch: (original) => createFetchWrapper(tracer, original, urls) });
+}
+/** Restore the original global `fetch`. Safe if never patched. */
+function unpatchFetch() {
+	patcher$1.uninstall(globalThis);
+}
+
+//#endregion
+//#region src/tracing/instrumentXHR.ts
+const XHR_DONE = 4;
+const xhrState = /* @__PURE__ */ new WeakMap();
+/**
+* Drop the span and listener references once a request is done with them. The entry itself stays in
+* the WeakMap for the re-send `ended` guard, so without this it would keep the Span and the listener
+* closure alive for as long as the app holds on to the XHR.
+*/
+function releaseRequestRefs(state) {
+	state.span = void 0;
+	state.onDone = void 0;
+}
+/**
+* Patch `open` to capture method/URL. Bails (records no state) when either is missing.
+* Calling `open()` on an in-flight request ends that prior request's span (marked aborted)
+* and detaches its `readystatechange` listener before the new request's method/URL are captured.
+*/
+function createXHROpen(original) {
+	return function(method, url, ...rest) {
+		const prior = xhrState.get(this);
+		if (prior && prior.span && !prior.ended) {
+			prior.ended = true;
+			if (prior.onDone) this.removeEventListener("readystatechange", prior.onDone);
+			try {
+				prior.span.setStatus({ code: _flareapp_core.SpanStatusCode.Error });
+				prior.span.end();
+			} catch {}
+			releaseRequestRefs(prior);
+		}
+		try {
+			if (method && url != null) xhrState.set(this, {
+				method: String(method).toUpperCase(),
+				url: String(url),
+				hasAppTraceparent: false,
+				ended: false
+			});
+			else xhrState.delete(this);
+		} catch {
+			xhrState.delete(this);
+		}
+		return original.apply(this, [
+			method,
+			url,
+			...rest
+		]);
+	};
+}
+/**
+* Patch `setRequestHeader` to note when the app sets its own `traceparent`.
+* There is no `getRequestHeader`, so this is the only way to avoid emitting a
+* second `traceparent` (repeat calls merge into one malformed header).
+*/
+function createXHRSetRequestHeader(original) {
+	return function(name, value) {
+		original.call(this, name, value);
+		if (typeof name === "string" && name.toLowerCase() === "traceparent") {
+			const state = xhrState.get(this);
+			if (state) state.hasAppTraceparent = true;
+		}
+	};
+}
+function setTraceparentHeader(xhr, traceparent) {
+	if (!traceparent) return;
+	try {
+		xhr.setRequestHeader("traceparent", traceparent);
+	} catch {}
+}
+/** Patch `send` to open the span, inject `traceparent`, and end on `readyState === 4`. */
+function createXHRSend(tracer, original, urls) {
+	return function(body) {
+		const send = () => original.call(this, body);
+		const config = tracer.config;
+		const state = xhrState.get(this);
+		if (!config.enableTracing || !state) return send();
+		if (state.ended) return send();
+		let started = null;
+		try {
+			started = startHttpRequestSpan(tracer, {
+				method: state.method,
+				url: state.url,
+				urls,
+				spanType: _flareapp_core.BrowserSpanType.Xhr
+			});
+		} catch {
+			started = null;
+		}
+		if (!started) return send();
+		const { span, absoluteUrl } = started;
+		state.span = span;
+		if (!state.hasAppTraceparent) {
+			let traceparent = null;
+			try {
+				traceparent = traceparentFor(span, absoluteUrl, state.url, urls.origin, config);
+			} catch {}
+			setTraceparentHeader(this, traceparent);
+		}
+		const onDone = () => {
+			if (this.readyState !== XHR_DONE) return;
+			this.removeEventListener("readystatechange", onDone);
+			if (state.ended) return;
+			state.ended = true;
+			let status = 0;
+			try {
+				status = this.status;
+			} catch {}
+			try {
+				const zeroIsError = absoluteUrl !== null && (absoluteUrl.protocol === "http:" || absoluteUrl.protocol === "https:");
+				endHttpRequestSpan(span, status, { zeroIsError });
+			} catch {}
+			releaseRequestRefs(state);
+		};
+		this.addEventListener("readystatechange", onDone);
+		state.onDone = onDone;
+		try {
+			return send();
+		} catch (error) {
+			this.removeEventListener("readystatechange", onDone);
+			state.ended = true;
+			try {
+				finishHttpSpanError(span, error);
+			} catch {}
+			releaseRequestRefs(state);
+			throw error;
+		}
+	};
+}
+const patcher = createPatcher();
+let patchedPrototype = null;
+/**
+* Patch `XMLHttpRequest.prototype` (`open`, `setRequestHeader`, `send`) so outgoing
+* XHR requests are traced. No-op where `XMLHttpRequest` is absent (SSR). Idempotent
+* via `fill`. Reversible via `unpatchXHR`.
+*/
+function instrumentXHR(tracer) {
+	if (patcher.installed) return;
+	const xhrConstructor = globalThis.XMLHttpRequest;
+	if (typeof xhrConstructor !== "function" || !xhrConstructor.prototype) return;
+	const urls = browserUrlContext();
+	patcher.install(xhrConstructor.prototype, {
+		open: (original) => createXHROpen(original),
+		setRequestHeader: (original) => createXHRSetRequestHeader(original),
+		send: (original) => createXHRSend(tracer, original, urls)
+	});
+	patchedPrototype = xhrConstructor.prototype;
+}
+/** Restore the original `XMLHttpRequest.prototype` methods. Safe if never patched. */
+function unpatchXHR() {
+	if (!patchedPrototype) return;
+	patcher.uninstall(patchedPrototype);
+	if (!patcher.installed) patchedPrototype = null;
+}
+
+//#endregion
+//#region src/tracing/absoluteHref.ts
+/**
+* Resolve a router-reported href against the page we are on. Returns the `URL`, so a caller that
+* wants the pathname as well as the href does not parse it a second time.
+*
+* Undefined outside a browser or for an unparseable href, so the caller can leave its attribute alone.
+*/
+function absoluteUrl(href) {
+	if (href == null || typeof window === "undefined") return;
+	try {
+		return new URL(href, window.location.href);
+	} catch {
+		return;
+	}
+}
+/**
+* The href form of `absoluteUrl`. Pass one built by the router's own `createHref`/`resolve` (see
+* `resolveHref`), not a bare path: routers strip the app's base path, so `origin + path` yields an
+* address the server does not have.
+*/
+function absoluteHref(href) {
+	return absoluteUrl(href)?.href;
+}
+
+//#endregion
+//#region src/browser/context/collectBrowserSpanContext.ts
+/**
+* Entry point plus request identity for a pageload/navigation root. Deliberately leaner than the report
+* context: no cookies, no structured query params, no host.name (that is resource-level). Captured at
+* span start, so a long-lived root reflects the page it represents rather than the page at close.
+*
+* @param hrefOverride destination href for a router that reports where it is going before the URL
+* commits. Only the URL-derived keys come from it; the rest always reflect the live document. An
+* unparseable override falls back to the live location instead of throwing into root creation.
+*/
+function collectBrowserSpanContext(config, hrefOverride) {
+	if (typeof window === "undefined") return {};
+	const url = absoluteUrl(hrefOverride);
+	return {
+		...browserEntryPoint(config, url),
+		...request(config.urlDenylist, url?.href)
+	};
+}
+/**
+* Updates a root's url after a redirect, or when a newer navigation replaces this one. The root opened
+* with the first destination, so without this it reports a page the user never reached.
+*
+* Does not touch `flare.entry_point.handler.identifier` or `http.route`. Those hold the route template,
+* and reading them back from the href would turn `/product/[id]` into `/product/p01`.
+*
+* Always sets `url.query`, even to an empty string. You can overwrite a span attribute but not remove
+* it, so going from `/a?x=1` to `/b` would otherwise keep the old query.
+*/
+function browserSpanUrlAttributes(config, href) {
+	if (typeof window === "undefined") return {};
+	const resolved = absoluteUrl(href);
+	if (!resolved) return {};
+	const attributes = (0, _flareapp_core.urlAttributes)(resolved.href, config.urlDenylist);
+	return {
+		"url.query": "",
+		...attributes,
+		"flare.entry_point.value": attributes["url.full"]
+	};
+}
+
+//#endregion
+//#region src/tracing/IdleRootController.ts
+/** Browser defaults for the three idle-root timeouts, in ms. Overridable per Config. */
+const DEFAULT_IDLE_TIMEOUTS = {
+	idleTimeout: 1e3,
+	finalTimeout: 3e4,
+	childSpanTimeout: 15e3
+};
+/**
+* Owns one root span's idle lifecycle: open while child spans in its trace are active, closing after
+* `idleTimeout` with no open children, or on the `finalTimeout` / `childSpanTimeout` backstops. Deps are
+* injected so this is testable without real timers or a real tracer.
+*/
+var IdleRootController = class {
+	openChildren = 0;
+	lastChildEndTime = null;
+	settleTime = null;
+	idleTimer = null;
+	finalTimer = null;
+	childTimer = null;
+	ended = false;
+	held = false;
+	unsubscribe;
+	constructor(deps, timeouts) {
+		this.deps = deps;
+		this.timeouts = timeouts;
+		deps.setActiveRoot(deps.root);
+		this.unsubscribe = deps.addSpanListener((e) => this.onSpanEvent(e.phase, e.span));
+		const elapsedMs = Math.max(0, (deps.now() - deps.rootStartTime) / 1e6);
+		const remainingMs = Math.max(0, timeouts.finalTimeout - elapsedMs);
+		this.finalTimer = deps.setTimeout(() => this.finish(deps.now()), remainingMs);
+		this.held = !!deps.held;
+		this.armIdle();
+	}
+	get isEnded() {
+		return this.ended;
+	}
+	/** For a route change or pagehide. */
+	endNow() {
+		this.finish(this.openChildren > 0 || this.held ? this.deps.now() : this.trimmedEnd());
+	}
+	/**
+	* Records the settle moment as a close floor and hands the root back to the normal idle lifecycle. It
+	* deliberately does not close here: a router settles before the framework mounts the new route
+	* component (vue-router runs `afterEach` in the route-update tick, Vue mounts on the next flush), so
+	* closing at settle cleared the active root ahead of every post-navigation mount: every component span
+	* read a null root, and a trailing fetch opened a root of its own.
+	*/
+	releaseHold() {
+		if (this.ended || !this.held) return;
+		this.held = false;
+		if (this.openChildren === 0) this.settleTime = this.deps.now();
+		this.armIdle();
+	}
+	onSpanEvent(phase, span) {
+		if (this.ended) return;
+		if (span === this.deps.root) return;
+		if (span.traceId !== this.deps.root.traceId) return;
+		if (phase === "start") {
+			this.onChildStarted();
+			return;
+		}
+		this.onChildEnded(span);
+	}
+	onChildStarted() {
+		this.openChildren++;
+		this.clearIdle();
+		if (this.openChildren === 1) this.armChildTimeout();
+	}
+	onChildEnded(span) {
+		this.openChildren = Math.max(0, this.openChildren - 1);
+		this.lastChildEndTime = span.endTimeUnixNano || this.deps.now();
+		if (this.openChildren > 0) return;
+		this.clearChildTimeout();
+		this.armIdle();
+	}
+	armIdle() {
+		this.clearIdle();
+		if (this.held) return;
+		this.idleTimer = this.deps.setTimeout(() => {
+			if (this.openChildren > 0) return;
+			this.finish(this.trimmedEnd());
+		}, this.timeouts.idleTimeout);
+	}
+	/** The latest of the floor, a released hold's settle moment, and the last child's end, so a root
+	*  covers its children without ever padding out to `now()`. */
+	trimmedEnd() {
+		return Math.max(this.deps.endFloor(), this.settleTime ?? 0, this.lastChildEndTime ?? 0);
+	}
+	clearIdle() {
+		if (this.idleTimer !== null) {
+			this.deps.clearTimeout(this.idleTimer);
+			this.idleTimer = null;
+		}
+	}
+	armChildTimeout() {
+		this.childTimer = this.deps.setTimeout(() => this.finish(this.deps.now()), this.timeouts.childSpanTimeout);
+	}
+	clearChildTimeout() {
+		if (this.childTimer !== null) {
+			this.deps.clearTimeout(this.childTimer);
+			this.childTimer = null;
+		}
+	}
+	finish(atTimeNano) {
+		if (this.ended) return;
+		this.ended = true;
+		atTimeNano = Math.max(atTimeNano, this.deps.rootStartTime);
+		this.clearIdle();
+		this.clearChildTimeout();
+		if (this.finalTimer !== null) {
+			this.deps.clearTimeout(this.finalTimer);
+			this.finalTimer = null;
+		}
+		this.unsubscribe();
+		this.deps.beforeEnd?.();
+		this.deps.root.end(atTimeNano);
+		this.deps.setActiveRoot(void 0);
+	}
+};
+
+//#endregion
+//#region src/tracing/navigation.ts
+/** The path the address bar is on, or '' outside a browser. */
+function currentPath() {
+	return typeof location !== "undefined" ? location.pathname : "";
+}
+/**
+* Prefers the router's parameterized template over the raw path, so names aggregate per route rather
+* than per url. `derive` runs inside a try: a router that throws on an unresolved match chain falls back
+* to the url name instead of taking the host down.
+*/
+function routeName(derive, fallbackPath, url) {
+	try {
+		const name = derive();
+		if (name) return {
+			name,
+			source: "route",
+			url
+		};
+	} catch {}
+	return {
+		name: fallbackPath,
+		source: "url",
+		url
+	};
+}
+/**
+* `build` is the router's own href builder (vue-router's `resolve`, React Router's `createHref`), which
+* is what puts the app's base path and hash prefix back on. Without it an app served from `/app/` reports
+* `/product/p01` for the real `/app/product/p01`. A router that throws still gets a url from `fallback`.
+*/
+function resolveHref(build, fallback) {
+	let href = fallback;
+	try {
+		href = build() ?? fallback;
+	} catch {}
+	return absoluteHref(href);
+}
+
+//#endregion
+//#region src/tracing/navigationTiming.ts
+/** Split out so the timestamp maths is testable without a Navigation Timing entry. */
+function computePageloadStartNano(timeOriginMs, startTimeMs) {
+	return Math.round((timeOriginMs + (startTimeMs ?? 0)) * 1e6);
+}
+/**
+* Choose the pageload root's start time: navigation start while that window is still open,
+* otherwise `now`. Starting at `now` (when tracing began after the final cap, or the pageload was
+* already traced) avoids a backdated root reporting a bogus multi-second duration.
+*/
+function resolvePageloadStartNano(backdatedNano, nowNano, finalTimeoutNano, alreadyTraced) {
+	if (alreadyTraced) return nowNano;
+	if (nowNano - backdatedNano > finalTimeoutNano) return nowNano;
+	return backdatedNano;
+}
+/** The Navigation Timing API, or null where it is missing or only partly implemented. */
+function navigationTiming() {
+	const perf = globalThis.performance;
+	if (!perf || typeof perf.getEntriesByType !== "function" || typeof perf.timeOrigin !== "number") return null;
+	return perf;
+}
+function navigationEntry(perf) {
+	return perf.getEntriesByType("navigation")[0];
+}
+/**
+* The pageload root's start time in unix nanoseconds, backdated to navigation start via the
+* Navigation Timing entry. Falls back to the tracer's clock when the API is unavailable.
+*/
+function pageloadStartNano() {
+	const perf = navigationTiming();
+	if (!perf) return (0, _flareapp_core.defaultNowNano)();
+	return computePageloadStartNano(perf.timeOrigin, navigationEntry(perf)?.startTime);
+}
+function computePageloadEndNano(timeOriginMs, loadEventEndMs, domContentLoadedEventEndMs, nowNano) {
+	const endMs = loadEventEndMs || domContentLoadedEventEndMs || 0;
+	if (!endMs) return nowNano;
+	return Math.round((timeOriginMs + endMs) * 1e6);
+}
+/**
+* The pageload root's end time in unix nanoseconds, taken from the Navigation
+* Timing `loadEventEnd` (the browser's own "page finished loading" mark), falling
+* back to `domContentLoadedEventEnd`, then the tracer's clock when neither has
+* fired yet or the API is unavailable. Used as the pageload root's close floor so a
+* childless pageload reports its real load duration rather than idle-timeout padding.
+*/
+function pageloadEndNano() {
+	const perf = navigationTiming();
+	if (!perf) return (0, _flareapp_core.defaultNowNano)();
+	const entry = navigationEntry(perf);
+	return computePageloadEndNano(perf.timeOrigin, entry?.loadEventEnd, entry?.domContentLoadedEventEnd, (0, _flareapp_core.defaultNowNano)());
+}
+
+//#endregion
+//#region src/tracing/webvitals/lib/bfcache.ts
+let bfcacheRestoreTime = -1;
+const getBFCacheRestoreTime = () => bfcacheRestoreTime;
+const onBFCacheRestore = (cb) => {
+	addEventListener("pageshow", (event) => {
+		if (event.persisted) {
+			bfcacheRestoreTime = event.timeStamp;
+			cb(event);
+		}
+	}, true);
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/bindReporter.ts
+const getRating = (value, thresholds) => {
+	if (value > thresholds[1]) return "poor";
+	if (value > thresholds[0]) return "needs-improvement";
+	return "good";
+};
+const bindReporter = (callback, metric, thresholds, reportAllChanges) => {
+	let prevValue;
+	let delta;
+	return (forceReport) => {
+		if (metric.value >= 0) {
+			if (forceReport || reportAllChanges) {
+				delta = metric.value - (prevValue ?? 0);
+				if (delta || prevValue === void 0) {
+					prevValue = metric.value;
+					metric.delta = delta;
+					metric.rating = getRating(metric.value, thresholds);
+					callback(metric);
+				}
+			}
+		}
+	};
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/doubleRAF.ts
+const doubleRAF = (cb) => {
+	requestAnimationFrame(() => requestAnimationFrame(cb));
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/getNavigationEntry.ts
+const getNavigationEntry = () => {
+	const navigationEntry = performance.getEntriesByType("navigation")[0];
+	if (navigationEntry && navigationEntry.responseStart > 0 && navigationEntry.responseStart < performance.now()) return navigationEntry;
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/getActivationStart.ts
+const getActivationStart = () => {
+	return getNavigationEntry()?.activationStart ?? 0;
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/getVisibilityWatcher.ts
+let firstHiddenTime = -1;
+const onHiddenFunctions = /* @__PURE__ */ new Set();
+const initHiddenTime = () => {
+	return document.visibilityState === "hidden" && !document.prerendering ? 0 : Infinity;
+};
+const onVisibilityUpdate = (event) => {
+	if (document.visibilityState === "hidden") {
+		if (event.type === "visibilitychange") for (const onHiddenFunction of onHiddenFunctions) onHiddenFunction();
+		if (!isFinite(firstHiddenTime)) {
+			firstHiddenTime = event.type === "visibilitychange" ? event.timeStamp : 0;
+			removeEventListener("prerenderingchange", onVisibilityUpdate, true);
+		}
+	}
+};
+const getVisibilityWatcher = (reset = false) => {
+	if (reset) firstHiddenTime = Infinity;
+	if (firstHiddenTime < 0) {
+		const activationStart = getActivationStart();
+		firstHiddenTime = (!document.prerendering ? globalThis.performance.getEntriesByType("visibility-state").find((e) => e.name === "hidden" && e.startTime >= activationStart)?.startTime : void 0) ?? initHiddenTime();
+		addEventListener("visibilitychange", onVisibilityUpdate, true);
+		addEventListener("prerenderingchange", onVisibilityUpdate, true);
+		onBFCacheRestore(() => {
+			setTimeout(() => {
+				firstHiddenTime = initHiddenTime();
+			});
+		});
+	}
+	return {
+		get firstHiddenTime() {
+			return firstHiddenTime;
+		},
+		onHidden(cb) {
+			onHiddenFunctions.add(cb);
+		}
+	};
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/generateUniqueID.ts
+/**
+* Performantly generate a unique, 30-char string by combining a version
+* number, the current timestamp with a 13-digit number integer.
+* @return {string}
+*/
+const generateUniqueID = () => {
+	return `v6-${Date.now()}-${Math.floor(Math.random() * 8999999999999) + 0xe8d4a51000}`;
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/initMetric.ts
+const initMetric = (name, value = -1, navigationType, navigationId = 0, navigationInteractionId, navigationURL, navigationStartTime) => {
+	const hardNavEntry = getNavigationEntry();
+	const hardNavId = hardNavEntry?.navigationId || 0;
+	let _navigationType = "navigate";
+	if (navigationType) _navigationType = navigationType;
+	else if (getBFCacheRestoreTime() >= 0) _navigationType = "back-forward-cache";
+	else if (hardNavEntry) {
+		if (document.prerendering || getActivationStart() > 0) _navigationType = "prerender";
+		else if (document.wasDiscarded) _navigationType = "restore";
+		else if (hardNavEntry.type) _navigationType = hardNavEntry.type.replace(/_/g, "-");
+	}
+	return {
+		name,
+		value,
+		rating: "good",
+		delta: 0,
+		entries: [],
+		id: generateUniqueID(),
+		navigationType: _navigationType,
+		navigationId: navigationId || hardNavId,
+		navigationInteractionId,
+		navigationURL: navigationURL || hardNavEntry?.name,
+		navigationStartTime: navigationStartTime || 0
+	};
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/initUnique.ts
+const instanceMap = /* @__PURE__ */ new WeakMap();
+/**
+* A function that accepts and identity object and a class object and returns
+* either a new instance of that class or an existing instance, if the
+* identity object was previously used.
+*/
+function initUnique(identityObj, ClassObj) {
+	let classInstances = instanceMap.get(ClassObj);
+	if (!classInstances) {
+		classInstances = /* @__PURE__ */ new WeakMap();
+		instanceMap.set(ClassObj, classInstances);
+	}
+	if (!classInstances.get(identityObj)) classInstances.set(identityObj, new ClassObj());
+	return classInstances.get(identityObj);
+}
+
+//#endregion
+//#region src/tracing/webvitals/lib/LayoutShiftManager.ts
+var LayoutShiftManager = class {
+	_onAfterProcessingUnexpectedShift;
+	_sessionValue = 0;
+	_sessionEntries = [];
+	_processEntry(entry) {
+		if (entry.hadRecentInput) return;
+		const firstSessionEntry = this._sessionEntries[0];
+		const lastSessionEntry = this._sessionEntries.at(-1);
+		if (this._sessionValue && firstSessionEntry && lastSessionEntry && entry.startTime - lastSessionEntry.startTime < 1e3 && entry.startTime - firstSessionEntry.startTime < 5e3) {
+			this._sessionValue += entry.value;
+			this._sessionEntries.push(entry);
+		} else {
+			this._sessionValue = entry.value;
+			this._sessionEntries = [entry];
+		}
+		this._onAfterProcessingUnexpectedShift?.(entry);
+	}
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/observe.ts
+/**
+* Takes a performance entry type and a callback function, and creates a
+* `PerformanceObserver` instance that will observe the specified entry type
+* with buffering enabled and call the callback _for each entry_.
+*
+* This function also feature-detects entry support and wraps the logic in a
+* try/catch to avoid errors in unsupporting browsers.
+*/
+const observe = (types, callback, opts = {}) => {
+	try {
+		const supportedTypes = types.filter((t) => PerformanceObserver.supportedEntryTypes.includes(t));
+		if (supportedTypes.length > 0) {
+			const po = new PerformanceObserver((list) => {
+				queueMicrotask(() => {
+					const entries = list.getEntries();
+					if (supportedTypes.length > 1) entries.sort((a, b) => {
+						return a.startTime + a.duration - (b.startTime + b.duration);
+					});
+					callback(entries);
+				});
+			});
+			for (const t of supportedTypes) po.observe({
+				type: t,
+				buffered: true,
+				...opts
+			});
+			return po;
+		}
+	} catch {}
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/softNavs.ts
+const checkSoftNavsEnabled = (opts) => {
+	return globalThis.PerformanceObserver?.supportedEntryTypes.includes("soft-navigation") && typeof globalThis.PerformanceSoftNavigation?.prototype?.getLargestInteractionContentfulPaint === "function" && opts && opts.reportSoftNavs;
+};
+const storeSoftNavEntry = (map, entry) => {
+	map.set(entry.navigationId, entry);
+	if (map.size > 2) {
+		const firstKey = map.keys().next().value;
+		if (firstKey !== void 0) map.delete(firstKey);
+	}
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/runOnce.ts
+const runOnce = (cb) => {
+	let called = false;
+	return () => {
+		if (!called) {
+			cb();
+			called = true;
+		}
+	};
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/FCPEntryManager.ts
+var FCPEntryManager = class {
+	_softNavigationEntryMap;
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/whenActivated.ts
+const whenActivated = (callback) => {
+	if (document.prerendering) addEventListener("prerenderingchange", callback, true);
+	else callback();
+};
+
+//#endregion
+//#region src/tracing/webvitals/onFCP.ts
+/** Thresholds for FCP. See https://web.dev/articles/fcp#what_is_a_good_fcp_score */
+const FCPThresholds = [1800, 3e3];
+/**
+* Calculates the [FCP](https://web.dev/articles/fcp) value for the current page and
+* calls the `callback` function once the value is ready, along with the
+* relevant `paint` performance entry used to determine the value. The reported
+* value is a `DOMHighResTimeStamp`.
+*/
+const onFCP = (onReport, opts = {}) => {
+	const softNavsEnabled = checkSoftNavsEnabled(opts);
+	whenActivated(() => {
+		const fcpEntryManager = initUnique(opts, FCPEntryManager);
+		const visibilityWatcher = getVisibilityWatcher();
+		let metric = initMetric("FCP");
+		let report;
+		const handleEntries = (entries) => {
+			for (const entry of entries) if (entry.name === "first-contentful-paint") {
+				po.disconnect();
+				if (entry.startTime < visibilityWatcher.firstHiddenTime) {
+					metric.value = Math.max(entry.startTime - getActivationStart(), 0);
+					metric.entries.push(entry);
+					metric.navigationId = entry.navigationId || metric.navigationId;
+					report(true);
+				}
+			}
+		};
+		const po = observe(["paint"], handleEntries);
+		if (po) {
+			report = bindReporter(onReport, metric, FCPThresholds, opts.reportAllChanges);
+			onBFCacheRestore((event) => {
+				metric = initMetric("FCP", -1, "back-forward-cache", metric.navigationId, metric.navigationInteractionId, metric.navigationURL, getBFCacheRestoreTime());
+				report = bindReporter(onReport, metric, FCPThresholds, opts.reportAllChanges);
+				doubleRAF(() => {
+					metric.value = performance.now() - event.timeStamp;
+					report(true);
+				});
+			});
+		}
+		if (softNavsEnabled) {
+			const handleSoftNavEntries = (entries) => {
+				entries.forEach((entry) => {
+					if (fcpEntryManager._softNavigationEntryMap && entry.navigationId) storeSoftNavEntry(fcpEntryManager._softNavigationEntryMap, entry);
+					metric = initMetric("FCP", Math.max((entry.presentationTime || entry.paintTime || 0) - entry.startTime, 0), "soft-navigation", entry.navigationId, entry.interactionId, entry.name, entry.startTime);
+					report = bindReporter(onReport, metric, FCPThresholds, opts.reportAllChanges);
+					report(true);
+				});
+			};
+			observe(["soft-navigation"], handleSoftNavEntries, opts);
+		}
+	});
+};
+
+//#endregion
+//#region src/tracing/webvitals/onCLS.ts
+/** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */
+const CLSThresholds = [.1, .25];
+/**
+* Calculates the [CLS](https://web.dev/articles/cls) value for the current page and
+* calls the `callback` function once the value is ready to be reported, along
+* with all `layout-shift` performance entries that were used in the metric
+* value calculation. The reported value is a `double` (corresponding to a
+* [layout shift score](https://web.dev/articles/cls#layout_shift_score)).
+*
+* If the `reportAllChanges` configuration option is set to `true`, the
+* `callback` function will be called as soon as the value is initially
+* determined as well as any time the value changes throughout the page
+* lifespan.
+*
+* _**Important:** CLS should be continually monitored for changes throughout
+* the entire lifespan of a page—including if the user returns to the page after
+* it's been hidden/backgrounded. However, since browsers often [will not fire
+* additional callbacks once the user has backgrounded a
+* page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),
+* `callback` is always called when the page's visibility state changes to
+* hidden. As a result, the `callback` function might be called multiple times
+* during the same page load._
+*/
+const onCLS = (onReport, opts = {}) => {
+	const visibilityWatcher = getVisibilityWatcher();
+	onFCP(runOnce(() => {
+		let metric = initMetric("CLS", 0);
+		let report;
+		const layoutShiftManager = initUnique(opts, LayoutShiftManager);
+		const initNewCLSMetric = (navigationType, navigationId, navigationInteractionId, navigationURL, navigationStartTime) => {
+			metric = initMetric("CLS", 0, navigationType, navigationId, navigationInteractionId, navigationURL, navigationStartTime);
+			layoutShiftManager._sessionValue = 0;
+			report = bindReporter(onReport, metric, CLSThresholds, opts.reportAllChanges);
+		};
+		const updateAndReportMetric = (forceReport = false) => {
+			if (layoutShiftManager._sessionValue > metric.value) {
+				metric.value = layoutShiftManager._sessionValue;
+				metric.entries = layoutShiftManager._sessionEntries;
+			}
+			report(forceReport);
+		};
+		const handleSoftNavEntry = (entry) => {
+			updateAndReportMetric(true);
+			initNewCLSMetric("soft-navigation", entry.navigationId, entry.interactionId, entry.name, entry.startTime);
+		};
+		const handleEntries = (entries) => {
+			for (const entry of entries) {
+				if (entry.entryType === "soft-navigation") {
+					handleSoftNavEntry(entry);
+					continue;
+				}
+				layoutShiftManager._processEntry(entry);
+			}
+			updateAndReportMetric();
+		};
+		const types = ["layout-shift"];
+		if (checkSoftNavsEnabled(opts)) types.push("soft-navigation");
+		const po = observe(types, handleEntries);
+		if (po) {
+			report = bindReporter(onReport, metric, CLSThresholds, opts.reportAllChanges);
+			visibilityWatcher.onHidden(() => {
+				handleEntries(po.takeRecords());
+				report(true);
+			});
+			onBFCacheRestore(() => {
+				initNewCLSMetric("back-forward-cache", metric.navigationId, metric.navigationInteractionId, metric.navigationURL, getBFCacheRestoreTime());
+				doubleRAF(report);
+			});
+			setTimeout(report);
+		}
+	}));
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/polyfills/interactionCountPolyfill.ts
+let interactionCountEstimate = 0;
+let minKnownInteractionId = Infinity;
+let maxKnownInteractionId = 0;
+const updateEstimate = (entries) => {
+	for (const entry of entries) if (entry.interactionId) {
+		minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);
+		maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);
+		interactionCountEstimate = maxKnownInteractionId ? (maxKnownInteractionId - minKnownInteractionId) / 7 + 1 : 0;
+	}
+};
+let po;
+/**
+* Returns the `interactionCount` value using the native API (if available)
+* or the polyfill estimate in this module.
+*/
+const getInteractionCount = () => {
+	return po ? interactionCountEstimate : performance.interactionCount ?? 0;
+};
+/**
+* Feature detects native support or initializes the polyfill if needed.
+*/
+const initInteractionCountPolyfill = () => {
+	if ("interactionCount" in performance || po) return;
+	po = observe(["event"], updateEstimate, { durationThreshold: 0 });
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/InteractionManager.ts
+const MAX_INTERACTIONS_TO_CONSIDER = 10;
+let prevInteractionCount = 0;
+/**
+* Returns the interaction count since the last bfcache restore (or for the
+* full page lifecycle if there were no bfcache restores).
+*/
+const getInteractionCountForNavigation = () => {
+	return getInteractionCount() - prevInteractionCount;
+};
+var InteractionManager = class {
+	/**
+	* A list of longest interactions on the page (by latency) sorted so the
+	* longest one is first. The list is at most MAX_INTERACTIONS_TO_CONSIDER
+	* long.
+	*/
+	_longestInteractionList = [];
+	/**
+	* A mapping of longest interactions by their interaction ID.
+	* This is used for faster lookup.
+	*/
+	_longestInteractionMap = /* @__PURE__ */ new Map();
+	_onBeforeProcessingEntry;
+	_onAfterProcessingINPCandidate;
+	_resetInteractions() {
+		prevInteractionCount = getInteractionCount();
+		this._longestInteractionList.length = 0;
+		this._longestInteractionMap.clear();
+	}
+	/**
+	* Returns the estimated p98 longest interaction based on the stored
+	* interaction candidates and the interaction count for the current page.
+	*/
+	_estimateP98LongestInteraction(navigationType) {
+		const interactionCountForNavigation = getInteractionCountForNavigation();
+		const candidateInteractionIndex = Math.min(this._longestInteractionList.length - 1, Math.floor(interactionCountForNavigation / 50));
+		if (interactionCountForNavigation && candidateInteractionIndex === -1 && (navigationType === "soft-navigation" || navigationType === "back-forward-cache")) return {
+			_latency: 8,
+			id: -1,
+			entries: []
+		};
+		return this._longestInteractionList[candidateInteractionIndex];
+	}
+	/**
+	* Takes a performance entry and adds it to the list of worst interactions
+	* if its duration is long enough to make it among the worst. If the
+	* entry is part of an existing interaction, it is merged and the latency
+	* and entries list is updated as needed.
+	*/
+	_processEntry(entry) {
+		this._onBeforeProcessingEntry?.(entry);
+		if (!(entry.interactionId || entry.entryType === "first-input")) return;
+		const minLongestInteraction = this._longestInteractionList.at(-1);
+		let interaction = this._longestInteractionMap.get(entry.interactionId);
+		if (interaction || this._longestInteractionList.length < MAX_INTERACTIONS_TO_CONSIDER || entry.duration > minLongestInteraction._latency) {
+			if (interaction) {
+				if (entry.duration > interaction._latency) {
+					interaction.entries = [entry];
+					interaction._latency = entry.duration;
+				} else if (entry.duration === interaction._latency && entry.startTime === interaction.entries[0].startTime) interaction.entries.push(entry);
+			} else {
+				interaction = {
+					id: entry.interactionId,
+					entries: [entry],
+					_latency: entry.duration
+				};
+				this._longestInteractionMap.set(interaction.id, interaction);
+				this._longestInteractionList.push(interaction);
+			}
+			this._longestInteractionList.sort((a, b) => b._latency - a._latency);
+			if (this._longestInteractionList.length > MAX_INTERACTIONS_TO_CONSIDER) {
+				const removedInteractions = this._longestInteractionList.splice(MAX_INTERACTIONS_TO_CONSIDER);
+				for (const interaction of removedInteractions) this._longestInteractionMap.delete(interaction.id);
+			}
+			this._onAfterProcessingINPCandidate?.(interaction);
+		}
+	}
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/whenIdleOrHidden.ts
+/**
+* Runs the passed callback during the next idle period, or immediately
+* if the browser's visibility state is (or becomes) hidden.
+*/
+const whenIdleOrHidden = (cb) => {
+	const timeout = "requestIdleCallback" in globalThis ? 1e3 : 0;
+	const rIC = globalThis.requestIdleCallback || setTimeout;
+	const cIC = globalThis.cancelIdleCallback || clearTimeout;
+	if (document.visibilityState === "hidden") cb();
+	else {
+		const wrappedCb = runOnce(cb);
+		let idleHandle = -1;
+		const onHidden = () => {
+			cIC(idleHandle);
+			wrappedCb();
+		};
+		addEventListener("visibilitychange", onHidden, {
+			once: true,
+			capture: true
+		});
+		idleHandle = rIC(() => {
+			removeEventListener("visibilitychange", onHidden, { capture: true });
+			wrappedCb();
+		}, { timeout });
+	}
+};
+
+//#endregion
+//#region src/tracing/webvitals/onINP.ts
+/** Thresholds for INP. See https://web.dev/articles/inp#what_is_a_good_inp_score */
+const INPThresholds = [200, 500];
+const DEFAULT_DURATION_THRESHOLD = 40;
+/**
+* Calculates the [INP](https://web.dev/articles/inp) value for the current
+* page and calls the `callback` function once the value is ready, along with
+* the `event` performance entries reported for that interaction. The reported
+* value is a `DOMHighResTimeStamp`.
+*
+* A custom `durationThreshold` configuration option can optionally be passed
+* to control what `event-timing` entries are considered for INP reporting. The
+* default threshold is `40`, which means INP scores of less than 40 will not
+* be reported. To avoid reporting no interactions in these cases, the library
+* will fall back to the input delay of the first interaction. Note that this
+* will not affect your 75th percentile INP value unless that value is also
+* less than 40 (well below the recommended
+* [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).
+*
+* If the `reportAllChanges` configuration option is set to `true`, the
+* `callback` function will be called as soon as the value is initially
+* determined as well as any time the value changes throughout the page
+* lifespan.
+*
+* _**Important:** INP should be continually monitored for changes throughout
+* the entire lifespan of a page—including if the user returns to the page after
+* it's been hidden/backgrounded. However, since browsers often [will not fire
+* additional callbacks once the user has backgrounded a
+* page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),
+* `callback` is always called when the page's visibility state changes to
+* hidden. As a result, the `callback` function might be called multiple times
+* during the same page load._
+*/
+const onINP = (onReport, opts = {}) => {
+	if (!(globalThis.PerformanceEventTiming && "interactionId" in PerformanceEventTiming.prototype)) return;
+	const visibilityWatcher = getVisibilityWatcher();
+	whenActivated(() => {
+		initInteractionCountPolyfill();
+		let metric = initMetric("INP");
+		let report;
+		const interactionManager = initUnique(opts, InteractionManager);
+		const initNewINPMetric = (navigationType, navigationId, navigationInteractionId, navigationURL, navigationStartTime) => {
+			interactionManager._resetInteractions();
+			metric = initMetric("INP", -1, navigationType, navigationId, navigationInteractionId, navigationURL, navigationStartTime);
+			report = bindReporter(onReport, metric, INPThresholds, opts.reportAllChanges);
+		};
+		const updateINPMetric = () => {
+			const inp = interactionManager._estimateP98LongestInteraction(metric.navigationType);
+			if (inp && inp._latency !== metric.value) {
+				metric.value = inp._latency;
+				metric.entries = inp.entries;
+				report();
+			}
+		};
+		const handleSoftNavEntry = (entry) => {
+			updateINPMetric();
+			report(true);
+			initNewINPMetric("soft-navigation", entry.navigationId, entry.interactionId, entry.name, entry.startTime);
+		};
+		const handleEntries = (entries, forceReport = false) => {
+			whenIdleOrHidden(() => {
+				for (const entry of entries) {
+					if (entry.entryType === "soft-navigation") {
+						handleSoftNavEntry(entry);
+						continue;
+					}
+					interactionManager._processEntry(entry);
+				}
+				updateINPMetric();
+				if (forceReport) report(true);
+			});
+		};
+		const types = ["event", "first-input"];
+		if (checkSoftNavsEnabled(opts)) types.push("soft-navigation");
+		const po = observe(types, handleEntries, {
+			...opts,
+			durationThreshold: opts.durationThreshold ?? DEFAULT_DURATION_THRESHOLD
+		});
+		report = bindReporter(onReport, metric, INPThresholds, opts.reportAllChanges);
+		if (po) {
+			visibilityWatcher.onHidden(() => {
+				handleEntries(po.takeRecords(), true);
+			});
+			onBFCacheRestore(() => {
+				initNewINPMetric("back-forward-cache", metric.navigationId, metric.navigationInteractionId, metric.navigationURL, getBFCacheRestoreTime());
+			});
+		}
+	});
+};
+
+//#endregion
+//#region src/tracing/webvitals/lib/LCPEntryManager.ts
+var LCPEntryManager = class {
+	_onBeforeProcessingEntry;
+	_softNavigationEntryMap;
+	_processEntry(entry) {
+		this._onBeforeProcessingEntry?.(entry);
+	}
+};
+
+//#endregion
+//#region src/tracing/webvitals/onLCP.ts
+/** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */
+const LCPThresholds = [2500, 4e3];
+/**
+* Calculates the [LCP](https://web.dev/articles/lcp) value for the current page and
+* calls the `callback` function once the value is ready (along with the
+* relevant `largest-contentful-paint` performance entry used to determine the
+* value). The reported value is a `DOMHighResTimeStamp`.
+*
+* If the `reportAllChanges` configuration option is set to `true`, the
+* `callback` function will be called any time a new `largest-contentful-paint`
+* performance entry is dispatched, or once the final value of the metric has
+* been determined.
+*/
+const onLCP = (onReport, opts = {}) => {
+	let isFinalized = false;
+	const softNavsEnabled = checkSoftNavsEnabled(opts);
+	whenActivated(() => {
+		let visibilityWatcher = getVisibilityWatcher();
+		let metric = initMetric("LCP");
+		let report;
+		const lcpEntryManager = initUnique(opts, LCPEntryManager);
+		const initNewLCPMetric = (navigation, navigationId, navigationInteractionId, navigationURL, navigationStartTime) => {
+			metric = initMetric("LCP", -1, navigation, navigationId, navigationInteractionId, navigationURL, navigationStartTime);
+			report = bindReporter(onReport, metric, LCPThresholds, opts.reportAllChanges);
+			isFinalized = false;
+			if (navigation === "soft-navigation") visibilityWatcher = getVisibilityWatcher(true);
+		};
+		const handleSoftNavEntry = (entry) => {
+			if (lcpEntryManager._softNavigationEntryMap && entry.navigationId) storeSoftNavEntry(lcpEntryManager._softNavigationEntryMap, entry);
+			if (!isFinalized) report(true);
+			initNewLCPMetric("soft-navigation", entry.navigationId, entry.interactionId, entry.name, entry.startTime);
+			const largestInteractionContentfulPaint = entry.getLargestInteractionContentfulPaint?.();
+			if (largestInteractionContentfulPaint) handleEntries([largestInteractionContentfulPaint]);
+		};
+		const handleEntries = (entries) => {
+			if (!opts.reportAllChanges && !softNavsEnabled) entries = entries.slice(-1);
+			for (const entry of entries) {
+				if (!entry) continue;
+				if (entry.entryType === "soft-navigation") {
+					handleSoftNavEntry(entry);
+					continue;
+				}
+				let value = 0;
+				let metricEntries = [];
+				let renderTime = entry.startTime;
+				if (entry.entryType === "largest-contentful-paint") {
+					value = Math.max(entry.startTime - getActivationStart(), 0);
+					lcpEntryManager._processEntry(entry);
+					metricEntries = [entry];
+				} else if (entry.entryType === "interaction-contentful-paint") {
+					const ICPEntry = entry;
+					if (!metric.navigationId) continue;
+					if ("interactionId" in ICPEntry && ICPEntry.interactionId != metric.navigationInteractionId) continue;
+					renderTime = ICPEntry.largestContentfulPaint?.renderTime || 0;
+					value = Math.max(renderTime - entry.startTime, 0);
+					if (ICPEntry.largestContentfulPaint) {
+						lcpEntryManager._processEntry(ICPEntry.largestContentfulPaint);
+						metricEntries = [ICPEntry.largestContentfulPaint];
+					}
+				}
+				if (renderTime < visibilityWatcher.firstHiddenTime) {
+					metric.value = value;
+					metric.entries = metricEntries;
+					report();
+				}
+			}
+		};
+		const types = ["largest-contentful-paint"];
+		if (softNavsEnabled) types.push("interaction-contentful-paint", "soft-navigation");
+		const po = observe(types, handleEntries);
+		if (po) {
+			report = bindReporter(onReport, metric, LCPThresholds, opts.reportAllChanges);
+			const finalizeEventTypes = [
+				"keydown",
+				"click",
+				"visibilitychange"
+			];
+			const finalizeLCP = (event) => {
+				if (event.isTrusted && !isFinalized) {
+					const metricIdToFinalize = metric.id;
+					whenIdleOrHidden(() => {
+						if (!isFinalized) {
+							if (!softNavsEnabled) {
+								po.disconnect();
+								for (const type of finalizeEventTypes) removeEventListener(type, finalizeLCP, { capture: true });
+							}
+							if (metricIdToFinalize === metric.id) {
+								isFinalized = true;
+								report(true);
+							}
+						}
+					});
+				}
+			};
+			for (const type of finalizeEventTypes) addEventListener(type, finalizeLCP, { capture: true });
+			onBFCacheRestore((event) => {
+				initNewLCPMetric("back-forward-cache", metric.navigationId, metric.navigationInteractionId, metric.navigationURL, getBFCacheRestoreTime());
+				report = bindReporter(onReport, metric, LCPThresholds, opts.reportAllChanges);
+				doubleRAF(() => {
+					metric.value = performance.now() - event.timeStamp;
+					isFinalized = true;
+					report(true);
+				});
+			});
+		}
+	});
+};
+
+//#endregion
+//#region src/tracing/webvitals/onTTFB.ts
+/** Thresholds for TTFB. See https://web.dev/articles/ttfb#what_is_a_good_ttfb_score */
+const TTFBThresholds = [800, 1800];
+/**
+* Runs in the next task after the page is done loading and/or prerendering.
+* @param callback
+*/
+const whenReady = (callback) => {
+	if (document.prerendering) whenActivated(() => whenReady(callback));
+	else if (document.readyState !== "complete") addEventListener("load", () => whenReady(callback), true);
+	else setTimeout(callback);
+};
+/**
+* Calculates the [TTFB](https://web.dev/articles/ttfb) value for the
+* current page and calls the `callback` function once the page has loaded,
+* along with the relevant `navigation` performance entry used to determine the
+* value. The reported value is a `DOMHighResTimeStamp`.
+*
+* Note, this function waits until after the page is loaded to call `callback`
+* in order to ensure all properties of the `navigation` entry are populated.
+* This is useful if you want to report on other metrics exposed by the
+* [Navigation Timing API](https://w3c.github.io/navigation-timing/). For
+* example, the TTFB metric starts from the page's [time
+* origin](https://www.w3.org/TR/hr-time-2/#sec-time-origin), which means it
+* includes time spent on DNS lookup, connection negotiation, network latency,
+* and server processing time.
+*/
+const onTTFB = (onReport, opts = {}) => {
+	const softNavsEnabled = checkSoftNavsEnabled(opts);
+	let metric = initMetric("TTFB");
+	let report = bindReporter(onReport, metric, TTFBThresholds, opts.reportAllChanges);
+	whenReady(() => {
+		const hardNavEntry = getNavigationEntry();
+		if (hardNavEntry) {
+			const responseStart = hardNavEntry.responseStart;
+			metric.value = Math.max(responseStart - getActivationStart(), 0);
+			metric.entries = [hardNavEntry];
+			report(true);
+			onBFCacheRestore(() => {
+				metric = initMetric("TTFB", 0, "back-forward-cache", metric.navigationId, metric.navigationInteractionId, metric.navigationURL, getBFCacheRestoreTime());
+				report = bindReporter(onReport, metric, TTFBThresholds, opts.reportAllChanges);
+				report(true);
+			});
+			if (softNavsEnabled) {
+				const reportSoftNavTTFBs = (entries) => {
+					entries.forEach((entry) => {
+						if (entry.navigationId) {
+							metric = initMetric("TTFB", 0, "soft-navigation", entry.navigationId, entry.interactionId, entry.name, entry.startTime);
+							metric.entries = [entry];
+							report = bindReporter(onReport, metric, TTFBThresholds, opts.reportAllChanges);
+							report(true);
+						}
+					});
+				};
+				observe(["soft-navigation"], reportSoftNavTTFBs, opts);
+			}
+		}
+	});
+};
+
+//#endregion
+//#region src/tracing/webVitals.ts
+/**
+* Final the moment they first report, so they can ride the pageload span itself. The other three keep
+* changing until the page goes away, and stamping an early value on the root would leave the root and
+* the later span disagreeing about the same vital.
+*/
+const EARLY_VITALS = ["ttfb", "fcp"];
+/** The one place a vital becomes a wire key. Both the pageload stamp and the late span go through it. */
+function vitalAttributes(vitals) {
+	const attributes = {};
+	for (const [name, value] of Object.entries(vitals)) if (typeof value === "number") attributes[`browser.web_vital.${name}`] = value;
+	return attributes;
+}
+/**
+* Turns the leftover values into one zero-duration span. Pure on purpose: the shape is what the backend
+* groups on, and this way it is testable without a tracer or a clock.
+*
+* Both timestamps sit at the pageload root's start. `spans_2` buckets on `start_time_unix_nano`, so
+* stamping the report moment would drop a tab left open for forty minutes into a minute forty minutes
+* after the page actually loaded.
+*
+* Returns null when nothing is left to report, so the caller emits no span at all.
+*/
+function buildVitalsSpan(input) {
+	const vitals = vitalAttributes(input.vitals);
+	if (Object.keys(vitals).length === 0) return null;
+	return {
+		name: input.routeName,
+		startTimeUnixNano: input.rootStartTimeUnixNano,
+		endTimeUnixNano: input.rootStartTimeUnixNano,
+		attributes: {
+			...input.contextAttributes,
+			"flare.entry_point.handler.identifier": input.routeName,
+			"http.route": input.routeName,
+			"flare.route.source": input.routeSource,
+			...vitals
+		}
+	};
+}
+let collected = {};
+let subscribed = false;
+let recording = false;
+let taken = false;
+function defaultSubscribers() {
+	return {
+		onTTFB: (cb) => onTTFB(cb),
+		onFCP: (cb) => onFCP(cb),
+		onLCP: (cb) => onLCP(cb, { reportAllChanges: true }),
+		onCLS: (cb) => onCLS(cb, { reportAllChanges: true }),
+		onINP: (cb) => onINP(cb, { reportAllChanges: true })
+	};
+}
+/**
+* Subscribes at most once per document: upstream's on* functions return no unsubscribe handle, so a
+* second call would attach a second set of observers with no way to detach either.
+*/
+function startWebVitals(subscribers = defaultSubscribers()) {
+	recording = true;
+	if (subscribed) return;
+	subscribed = true;
+	subscribe(subscribers.onTTFB, "ttfb");
+	subscribe(subscribers.onFCP, "fcp");
+	subscribe(subscribers.onLCP, "lcp");
+	subscribe(subscribers.onCLS, "cls");
+	subscribe(subscribers.onINP, "inp");
+}
+function subscribe(on, name) {
+	try {
+		on((metric) => record(name, metric));
+	} catch {}
+}
+function record(name, metric) {
+	if (!recording || typeof metric?.value !== "number") return;
+	collected[name] = metric.value;
+}
+/**
+* Stops recording and drops what was collected. The observers themselves cannot be detached, and both
+* the `subscribed` and `taken` latches deliberately survive: clearing `subscribed` would let a re-enable
+* attach a second set of observers that is just as undetachable as the first, and clearing `taken` would
+* let those surviving observers refill `collected` and ship a second `browser_web_vital` for the same
+* document once the page is re-enabled and later hidden.
+*/
+function stopWebVitals() {
+	recording = false;
+	collected = {};
+}
+/**
+* The vitals that are already final when the pageload root closes, removed from `collected` so the late
+* span cannot report them a second time. Naturally idempotent: a second call finds the keys gone.
+*/
+function takeEarlyVitals() {
+	if (!recording) return null;
+	const taking = {};
+	for (const name of EARLY_VITALS) {
+		const value = collected[name];
+		if (value !== void 0) {
+			taking[name] = value;
+			delete collected[name];
+		}
+	}
+	return Object.keys(taking).length === 0 ? null : taking;
+}
+/** Everything still outstanding, once. Null afterwards, and null when nothing is left. */
+function takeWebVitals() {
+	if (taken || !recording || Object.keys(collected).length === 0) return null;
+	taken = true;
+	const taking = collected;
+	collected = {};
+	return taking;
+}
+/**
+* Undoes a take after the emit failed partway through, so the values are not lost and a later trigger
+* can retry. Safe to assign outright rather than merge: the whole emit runs synchronously between the
+* take and a catch block calling this, so nothing else can have written to `collected` in between.
+*/
+function restoreWebVitals(vitals) {
+	collected = vitals;
+	taken = false;
+}
+
+//#endregion
+//#region src/tracing/browserTracing.ts
+let controller = null;
+let uninstall = null;
+let lastPath = "";
+let pageloadTraced = false;
+let navSource = null;
+let activeFlare = null;
+let currentRoot = null;
+let pendingRouteName = null;
+let pendingRouteNameOwner = null;
+let pageloadRoot = null;
+let pageloadRootStartNano = 0;
+let pageloadRoute = null;
+let pageloadContext = {};
+function resolveTimeouts(config) {
+	return {
+		idleTimeout: config.idleTimeout ?? DEFAULT_IDLE_TIMEOUTS.idleTimeout,
+		finalTimeout: config.finalTimeout ?? DEFAULT_IDLE_TIMEOUTS.finalTimeout,
+		childSpanTimeout: config.childSpanTimeout ?? DEFAULT_IDLE_TIMEOUTS.childSpanTimeout
+	};
+}
+/** No-ops once the controller has ended: it can close itself asynchronously via a timer, before this
+*  module's `controller` reference is cleared. */
+function withLiveController(fn) {
+	if (!controller || controller.isEnded) return;
+	try {
+		fn(controller);
+	} catch (error) {
+		if (activeFlare?.config.debug) console.error("Flare: browser tracing controller callback failed", error);
+	}
+}
+/** Run `fn` only while the current root is still open. Swallows a throw, like `withLiveController`. */
+function ifRootLive(fn) {
+	withLiveController(() => fn());
+}
+function startRoot(flare, options) {
+	const { spanType, startTimeUnixNano, name = location.pathname, urlOverride, hold, backdated } = options;
+	let root;
+	try {
+		const context = collectBrowserSpanContext(flare.config, urlOverride);
+		root = flare.startSpan(name, {
+			spanType,
+			startTimeUnixNano,
+			forceRoot: true,
+			attributes: {
+				...context,
+				"flare.route.source": "url"
+			}
+		});
+		controller = new IdleRootController({
+			root,
+			addSpanListener: (fn) => flare.tracer.addSpanListener(fn),
+			setActiveRoot: (span) => flare.tracer.setActiveRoot(span),
+			now: _flareapp_core.defaultNowNano,
+			setTimeout: (fn, ms) => setTimeout(fn, ms),
+			clearTimeout: (handle) => clearTimeout(handle),
+			rootStartTime: startTimeUnixNano,
+			endFloor: spanType === _flareapp_core.BrowserSpanType.Pageload && backdated ? pageloadEndNano : () => startTimeUnixNano,
+			held: hold,
+			beforeEnd: spanType === _flareapp_core.BrowserSpanType.Pageload ? () => stampEarlyVitals(root, flare) : void 0
+		}, resolveTimeouts(flare.config));
+		currentRoot = root;
+		if (spanType === _flareapp_core.BrowserSpanType.Pageload) {
+			pageloadRoot = root;
+			pageloadRootStartNano = startTimeUnixNano;
+			pageloadRoute = {
+				name,
+				source: "url"
+			};
+			pageloadContext = { ...context };
+		}
+	} catch (error) {
+		controller = null;
+		currentRoot = null;
+		if (spanType === _flareapp_core.BrowserSpanType.Pageload) {
+			pageloadRoot = null;
+			pageloadRootStartNano = 0;
+			pageloadRoute = null;
+			pageloadContext = {};
+		}
+		try {
+			root?.end();
+		} catch {}
+		try {
+			flare.tracer.setActiveRoot(void 0);
+		} catch {}
+		if (flare.config.debug) console.error("Flare: failed to start browser tracing root", error);
+	}
+}
+function onUrlChanged(flare) {
+	const path = location.pathname;
+	if (path === lastPath) return;
+	lastPath = path;
+	if (navSource) return;
+	withLiveController((live) => live.endNow());
+	startRoot(flare, {
+		spanType: _flareapp_core.BrowserSpanType.Navigation,
+		startTimeUnixNano: (0, _flareapp_core.defaultNowNano)(),
+		name: path
+	});
+}
+/**
+* Writes the already-final vitals onto the pageload root itself, from `IdleRootController`'s beforeEnd
+* hook. Whatever has not reported yet stays in `collected` and rides the later `browser_web_vital`
+* span instead, so no vital is ever sent twice and none is lost.
+*
+* Swallows its own failures: this runs inside the root's close path, and a throw here would leave the
+* root open forever.
+*/
+function stampEarlyVitals(root, flare) {
+	try {
+		const early = takeEarlyVitals();
+		if (!early) return;
+		for (const [key, value] of Object.entries(vitalAttributes(early))) root.setAttribute(key, value);
+	} catch (error) {
+		if (flare.config.debug) console.error("Flare: failed to stamp web vitals on the pageload root", error);
+	}
+}
+/**
+* Emits whatever the pageload root could not carry as one zero-duration `browser_web_vital` span,
+* parented to that root. Page hide only, and once per document.
+*
+* Deliberately NOT on navigation: LCP, CLS and INP keep moving all document long, so emitting at the
+* first route change froze them a second after load, and a session whose first action was a nav click
+* reported no INP at all. One span per document is a backend constraint, so the emit waits for the last
+* moment we get instead. The cost is a page whose hide event never fires reports no vitals.
+*
+* `pageloadRoot` has usually ended by now; reading `traceId` and `spanId` off an ended span is fine,
+* and passing the `Span` rather than a `{ traceId, spanId }` pair is what makes sampling inherit:
+* `resolveTrace()` reads `parent.isRecording` instead of re-rolling the sampler.
+*/
+function emitWebVitals(flare) {
+	const root = pageloadRoot;
+	const route = pageloadRoute;
+	if (!root || !route) return;
+	const vitals = takeWebVitals();
+	if (!vitals) return;
+	try {
+		const planned = buildVitalsSpan({
+			vitals,
+			rootStartTimeUnixNano: pageloadRootStartNano,
+			routeName: route.name,
+			routeSource: route.source,
+			contextAttributes: pageloadContext
+		});
+		if (!planned) return;
+		flare.startSpan(planned.name, {
+			parent: root,
+			forceRoot: true,
+			spanType: _flareapp_core.BrowserSpanType.WebVital,
+			startTimeUnixNano: planned.startTimeUnixNano,
+			attributes: planned.attributes
+		}).end(planned.endTimeUnixNano);
+	} catch (error) {
+		restoreWebVitals(vitals);
+		if (flare.config.debug) console.error("Flare: failed to emit web vitals", error);
+	}
+}
+/** Opens a backdated pageload root, then a navigation root per History change. No-op outside a browser. Idempotent. */
+function startBrowserTracing(flare) {
+	if (typeof window === "undefined" || typeof history === "undefined" || typeof location === "undefined") return;
+	if (uninstall) return;
+	activeFlare = flare;
+	lastPath = location.pathname;
+	const finalTimeoutNano = resolveTimeouts(flare.config).finalTimeout * 1e6;
+	const navigationStart = pageloadStartNano();
+	const pageloadStart = resolvePageloadStartNano(navigationStart, (0, _flareapp_core.defaultNowNano)(), finalTimeoutNano, pageloadTraced);
+	pageloadTraced = true;
+	startRoot(flare, {
+		spanType: _flareapp_core.BrowserSpanType.Pageload,
+		startTimeUnixNano: pageloadStart,
+		backdated: pageloadStart === navigationStart
+	});
+	startWebVitals();
+	if (pendingRouteName) {
+		const route = pendingRouteName;
+		const owner = pendingRouteNameOwner;
+		pendingRouteName = null;
+		pendingRouteNameOwner = null;
+		if (owner === navSource) applyRouteName(route);
+	}
+	const handle = () => {
+		if (!uninstall) return;
+		try {
+			onUrlChanged(flare);
+		} catch (error) {
+			if (flare.config.debug) console.error("Flare: browser tracing navigation handler failed", error);
+		}
+	};
+	function wrapHistoryMethod(original) {
+		return function(...args) {
+			const result = original.apply(this, args);
+			handle();
+			return result;
+		};
+	}
+	fill(history, "pushState", wrapHistoryMethod);
+	fill(history, "replaceState", wrapHistoryMethod);
+	window.addEventListener("popstate", handle);
+	function endRootAndFlush() {
+		if (controller && !controller.isEnded) try {
+			controller.endNow();
+		} catch (error) {
+			if (flare.config.debug) console.error("Flare: failed to end tracing root on page hide", error);
+		}
+		emitWebVitals(flare);
+		try {
+			flare.tracer.flush({ keepalive: true });
+		} catch (error) {
+			if (flare.config.debug) console.error("Flare: failed to flush spans on page hide", error);
+		}
+	}
+	const onPageHide = () => endRootAndFlush();
+	const onVisibilityChange = () => {
+		if (document.visibilityState === "hidden") endRootAndFlush();
+	};
+	window.addEventListener("pagehide", onPageHide);
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	uninstall = () => {
+		unfill(history, "pushState");
+		unfill(history, "replaceState");
+		window.removeEventListener("popstate", handle);
+		window.removeEventListener("pagehide", onPageHide);
+		document.removeEventListener("visibilitychange", onVisibilityChange);
+	};
+}
+/** Idempotent. */
+function stopBrowserTracing() {
+	withLiveController((live) => live.endNow());
+	controller = null;
+	if (uninstall) {
+		uninstall();
+		uninstall = null;
+	}
+	activeFlare = null;
+	currentRoot = null;
+	pendingRouteName = null;
+	pendingRouteNameOwner = null;
+	lastPath = "";
+	stopWebVitals();
+	pageloadRoot = null;
+	pageloadRootStartNano = 0;
+	pageloadRoute = null;
+	pageloadContext = {};
+}
+/**
+* Computes the url attributes a route rename carries, or null when there is nothing to add. Guarded
+* so the pin below (which runs outside ifRootLive's own try/catch) cannot throw into the host.
+*/
+function urlAttributesFor(route) {
+	if (route.url === void 0 || !activeFlare) return null;
+	try {
+		return browserSpanUrlAttributes(activeFlare.config, route.url);
+	} catch {
+		return null;
+	}
+}
+/**
+* Rename the current root and update the attributes that go with the name, and pin the pageload's route
+* for the vitals emit. No-op once it closed; the pin is NOT gated the same way, see below.
+* With no root yet the name is held for the pageload root that opens next, rather than dropped.
+* `owner` stamps who is holding it, so a stale or superseded source cannot land its name later.
+*/
+function applyRouteName(route, owner) {
+	const root = currentRoot;
+	if (!root) {
+		pendingRouteName = route;
+		pendingRouteNameOwner = owner ?? null;
+		return;
+	}
+	const urlAttrs = urlAttributesFor(route);
+	ifRootLive(() => {
+		root.name = route.name;
+		root.setAttribute("flare.entry_point.handler.identifier", route.name);
+		root.setAttribute("http.route", route.name);
+		root.setAttribute("flare.route.source", route.source);
+		if (!urlAttrs) return;
+		for (const [key, value] of Object.entries(urlAttrs)) root.setAttribute(key, value);
+	});
+	if (root !== pageloadRoot) return;
+	pageloadRoute = {
+		name: route.name,
+		source: route.source
+	};
+	if (urlAttrs) pageloadContext = {
+		...pageloadContext,
+		...urlAttrs
+	};
+}
+/**
+* While registered, the built-in History detection opens no roots and the caller drives navigation
+* through the returned handle. Last-wins, and a stale handle no-ops, so an HMR-replaced bootstrap
+* cannot tear down a newer registration.
+*/
+function registerNavigationSource() {
+	const token = {};
+	if (navSource && activeFlare?.config.debug) console.debug("Flare: navigation source replaced");
+	navSource = token;
+	function active() {
+		return navSource === token;
+	}
+	return {
+		startNavigation(opts) {
+			if (!active() || !activeFlare) return;
+			const path = opts?.path ?? currentPath();
+			lastPath = path;
+			withLiveController((live) => live.endNow());
+			startRoot(activeFlare, {
+				spanType: _flareapp_core.BrowserSpanType.Navigation,
+				startTimeUnixNano: (0, _flareapp_core.defaultNowNano)(),
+				name: path,
+				urlOverride: opts?.url,
+				hold: opts?.hold
+			});
+		},
+		setActiveRouteName(route) {
+			if (!active()) return;
+			applyRouteName(route, token);
+		},
+		settleNavigation(route) {
+			if (!active()) return;
+			applyRouteName(route, token);
+			withLiveController((live) => live.releaseHold());
+		},
+		unregister() {
+			if (!active()) return;
+			withLiveController((live) => live.releaseHold());
+			navSource = null;
+			lastPath = currentPath();
+			pendingRouteName = null;
+			pendingRouteNameOwner = null;
+		}
+	};
+}
+/** For sibling tracing modules (the component-profiler seam) that need the live tracer. */
+function activeTracingFlare() {
+	return activeFlare;
+}
+
+//#endregion
+//#region src/createFlareResolver.ts
+/**
+* `process.env.NODE_ENV` is replaced inline by bundlers. The try/catch keeps a process-less
+* environment safe: treat "undetermined" as production (warn, never crash).
+*/
+function isDevMode() {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+}
+/**
+* Builds a per-package Flare resolver: `registerDefaultFlare` (wired once by the web entry) and
+* `resolveFlare` (called at wiring time). Each call holds its own default-provider state. The check
+* that warns about the Electron `__flare` bridge uses `packageName` in its message;
+* `injectInstruction` replaces the closing hint for packages whose advice differs (for example
+* svelte, which points at the preprocessor's importSource).
+*/
+function createFlareResolver(config) {
+	const { packageName } = config;
+	const injectInstruction = config.injectInstruction ?? `Import ${packageName}/inject and pass the @flareapp/electron/renderer instance instead.`;
+	let defaultProvider = null;
+	function registerDefaultFlare(provider) {
+		if (typeof window !== "undefined" && window.__flare) {
+			const message = `[flare] ${packageName} (web root) was imported in a renderer where the Electron bridge is present, pulling the keyed @flareapp/js singleton into the renderer. ` + injectInstruction;
+			if (isDevMode()) throw new Error(message);
+			console.warn(message);
+		}
+		defaultProvider = provider;
+	}
+	function resolveFlare(explicit) {
+		if (explicit) return explicit;
+		if (defaultProvider) return defaultProvider();
+		throw new Error(`[flare] No Flare instance available. Pass \`flare\` (e.g. from @flareapp/electron/renderer), or import ${packageName} (the package root) to use the @flareapp/js default singleton.`);
+	}
+	return {
+		registerDefaultFlare,
+		resolveFlare
+	};
+}
+
+//#endregion
+//#region src/browser/catchWindowErrors.ts
+/**
+* Wire up global `error` and `unhandledrejection` listeners, routing reports through `window.flare`
+* (assigned by Flare.light()/configure()). Events are dropped, not queued, when the global is absent.
+*/
+function catchWindowErrors() {
+	if (typeof window === "undefined") return;
+	window.addEventListener("error", (event) => {
+		const flare = window.flare;
+		if (!flare) return;
+		if (event.error instanceof Error) flare.reportSilently(event.error);
+	});
+	window.addEventListener("unhandledrejection", (event) => {
+		const flare = window.flare;
+		if (!flare) return;
+		(0, _flareapp_core.routeRejection)(flare, event.reason);
+	});
+}
+
+//#endregion
+//#region src/tracing/componentProfiler.ts
+/** Unix nanos on the same clock the tracer uses for span timestamps. */
+const nowNano = _flareapp_core.defaultNowNano;
+/**
+* Reserved up front so descendants can point at a span before it is recorded. Null when the trace is at
+* its span cap: descendants record before this span does, so an id the cap will refuse orphans them.
+*/
+function reserveSpanId(traceId) {
+	if (traceId !== void 0 && !activeTracingFlare()?.tracer.claimSpanSlot(traceId)) return null;
+	return (0, _flareapp_core.spanId)();
+}
+/** The root a top-level component nests under. Null when tracing is off or no root is recording. */
+function activeComponentRoot() {
+	try {
+		const root = activeTracingFlare()?.tracer.getActiveSpan();
+		if (!root || !root.isRecording) return null;
+		return {
+			traceId: root.traceId,
+			parentSpanId: root.spanId
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* An ancestor's context is only usable while it still belongs to the live trace. A profiled component
+* that survives a navigation (a layout around a swapped page body) froze its context under the pageload
+* trace, and `recordComponentSpan` would drop anything pointing at that closed root.
+*/
+function resolveComponentParent(inherited, live) {
+	if (inherited && live && inherited.traceId === live.traceId) return inherited;
+	return live;
+}
+/**
+* Records only while the reserved root is still the live recording root, and drops the span otherwise.
+* Dropping avoids starting a fresh TraceState for a dead trace, which would re-run the sampler, and
+* avoids adding a child to a root that already shipped.
+*/
+function recordComponentSpan(record) {
+	try {
+		const flare = activeTracingFlare();
+		if (!flare) return;
+		const root = flare.tracer.getActiveSpan();
+		if (!root || root.traceId !== record.parent.traceId || !root.isRecording) return;
+		flare.startSpan(record.name, {
+			spanId: record.spanId,
+			parent: {
+				traceId: record.parent.traceId,
+				spanId: record.parent.parentSpanId
+			},
+			spanType: _flareapp_core.BrowserSpanType.Component,
+			startTimeUnixNano: record.startTimeUnixNano,
+			attributes: {
+				...record.attributes,
+				"flare.component.name": record.name
+			},
+			claimed: true
+		}).end(record.endTimeUnixNano);
+	} catch {}
+}
+
+//#endregion
+Object.defineProperty(exports, 'BrowserFlushScheduler', {
+  enumerable: true,
+  get: function () {
+    return BrowserFlushScheduler;
+  }
+});
+Object.defineProperty(exports, 'CLIENT_VERSION', {
+  enumerable: true,
+  get: function () {
+    return CLIENT_VERSION;
+  }
+});
+Object.defineProperty(exports, 'FetchFileReader', {
+  enumerable: true,
+  get: function () {
+    return FetchFileReader;
+  }
+});
+Object.defineProperty(exports, 'absoluteHref', {
+  enumerable: true,
+  get: function () {
+    return absoluteHref;
+  }
+});
+Object.defineProperty(exports, 'absoluteUrl', {
+  enumerable: true,
+  get: function () {
+    return absoluteUrl;
+  }
+});
+Object.defineProperty(exports, 'activeComponentRoot', {
+  enumerable: true,
+  get: function () {
+    return activeComponentRoot;
+  }
+});
+Object.defineProperty(exports, 'catchWindowErrors', {
+  enumerable: true,
+  get: function () {
+    return catchWindowErrors;
+  }
+});
+Object.defineProperty(exports, 'collectBrowser', {
+  enumerable: true,
+  get: function () {
+    return collectBrowser;
+  }
+});
+Object.defineProperty(exports, 'createFlareResolver', {
+  enumerable: true,
+  get: function () {
+    return createFlareResolver;
+  }
+});
+Object.defineProperty(exports, 'currentPath', {
+  enumerable: true,
+  get: function () {
+    return currentPath;
+  }
+});
+Object.defineProperty(exports, 'instrumentFetch', {
+  enumerable: true,
+  get: function () {
+    return instrumentFetch;
+  }
+});
+Object.defineProperty(exports, 'instrumentOnce', {
+  enumerable: true,
+  get: function () {
+    return instrumentOnce;
+  }
+});
+Object.defineProperty(exports, 'instrumentXHR', {
+  enumerable: true,
+  get: function () {
+    return instrumentXHR;
+  }
+});
+Object.defineProperty(exports, 'insulate', {
+  enumerable: true,
+  get: function () {
+    return insulate;
+  }
+});
+Object.defineProperty(exports, 'nowNano', {
+  enumerable: true,
+  get: function () {
+    return nowNano;
+  }
+});
+Object.defineProperty(exports, 'recordComponentSpan', {
+  enumerable: true,
+  get: function () {
+    return recordComponentSpan;
+  }
+});
+Object.defineProperty(exports, 'registerNavigationSource', {
+  enumerable: true,
+  get: function () {
+    return registerNavigationSource;
+  }
+});
+Object.defineProperty(exports, 'reserveSpanId', {
+  enumerable: true,
+  get: function () {
+    return reserveSpanId;
+  }
+});
+Object.defineProperty(exports, 'resolveComponentParent', {
+  enumerable: true,
+  get: function () {
+    return resolveComponentParent;
+  }
+});
+Object.defineProperty(exports, 'resolveHref', {
+  enumerable: true,
+  get: function () {
+    return resolveHref;
+  }
+});
+Object.defineProperty(exports, 'routeName', {
+  enumerable: true,
+  get: function () {
+    return routeName;
+  }
+});
+Object.defineProperty(exports, 'safeInvoke', {
+  enumerable: true,
+  get: function () {
+    return safeInvoke;
+  }
+});
+Object.defineProperty(exports, 'startBrowserTracing', {
+  enumerable: true,
+  get: function () {
+    return startBrowserTracing;
+  }
+});
+Object.defineProperty(exports, 'stopBrowserTracing', {
+  enumerable: true,
+  get: function () {
+    return stopBrowserTracing;
+  }
+});
+Object.defineProperty(exports, 'unpatchFetch', {
+  enumerable: true,
+  get: function () {
+    return unpatchFetch;
+  }
+});
+Object.defineProperty(exports, 'unpatchXHR', {
+  enumerable: true,
+  get: function () {
+    return unpatchXHR;
+  }
+});