@flareapp/js 2.6.0 → 2.8.0

package/dist/componentProfiler-CoH2m13n.mjs

@@ -0,0 +1,2342 @@
+import { BrowserSpanType, SpanStatusCode, buildTraceparent, defaultNowNano, redactUrlQuery, routeRejection, spanId, urlAttributes } from "@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 {
+		...urlAttributes(hrefOverride ?? window.location.href, urlDenylist),
+		"user_agent.original": window.navigator.userAgent,
+		"http.request.referrer": 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"] = 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,
+		...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: SpanStatusCode.Error });
+	span.end();
+}
+function finishHttpSpanError(span, error) {
+	span.setStatus({
+		code: 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 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: 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: 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: 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 = 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 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 defaultNowNano();
+	const entry = navigationEntry(perf);
+	return computePageloadEndNano(perf.timeOrigin, entry?.loadEventEnd, entry?.domContentLoadedEventEnd, 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: defaultNowNano,
+			setTimeout: (fn, ms) => setTimeout(fn, ms),
+			clearTimeout: (handle) => clearTimeout(handle),
+			rootStartTime: startTimeUnixNano,
+			endFloor: spanType === BrowserSpanType.Pageload && backdated ? pageloadEndNano : () => startTimeUnixNano,
+			held: hold,
+			beforeEnd: spanType === BrowserSpanType.Pageload ? () => stampEarlyVitals(root, flare) : void 0
+		}, resolveTimeouts(flare.config));
+		currentRoot = root;
+		if (spanType === BrowserSpanType.Pageload) {
+			pageloadRoot = root;
+			pageloadRootStartNano = startTimeUnixNano;
+			pageloadRoute = {
+				name,
+				source: "url"
+			};
+			pageloadContext = { ...context };
+		}
+	} catch (error) {
+		controller = null;
+		currentRoot = null;
+		if (spanType === 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: BrowserSpanType.Navigation,
+		startTimeUnixNano: 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: 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, defaultNowNano(), finalTimeoutNano, pageloadTraced);
+	pageloadTraced = true;
+	startRoot(flare, {
+		spanType: 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: BrowserSpanType.Navigation,
+				startTimeUnixNano: 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;
+		routeRejection(flare, event.reason);
+	});
+}
+
+//#endregion
+//#region src/tracing/componentProfiler.ts
+/** Unix nanos on the same clock the tracer uses for span timestamps. */
+const nowNano = 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 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: BrowserSpanType.Component,
+			startTimeUnixNano: record.startTimeUnixNano,
+			attributes: {
+				...record.attributes,
+				"flare.component.name": record.name
+			},
+			claimed: true
+		}).end(record.endTimeUnixNano);
+	} catch {}
+}
+
+//#endregion
+export { safeInvoke as C, BrowserFlushScheduler as D, collectBrowser as E, insulate as S, FetchFileReader as T, unpatchXHR as _, resolveComponentParent as a, BrowserSpanType as b, registerNavigationSource as c, currentPath as d, resolveHref as f, instrumentXHR as g, absoluteUrl as h, reserveSpanId as i, startBrowserTracing as l, absoluteHref as m, nowNano as n, catchWindowErrors as o, routeName as p, recordComponentSpan as r, createFlareResolver as s, activeComponentRoot as t, stopBrowserTracing as u, instrumentFetch as v, CLIENT_VERSION as w, instrumentOnce as x, unpatchFetch as y };