@flareapp/js 2.8.0 → 2.9.0

package/dist/{componentProfiler-CoH2m13n.mjs → catchWindowErrors-C0gSVGiF.mjs}

@@ -1,126 +1,138 @@
-import { BrowserSpanType, SpanStatusCode, buildTraceparent, defaultNowNano, redactUrlQuery, routeRejection, spanId, urlAttributes } from "@flareapp/core";
+import { BrowserSpanEventType, BrowserSpanType, BrowserSpanType as BrowserSpanType$1, SpanStatusCode, breadcrumbUrl, 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 }));
-	}
-};
+//#region src/breadcrumbs/utils/documentEvent.ts
+function onDocumentEvent(name, handle) {
+	document.addEventListener(name, handle, true);
+	return () => document.removeEventListener(name, handle, 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 };
+//#region src/breadcrumbs/utils/elementSelector.ts
+const INTERACTIVE_HTML_ELEMENTS = "button, a, input, select, textarea, label, [role], [tabindex], [onclick]";
+const MAX_ANCESTOR_DEPTH = 5;
+function interactiveTarget(target) {
+	let element = target;
+	for (let depth = 0; element && depth < MAX_ANCESTOR_DEPTH; depth++) {
+		if (element.matches?.(INTERACTIVE_HTML_ELEMENTS)) return element;
+		element = element.parentElement;
+	}
+	return target;
+}
+function elementSelector(element) {
+	let selector = element.tagName.toLowerCase();
+	if (element.id) selector += `#${element.id}`;
+	for (const className of element.classList) selector += `.${className}`;
+	return selector;
+}
+function elementTestId(element) {
+	return element.getAttribute?.("data-testid") ?? void 0;
+}
+function elementAttributes(element) {
+	const attributes = { "browser.element.selector": elementSelector(element) };
+	const testId = elementTestId(element);
+	if (testId) attributes["browser.element.test_id"] = testId;
+	return attributes;
 }
 
 //#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
-	};
-}
+//#region src/breadcrumbs/ClickRecorder.ts
+var ClickRecorder = class {
+	type = BrowserSpanEventType.Click;
+	constructor(host) {
+		this.host = host;
+		this.onClick = this.onClick.bind(this);
+	}
+	install() {
+		return onDocumentEvent("click", this.onClick);
+	}
+	onClick(event) {
+		const target = event.target;
+		if (!(target instanceof Element)) return;
+		this.host.record(this.type, elementAttributes(interactiveTarget(target)), defaultNowNano());
+	}
+};
 
 //#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";
-		}
+//#region src/breadcrumbs/FormChangeRecorder.ts
+var FormChangeRecorder = class {
+	type = BrowserSpanEventType.Input;
+	constructor(host) {
+		this.host = host;
+		this.onChange = this.onChange.bind(this);
+	}
+	install() {
+		return onDocumentEvent("change", this.onChange);
+	}
+	onChange(event) {
+		const target = event.target;
+		if (!(target instanceof Element)) return;
+		this.host.record(this.type, elementAttributes(target), defaultNowNano());
 	}
-	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
+//#region src/tracing/utils/absoluteHref.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.
+* 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.
 *
-* 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.
+* Undefined outside a browser or for an unparseable href, so the caller can leave its attribute alone.
 */
-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 absoluteUrl(href) {
+	if (href == null || typeof window === "undefined") return;
+	try {
+		return new URL(href, window.location.href);
+	} catch {
+		return;
+	}
 }
-function isInternalRequest(init) {
-	return init?.[INTERNAL_REQUEST_KEY] === true;
+/**
+* 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/FetchFileReader.ts
+//#region src/instrumentation/navigation/utils.ts
+function currentPath() {
+	return typeof location !== "undefined" ? location.pathname : "";
+}
+function currentHref() {
+	return typeof location !== "undefined" ? location.href : "";
+}
+function routeName(derive, fallbackPath, url) {
+	try {
+		const name = derive();
+		if (name) return {
+			name,
+			source: "route",
+			url
+		};
+	} catch {}
+	return {
+		name: fallbackPath,
+		source: "url",
+		url
+	};
+}
 /**
-* 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.
+* `build` is the router's own href builder (vue-router `resolve`, React Router `createHref`). It puts
+* the app's base path and hash prefix back. Without it, an app served from `/app/` reports
+* `/product/p01` instead of `/app/product/p01`. If `build` throws, we use `fallback`.
 */
-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" : "?";
+function resolveHref(build, fallbackHref) {
+	let href = fallbackHref;
+	try {
+		href = build() ?? fallbackHref;
+	} catch {}
+	return absoluteHref(href);
+}
 
 //#endregion
-//#region src/tracing/fill.ts
+//#region src/tracing/utils/fill.ts
 /**
 * Replace `source[name]` with `replacer(original)`, tagging the wrapper with a
 * non-enumerable `__flare_original__` so the patch is idempotent and reversible.
@@ -147,275 +159,237 @@ function unfill(source, name) {
 }
 
 //#endregion
-//#region src/tracing/createPatcher.ts
+//#region src/instrumentation/navigation/navigationBus.ts
+const subscribers$1 = /* @__PURE__ */ new Set();
+let source = null;
+let currentRoute = null;
+let lastPath = "";
+let uninstallHistory = null;
+function broadcast(callback) {
+	for (const subscriber of subscribers$1) try {
+		callback(subscriber);
+	} catch {}
+}
+function onHistoryChange() {
+	if (!uninstallHistory) return;
+	const path = currentPath();
+	if (path === lastPath) return;
+	lastPath = path;
+	if (source) return;
+	broadcast((subscriber) => subscriber.onUrlChanged?.(path));
+}
+function installHistory() {
+	if (uninstallHistory) return;
+	if (typeof window === "undefined" || typeof history === "undefined" || typeof location === "undefined") return;
+	lastPath = currentPath();
+	function wrapHistoryMethod(original) {
+		return function(...args) {
+			const result = original.apply(this, args);
+			onHistoryChange();
+			return result;
+		};
+	}
+	fill(history, "pushState", wrapHistoryMethod);
+	fill(history, "replaceState", wrapHistoryMethod);
+	window.addEventListener("popstate", onHistoryChange);
+	uninstallHistory = () => {
+		unfill(history, "pushState");
+		unfill(history, "replaceState");
+		window.removeEventListener("popstate", onHistoryChange);
+	};
+}
+function subscribeToNavigation(subscriber) {
+	if (subscribers$1.size === 0) installHistory();
+	subscribers$1.add(subscriber);
+	if (currentRoute) try {
+		subscriber.onRouteName?.(currentRoute.route, currentRoute.owner);
+	} catch {}
+	let removed = false;
+	return () => {
+		if (removed) return;
+		removed = true;
+		subscribers$1.delete(subscriber);
+		if (subscribers$1.size === 0) {
+			uninstallHistory?.();
+			uninstallHistory = null;
+			lastPath = "";
+		}
+	};
+}
 /**
-* 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).
+* Hands navigation to a framework router: while registered, the built-in History detection stays
+* quiet and the router drives every step through the returned handle. The newest registration wins
+* and a stale handle no-ops, because HMR can replace a router that still holds one.
 */
-function createPatcher() {
-	let installed = false;
-	let names = [];
+function registerNavigationSource() {
+	const token = {};
+	if (source) console.debug("Flare: navigation source replaced");
+	source = token;
+	const active = () => source === token;
 	return {
-		get installed() {
-			return installed;
+		startNavigation(opts) {
+			if (!active()) return;
+			const path = opts?.path ?? currentPath();
+			lastPath = path;
+			broadcast((subscriber) => subscriber.onNavigationStart?.({
+				path,
+				url: opts?.url,
+				hold: opts?.hold
+			}));
 		},
-		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;
+		setActiveRouteName(route) {
+			if (!active()) return;
+			currentRoute = {
+				route,
+				owner: token
+			};
+			broadcast((subscriber) => subscriber.onRouteName?.(route, token));
 		},
-		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;
+		settleNavigation(route) {
+			if (!active()) return;
+			currentRoute = {
+				route,
+				owner: token
+			};
+			broadcast((subscriber) => subscriber.onNavigationSettle?.(route, token));
+		},
+		unregister() {
+			if (!active()) return;
+			broadcast((subscriber) => subscriber.onSourceUnregistered?.());
+			source = null;
+			currentRoute = null;
+			lastPath = currentPath();
 		}
 	};
 }
+/** A name from an earlier call is only valid while that source is still registered. */
+function isActiveNavigationSource(token) {
+	return token !== null && source === token;
+}
 
 //#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));
+//#region src/breadcrumbs/NavigationRecorder.ts
+var NavigationRecorder = class {
+	type = BrowserSpanEventType.RouteChange;
+	previousHref = "";
+	constructor(host) {
+		this.host = host;
+		this.onUrlChanged = this.onUrlChanged.bind(this);
+		this.onNavigationSettle = this.onNavigationSettle.bind(this);
 	}
-	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])]);
+	install() {
+		this.record(currentHref());
+		return subscribeToNavigation({
+			onUrlChanged: this.onUrlChanged,
+			onNavigationSettle: this.onNavigationSettle
+		});
+	}
+	onUrlChanged() {
+		this.record(currentHref());
+	}
+	onNavigationSettle(route) {
+		this.record(route.url ?? currentHref(), route);
+	}
+	record(href, route) {
+		const attributes = { "browser.route.to": this.clean(href) };
+		if (this.previousHref) attributes["browser.route.from"] = this.clean(this.previousHref);
+		if (route?.source === "route") {
+			attributes["flare.entry_point.handler.identifier"] = route.name;
+			attributes["flare.route.source"] = route.source;
 		}
-		return pairs;
-	} catch {
-		return null;
+		this.previousHref = href;
+		this.host.record(this.type, attributes, defaultNowNano());
+	}
+	clean(href) {
+		return breadcrumbUrl(href, this.host.config().urlDenylist);
 	}
+};
+
+//#endregion
+//#region src/instrumentation/requests/requestBus.ts
+const subscribers = /* @__PURE__ */ new Set();
+let mutator = null;
+function subscribeToRequests(subscriber) {
+	subscribers.add(subscriber);
+	return () => {
+		subscribers.delete(subscriber);
+	};
 }
-/** 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";
+function claimRequestMutation(owner) {
+	if (mutator !== null) console.warn(`%c FLARE %c
+
+What: two things tried to add headers to outgoing requests. Only one can.
+
+Why it matters: the first one stopped. Requests can now go out without a traceparent header, so Flare cannot link a browser request to its server trace.
+
+How to fix: use one Flare instance, and check your bundle for two copies of @flareapp/js.`, "background:#e11d48;color:#fff;font-weight:bold;font-size:14px;padding:2px 6px", "color:#e11d48;font-size:13px");
+	mutator = owner;
+	return () => {
+		if (mutator === owner) mutator = null;
+	};
+}
+function hasRequestSubscribers() {
+	return subscribers.size > 0 || mutator !== null;
 }
 /**
-* 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.
+* Tells every subscriber a request is about to go out. Returns the (possibly mutated) `init` and
+* `headers` plus one `settle` callback that fans the result out to every subscriber. Returns null
+* when nothing acted on the request; the wrapper must then call the real fetch or send untouched.
+* A subscriber that throws is skipped, so instrumentation never breaks the app's request.
 */
-function mergeTraceparentHeader(input, init, traceparent) {
-	const source = init?.headers ?? (typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0);
+function publishRequestStart(start) {
+	const handlers = [];
+	for (const subscriber of subscribers) try {
+		const handler = subscriber(start);
+		if (handler) handlers.push(handler);
+	} catch {}
+	let init = start.init;
 	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) {
+	if (mutator) try {
+		const handler = mutator(start);
+		if (handler) {
+			handlers.push(handler);
+			if (handler.init !== void 0) init = handler.init;
+			headers = handler.headers;
+		}
+	} catch {}
+	if (handlers.length === 0 && init === start.init && headers === void 0) return null;
 	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) } : {}
+		init,
+		headers,
+		settle(result) {
+			for (const handler of handlers) try {
+				handler.onSettle?.(result);
+			} catch {}
+		}
 	};
 }
+
+//#endregion
+//#region src/tracing/requests/internalRequest.ts
 /**
-* 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.
+* 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.
 *
-* `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.
+* 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.
 */
-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;
+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 {
-		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 {}
+		...init,
+		[INTERNAL_REQUEST_KEY]: true
 	};
 }
-/** 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;
+function isInternalRequest(init) {
+	return init?.[INTERNAL_REQUEST_KEY] === true;
 }
 
 //#endregion
-//#region src/tracing/supportsNativeFetch.ts
+//#region src/tracing/requests/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));
@@ -452,7 +426,42 @@ function supportsNativeFetch() {
 }
 
 //#endregion
-//#region src/tracing/instrumentFetch.ts
+//#region src/tracing/utils/createPatcher.ts
+/**
+* One `installed` flag for the whole set, not one per method: `open` remembers the URL that `send`
+* reads, so a half patched set is broken.
+*/
+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/instrumentation/requests/instrumentFetch.ts
 function resolveRequest(input, init) {
 	let url;
 	let method = init?.method;
@@ -465,113 +474,79 @@ function resolveRequest(input, init) {
 		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) {
+function createFetchWrapper(original) {
 	return function(input, init) {
 		const call = (i) => original.call(this, input, i);
-		let started = null;
-		let url = "";
-		let passthrough = false;
+		let watched = null;
 		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
+			if (hasRequestSubscribers() && !isInternalRequest(init)) {
+				const request = resolveRequest(input, init);
+				watched = publishRequestStart({
+					kind: "fetch",
+					method: request.method,
+					url: request.url,
+					input,
+					init
 				});
 			}
 		} 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;
+			watched = null;
 		}
-		const endSpan = insulate((response) => endHttpRequestSpan(span, response.status));
-		const failSpan = insulate((error) => finishHttpSpanError(span, error));
+		if (!watched) return call(init);
+		const settle = watched.settle;
 		const finishError = (error) => {
-			failSpan(error);
+			settle({ error });
 			return Promise.reject(error);
 		};
 		let promise;
 		try {
-			promise = call(finalInit);
+			promise = call(watched.init);
 		} catch (error) {
 			return finishError(error);
 		}
 		return promise.then((response) => {
-			endSpan(response);
+			settle({ status: response.status });
 			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) {
+function instrumentFetch() {
 	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) });
+	patcher$1.install(globals, { fetch: (original) => createFetchWrapper(original) });
 }
-/** Restore the original global `fetch`. Safe if never patched. */
 function unpatchFetch() {
 	patcher$1.uninstall(globalThis);
 }
 
 //#endregion
-//#region src/tracing/instrumentXHR.ts
+//#region src/instrumentation/requests/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.watched = 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 settleOnce(state, result) {
+	state.ended = true;
+	state.watched?.settle(result);
+	releaseRequestRefs(state);
+}
 function createXHROpen(original) {
 	return function(method, url, ...rest) {
 		const prior = xhrState.get(this);
-		if (prior && prior.span && !prior.ended) {
-			prior.ended = true;
+		if (prior && prior.watched && !prior.ended) {
 			if (prior.onDone) this.removeEventListener("readystatechange", prior.onDone);
-			try {
-				prior.span.setStatus({ code: SpanStatusCode.Error });
-				prior.span.end();
-			} catch {}
-			releaseRequestRefs(prior);
+			settleOnce(prior, { aborted: true });
 		}
 		try {
 			if (method && url != null) xhrState.set(this, {
 				method: String(method).toUpperCase(),
 				url: String(url),
-				hasAppTraceparent: false,
+				appHeaders: /* @__PURE__ */ new Set(),
 				ended: false
 			});
 			else xhrState.delete(this);
@@ -585,69 +560,50 @@ function createXHROpen(original) {
 		]);
 	};
 }
-/**
-* 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;
-		}
+		if (typeof name === "string") xhrState.get(this)?.appHeaders.add(name.toLowerCase());
 	};
 }
-function setTraceparentHeader(xhr, traceparent) {
-	if (!traceparent) return;
-	try {
-		xhr.setRequestHeader("traceparent", traceparent);
-	} catch {}
+function applyHeaders(xhr, state) {
+	const headers = state.watched?.headers;
+	if (!headers) return;
+	for (const [name, value] of Object.entries(headers)) {
+		if (state.appHeaders.has(name.toLowerCase())) continue;
+		try {
+			xhr.setRequestHeader(name, value);
+		} catch {}
+	}
 }
-/** Patch `send` to open the span, inject `traceparent`, and end on `readyState === 4`. */
-function createXHRSend(tracer, original, urls) {
+function createXHRSend(original) {
 	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 || !hasRequestSubscribers()) return send();
 		if (state.ended) return send();
-		let started = null;
+		let watched = null;
 		try {
-			started = startHttpRequestSpan(tracer, {
+			watched = publishRequestStart({
+				kind: "xhr",
 				method: state.method,
-				url: state.url,
-				urls,
-				spanType: BrowserSpanType.Xhr
+				url: state.url
 			});
 		} 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);
+			watched = null;
 		}
+		if (!watched) return send();
+		state.watched = watched;
+		applyHeaders(this, state);
 		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);
+			settleOnce(state, { status });
 		};
 		this.addEventListener("readystatechange", onDone);
 		state.onDone = onDone;
@@ -655,35 +611,24 @@ function createXHRSend(tracer, original, urls) {
 			return send();
 		} catch (error) {
 			this.removeEventListener("readystatechange", onDone);
-			state.ended = true;
-			try {
-				finishHttpSpanError(span, error);
-			} catch {}
-			releaseRequestRefs(state);
+			settleOnce(state, { error });
 			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) {
+function instrumentXHR() {
 	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)
+		send: (original) => createXHRSend(original)
 	});
 	patchedPrototype = xhrConstructor.prototype;
 }
-/** Restore the original `XMLHttpRequest.prototype` methods. Safe if never patched. */
 function unpatchXHR() {
 	if (!patchedPrototype) return;
 	patcher.uninstall(patchedPrototype);
@@ -691,286 +636,522 @@ function unpatchXHR() {
 }
 
 //#endregion
-//#region src/tracing/absoluteHref.ts
+//#region src/instrumentation/requests/requestPatches.ts
+let subscriptions = 0;
 /**
-* 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.
+* Keeps fetch and XHR patched while at least one subscriber lives. Counted, so turning tracing off
+* cannot remove a patch that breadcrumbs still need.
 *
-* Undefined outside a browser or for an unparseable href, so the caller can leave its attribute alone.
+* @param subscribe registers one subscriber and returns its own teardown
 */
-function absoluteUrl(href) {
-	if (href == null || typeof window === "undefined") return;
+function withRequestPatches(subscribe) {
+	if (subscriptions === 0) {
+		instrumentFetch();
+		instrumentXHR();
+	}
+	subscriptions++;
+	const unsubscribe = subscribe();
+	let removed = false;
+	return () => {
+		if (removed) return;
+		removed = true;
+		unsubscribe();
+		subscriptions--;
+		if (subscriptions === 0) {
+			unpatchFetch();
+			unpatchXHR();
+		}
+	};
+}
+
+//#endregion
+//#region src/tracing/requests/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 {
-		return new URL(href, window.location.href);
+		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;
+		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";
+}
 /**
-* 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.
+* 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 absoluteHref(href) {
-	return absoluteUrl(href)?.href;
+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/browser/context/collectBrowserSpanContext.ts
+//#region src/tracing/requests/httpRequestSpan.ts
+const REQUEST_SPAN_TYPES = {
+	fetch: BrowserSpanType.Fetch,
+	xhr: BrowserSpanType.Xhr
+};
+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 === "#";
+}
 /**
-* 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.
+* 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 collectBrowserSpanContext(config, hrefOverride) {
-	if (typeof window === "undefined") return {};
-	const url = absoluteUrl(hrefOverride);
+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 {
-		...browserEntryPoint(config, url),
-		...request(config.urlDenylist, url?.href)
+		"http.request.method": method,
+		...urlAttributes(resolved ? resolved.href : url, config.urlDenylist),
+		...resolved ? { "server.address": resolved.hostname } : {},
+		...resolved && resolved.port ? { "server.port": Number(resolved.port) } : {}
 	};
 }
 /**
-* 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`.
+* 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.
 *
-* 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.
+* `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 browserSpanUrlAttributes(config, href) {
-	if (typeof window === "undefined") return {};
-	const resolved = absoluteUrl(href);
-	if (!resolved) return {};
-	const attributes = urlAttributes(resolved.href, config.urlDenylist);
+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 {
-		"url.query": "",
-		...attributes,
-		"flare.entry_point.value": attributes["url.full"]
+		span: tracer.startSpan(`${method} ${pathname}`, {
+			spanType,
+			attributes: requestSpanAttributes(method, resolved, url, config)
+		}),
+		absoluteUrl: resolved
 	};
 }
 
 //#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
-};
+//#region src/tracing/requests/traceRequests.ts
 /**
-* 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.
+* For http and https, status 0 at DONE means the request got no response.
+*
+* Other schemes return 0 when they succeed. file:// does, and so do custom ones like Electron's
+* registerFileProtocol. A URL we could not parse is not an error either.
 */
-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;
+function zeroIsError(absoluteUrl) {
+	return absoluteUrl !== null && (absoluteUrl.protocol === "http:" || absoluteUrl.protocol === "https:");
+}
+function propagate(span, absoluteUrl, start, urls, tracer) {
+	const traceparent = traceparentFor(span, absoluteUrl, start.url, urls.origin, tracer.config);
+	if (!traceparent) return {};
+	if (start.kind === "xhr") return { headers: { traceparent } };
+	if (start.input === void 0) return {};
+	return { init: mergeTraceparentHeader(start.input, start.init, traceparent) };
+}
+/** Tracing takes the mutation slot, not a plain subscription, because it adds a `traceparent` header. */
+function traceRequests(tracer, urls) {
+	return claimRequestMutation((start) => {
+		if (!tracer.config.enableTracing) return;
+		const started = startHttpRequestSpan(tracer, {
+			method: start.method,
+			url: start.url,
+			urls,
+			spanType: REQUEST_SPAN_TYPES[start.kind]
+		});
+		if (!started) return;
+		const { span, absoluteUrl } = started;
+		let mutated = {};
+		try {
+			mutated = propagate(span, absoluteUrl, start, urls, tracer);
+		} catch {
+			mutated = {};
 		}
-		this.onChildEnded(span);
-	}
-	onChildStarted() {
-		this.openChildren++;
-		this.clearIdle();
-		if (this.openChildren === 1) this.armChildTimeout();
+		return {
+			...mutated,
+			onSettle({ status, error, aborted }) {
+				if (aborted) {
+					span.setStatus({ code: SpanStatusCode.Error });
+					span.end();
+					return;
+				}
+				if (error !== void 0) {
+					finishHttpSpanError(span, error);
+					return;
+				}
+				if (start.kind === "xhr") {
+					endHttpRequestSpan(span, status ?? 0, { zeroIsError: zeroIsError(absoluteUrl) });
+					return;
+				}
+				endHttpRequestSpan(span, status ?? 0);
+			}
+		};
+	});
+}
+
+//#endregion
+//#region src/breadcrumbs/RequestRecorder.ts
+var RequestRecorder = class {
+	type = "browser_request";
+	constructor(host) {
+		this.host = host;
+		this.subscribe = this.subscribe.bind(this);
+		this.onStart = this.onStart.bind(this);
+		this.onSettle = this.onSettle.bind(this);
 	}
-	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();
+	install() {
+		return withRequestPatches(this.subscribe);
 	}
-	armIdle() {
-		this.clearIdle();
-		if (this.held) return;
-		this.idleTimer = this.deps.setTimeout(() => {
-			if (this.openChildren > 0) return;
-			this.finish(this.trimmedEnd());
-		}, this.timeouts.idleTimeout);
+	subscribe() {
+		return subscribeToRequests(this.onStart);
 	}
-	/** 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);
+	onStart(start) {
+		const base = browserUrlContext().base();
+		const absolute = safeAbsolute(start.url, base);
+		if (isFlareIngestUrl(absolute, this.host.config(), base)) return;
+		return { onSettle: this.onSettle.bind(this, start, absolute) };
 	}
-	clearIdle() {
-		if (this.idleTimer !== null) {
-			this.deps.clearTimeout(this.idleTimer);
-			this.idleTimer = null;
-		}
+	onSettle(start, absolute, settle) {
+		const url = absolute ? absolute.href : start.url;
+		const attributes = {
+			"http.request.method": start.method,
+			"url.full": breadcrumbUrl(url, this.host.config().urlDenylist)
+		};
+		if (absolute?.hostname) attributes["server.address"] = absolute.hostname;
+		if (settle.status !== void 0) attributes["http.response.status_code"] = settle.status;
+		this.host.record(REQUEST_SPAN_TYPES[start.kind], attributes, defaultNowNano());
 	}
-	armChildTimeout() {
-		this.childTimer = this.deps.setTimeout(() => this.finish(this.deps.now()), this.timeouts.childSpanTimeout);
+};
+
+//#endregion
+//#region src/breadcrumbs/index.ts
+/** Starts every recorder, returns one teardown. A recorder that fails to install is skipped. */
+function startBreadcrumbs(host) {
+	if (typeof document === "undefined") return () => {};
+	const recorders = [
+		new ClickRecorder(host),
+		new FormChangeRecorder(host),
+		new RequestRecorder(host),
+		new NavigationRecorder(host)
+	];
+	const teardowns = [];
+	for (const recorder of recorders) try {
+		teardowns.push(recorder.install());
+	} catch {}
+	return () => {
+		for (const teardown of teardowns) try {
+			teardown();
+		} catch {}
+	};
+}
+
+//#endregion
+//#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 }));
 	}
-	clearChildTimeout() {
-		if (this.childTimer !== null) {
-			this.deps.clearTimeout(this.childTimer);
-			this.childTimer = null;
+};
+
+//#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;
 		}
-	}
-	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;
+		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";
 		}
-		this.unsubscribe();
-		this.deps.beforeEnd?.();
-		this.deps.root.end(atTimeNano);
-		this.deps.setActiveRoot(void 0);
 	}
+	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/navigation.ts
-/** The path the address bar is on, or '' outside a browser. */
-function currentPath() {
-	return typeof location !== "undefined" ? location.pathname : "";
-}
+//#region src/browser/FetchFileReader.ts
 /**
-* 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.
+* 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.
 */
-function routeName(derive, fallbackPath, url) {
+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.9.0" : "?";
+
+//#endregion
+//#region src/tracing/utils/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 {
-		const name = derive();
-		if (name) return {
-			name,
-			source: "route",
-			url
-		};
+		fn?.();
 	} catch {}
-	return {
-		name: fallbackPath,
-		source: "url",
-		url
-	};
 }
+const instrumented = /* @__PURE__ */ new WeakMap();
 /**
-* `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`.
+* 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 resolveHref(build, fallback) {
-	let href = fallback;
+function instrumentOnce(target, install) {
+	instrumented.get(target)?.();
+	const teardowns = [];
+	function unwind() {
+		for (let i = teardowns.length - 1; i >= 0; i--) safeInvoke(teardowns[i]);
+	}
 	try {
-		href = build() ?? fallback;
-	} catch {}
-	return absoluteHref(href);
+		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/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];
-}
+//#region src/browser/context/collectBrowserSpanContext.ts
 /**
-* 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.
+* 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 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);
+function collectBrowserSpanContext(config, hrefOverride) {
+	if (typeof window === "undefined") return {};
+	const url = absoluteUrl(hrefOverride);
+	return {
+		...browserEntryPoint(config, url),
+		...request(config.urlDenylist, url?.href)
+	};
 }
 /**
-* 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.
+* 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 pageloadEndNano() {
-	const perf = navigationTiming();
-	if (!perf) return defaultNowNano();
-	const entry = navigationEntry(perf);
-	return computePageloadEndNano(perf.timeOrigin, entry?.loadEventEnd, entry?.domContentLoadedEventEnd, defaultNowNano());
+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/webvitals/lib/bfcache.ts
+//#region src/tracing/vitals/webvitals/lib/bfcache.ts
 let bfcacheRestoreTime = -1;
 const getBFCacheRestoreTime = () => bfcacheRestoreTime;
 const onBFCacheRestore = (cb) => {
@@ -983,7 +1164,7 @@ const onBFCacheRestore = (cb) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/bindReporter.ts
+//#region src/tracing/vitals/webvitals/lib/bindReporter.ts
 const getRating = (value, thresholds) => {
 	if (value > thresholds[1]) return "poor";
 	if (value > thresholds[0]) return "needs-improvement";
@@ -1008,26 +1189,26 @@ const bindReporter = (callback, metric, thresholds, reportAllChanges) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/doubleRAF.ts
+//#region src/tracing/vitals/webvitals/lib/doubleRAF.ts
 const doubleRAF = (cb) => {
 	requestAnimationFrame(() => requestAnimationFrame(cb));
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/getNavigationEntry.ts
+//#region src/tracing/vitals/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
+//#region src/tracing/vitals/webvitals/lib/getActivationStart.ts
 const getActivationStart = () => {
 	return getNavigationEntry()?.activationStart ?? 0;
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/getVisibilityWatcher.ts
+//#region src/tracing/vitals/webvitals/lib/getVisibilityWatcher.ts
 let firstHiddenTime = -1;
 const onHiddenFunctions = /* @__PURE__ */ new Set();
 const initHiddenTime = () => {
@@ -1066,7 +1247,7 @@ const getVisibilityWatcher = (reset = false) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/generateUniqueID.ts
+//#region src/tracing/vitals/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.
@@ -1077,7 +1258,7 @@ const generateUniqueID = () => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/initMetric.ts
+//#region src/tracing/vitals/webvitals/lib/initMetric.ts
 const initMetric = (name, value = -1, navigationType, navigationId = 0, navigationInteractionId, navigationURL, navigationStartTime) => {
 	const hardNavEntry = getNavigationEntry();
 	const hardNavId = hardNavEntry?.navigationId || 0;
@@ -1105,7 +1286,7 @@ const initMetric = (name, value = -1, navigationType, navigationId = 0, navigati
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/initUnique.ts
+//#region src/tracing/vitals/webvitals/lib/initUnique.ts
 const instanceMap = /* @__PURE__ */ new WeakMap();
 /**
 * A function that accepts and identity object and a class object and returns
@@ -1123,7 +1304,7 @@ function initUnique(identityObj, ClassObj) {
 }
 
 //#endregion
-//#region src/tracing/webvitals/lib/LayoutShiftManager.ts
+//#region src/tracing/vitals/webvitals/lib/LayoutShiftManager.ts
 var LayoutShiftManager = class {
 	_onAfterProcessingUnexpectedShift;
 	_sessionValue = 0;
@@ -1144,7 +1325,7 @@ var LayoutShiftManager = class {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/observe.ts
+//#region src/tracing/vitals/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
@@ -1177,7 +1358,7 @@ const observe = (types, callback, opts = {}) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/softNavs.ts
+//#region src/tracing/vitals/webvitals/lib/softNavs.ts
 const checkSoftNavsEnabled = (opts) => {
 	return globalThis.PerformanceObserver?.supportedEntryTypes.includes("soft-navigation") && typeof globalThis.PerformanceSoftNavigation?.prototype?.getLargestInteractionContentfulPaint === "function" && opts && opts.reportSoftNavs;
 };
@@ -1190,7 +1371,7 @@ const storeSoftNavEntry = (map, entry) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/runOnce.ts
+//#region src/tracing/vitals/webvitals/lib/runOnce.ts
 const runOnce = (cb) => {
 	let called = false;
 	return () => {
@@ -1202,20 +1383,20 @@ const runOnce = (cb) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/FCPEntryManager.ts
+//#region src/tracing/vitals/webvitals/lib/FCPEntryManager.ts
 var FCPEntryManager = class {
 	_softNavigationEntryMap;
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/whenActivated.ts
+//#region src/tracing/vitals/webvitals/lib/whenActivated.ts
 const whenActivated = (callback) => {
 	if (document.prerendering) addEventListener("prerenderingchange", callback, true);
 	else callback();
 };
 
 //#endregion
-//#region src/tracing/webvitals/onFCP.ts
+//#region src/tracing/vitals/webvitals/onFCP.ts
 /** Thresholds for FCP. See https://web.dev/articles/fcp#what_is_a_good_fcp_score */
 const FCPThresholds = [1800, 3e3];
 /**
@@ -1269,7 +1450,7 @@ const onFCP = (onReport, opts = {}) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/onCLS.ts
+//#region src/tracing/vitals/webvitals/onCLS.ts
 /** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */
 const CLSThresholds = [.1, .25];
 /**
@@ -1344,7 +1525,7 @@ const onCLS = (onReport, opts = {}) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/polyfills/interactionCountPolyfill.ts
+//#region src/tracing/vitals/webvitals/lib/polyfills/interactionCountPolyfill.ts
 let interactionCountEstimate = 0;
 let minKnownInteractionId = Infinity;
 let maxKnownInteractionId = 0;
@@ -1372,7 +1553,7 @@ const initInteractionCountPolyfill = () => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/InteractionManager.ts
+//#region src/tracing/vitals/webvitals/lib/InteractionManager.ts
 const MAX_INTERACTIONS_TO_CONSIDER = 10;
 let prevInteractionCount = 0;
 /**
@@ -1452,7 +1633,7 @@ var InteractionManager = class {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/whenIdleOrHidden.ts
+//#region src/tracing/vitals/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.
@@ -1481,7 +1662,7 @@ const whenIdleOrHidden = (cb) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/onINP.ts
+//#region src/tracing/vitals/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;
@@ -1572,7 +1753,7 @@ const onINP = (onReport, opts = {}) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/lib/LCPEntryManager.ts
+//#region src/tracing/vitals/webvitals/lib/LCPEntryManager.ts
 var LCPEntryManager = class {
 	_onBeforeProcessingEntry;
 	_softNavigationEntryMap;
@@ -1582,7 +1763,7 @@ var LCPEntryManager = class {
 };
 
 //#endregion
-//#region src/tracing/webvitals/onLCP.ts
+//#region src/tracing/vitals/webvitals/onLCP.ts
 /** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */
 const LCPThresholds = [2500, 4e3];
 /**
@@ -1692,7 +1873,7 @@ const onLCP = (onReport, opts = {}) => {
 };
 
 //#endregion
-//#region src/tracing/webvitals/onTTFB.ts
+//#region src/tracing/vitals/webvitals/onTTFB.ts
 /** Thresholds for TTFB. See https://web.dev/articles/ttfb#what_is_a_good_ttfb_score */
 const TTFBThresholds = [800, 1800];
 /**
@@ -1753,7 +1934,7 @@ const onTTFB = (onReport, opts = {}) => {
 };
 
 //#endregion
-//#region src/tracing/webVitals.ts
+//#region src/tracing/vitals/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
@@ -1829,57 +2010,230 @@ function record(name, metric) {
 	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.
+* 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/roots/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/roots/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 stopWebVitals() {
-	recording = false;
-	collected = {};
+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 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.
+* 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 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;
+function pageloadStartNano() {
+	const perf = navigationTiming();
+	if (!perf) return defaultNowNano();
+	return computePageloadStartNano(perf.timeOrigin, navigationEntry(perf)?.startTime);
 }
-/** 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;
+function computePageloadEndNano(timeOriginMs, loadEventEndMs, domContentLoadedEventEndMs, nowNano) {
+	const endMs = loadEventEndMs || domContentLoadedEventEndMs || 0;
+	if (!endMs) return nowNano;
+	return Math.round((timeOriginMs + endMs) * 1e6);
 }
 /**
-* 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.
+* 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 restoreWebVitals(vitals) {
-	collected = vitals;
-	taken = false;
+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/browserTracing.ts
+//#region src/tracing/roots/browserTracing.ts
 let controller = null;
 let uninstall = null;
-let lastPath = "";
+let removeNavigationSubscription = null;
 let pageloadTraced = false;
-let navSource = null;
 let activeFlare = null;
 let currentRoot = null;
 let pendingRouteName = null;
@@ -1931,12 +2285,12 @@ function startRoot(flare, options) {
 			setTimeout: (fn, ms) => setTimeout(fn, ms),
 			clearTimeout: (handle) => clearTimeout(handle),
 			rootStartTime: startTimeUnixNano,
-			endFloor: spanType === BrowserSpanType.Pageload && backdated ? pageloadEndNano : () => startTimeUnixNano,
+			endFloor: spanType === BrowserSpanType$1.Pageload && backdated ? pageloadEndNano : () => startTimeUnixNano,
 			held: hold,
-			beforeEnd: spanType === BrowserSpanType.Pageload ? () => stampEarlyVitals(root, flare) : void 0
+			beforeEnd: spanType === BrowserSpanType$1.Pageload ? () => stampEarlyVitals(root, flare) : void 0
 		}, resolveTimeouts(flare.config));
 		currentRoot = root;
-		if (spanType === BrowserSpanType.Pageload) {
+		if (spanType === BrowserSpanType$1.Pageload) {
 			pageloadRoot = root;
 			pageloadRootStartNano = startTimeUnixNano;
 			pageloadRoute = {
@@ -1948,7 +2302,7 @@ function startRoot(flare, options) {
 	} catch (error) {
 		controller = null;
 		currentRoot = null;
-		if (spanType === BrowserSpanType.Pageload) {
+		if (spanType === BrowserSpanType$1.Pageload) {
 			pageloadRoot = null;
 			pageloadRootStartNano = 0;
 			pageloadRoute = null;
@@ -1963,16 +2317,14 @@ function startRoot(flare, options) {
 		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;
+function openNavigationRoot(flare, opts) {
 	withLiveController((live) => live.endNow());
 	startRoot(flare, {
-		spanType: BrowserSpanType.Navigation,
+		spanType: BrowserSpanType$1.Navigation,
 		startTimeUnixNano: defaultNowNano(),
-		name: path
+		name: opts.path,
+		urlOverride: opts.url,
+		hold: opts.hold
 	});
 }
 /**
@@ -2023,7 +2375,7 @@ function emitWebVitals(flare) {
 		flare.startSpan(planned.name, {
 			parent: root,
 			forceRoot: true,
-			spanType: BrowserSpanType.WebVital,
+			spanType: BrowserSpanType$1.WebVital,
 			startTimeUnixNano: planned.startTimeUnixNano,
 			attributes: planned.attributes
 		}).end(planned.endTimeUnixNano);
@@ -2037,13 +2389,26 @@ function startBrowserTracing(flare) {
 	if (typeof window === "undefined" || typeof history === "undefined" || typeof location === "undefined") return;
 	if (uninstall) return;
 	activeFlare = flare;
-	lastPath = location.pathname;
+	removeNavigationSubscription = subscribeToNavigation({
+		onUrlChanged: (path) => openNavigationRoot(flare, { path }),
+		onNavigationStart: (opts) => openNavigationRoot(flare, opts),
+		onRouteName: (route, owner) => applyRouteName(route, owner),
+		onNavigationSettle: (route, owner) => {
+			applyRouteName(route, owner);
+			withLiveController((live) => live.releaseHold());
+		},
+		onSourceUnregistered: () => {
+			withLiveController((live) => live.releaseHold());
+			pendingRouteName = null;
+			pendingRouteNameOwner = null;
+		}
+	});
 	const finalTimeoutNano = resolveTimeouts(flare.config).finalTimeout * 1e6;
 	const navigationStart = pageloadStartNano();
 	const pageloadStart = resolvePageloadStartNano(navigationStart, defaultNowNano(), finalTimeoutNano, pageloadTraced);
 	pageloadTraced = true;
 	startRoot(flare, {
-		spanType: BrowserSpanType.Pageload,
+		spanType: BrowserSpanType$1.Pageload,
 		startTimeUnixNano: pageloadStart,
 		backdated: pageloadStart === navigationStart
 	});
@@ -2053,26 +2418,8 @@ function startBrowserTracing(flare) {
 		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;
-		};
+		if (isActiveNavigationSource(owner)) applyRouteName(route);
 	}
-	fill(history, "pushState", wrapHistoryMethod);
-	fill(history, "replaceState", wrapHistoryMethod);
-	window.addEventListener("popstate", handle);
 	function endRootAndFlush() {
 		if (controller && !controller.isEnded) try {
 			controller.endNow();
@@ -2093,9 +2440,6 @@ function startBrowserTracing(flare) {
 	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);
 	};
@@ -2108,11 +2452,12 @@ function stopBrowserTracing() {
 		uninstall();
 		uninstall = null;
 	}
+	removeNavigationSubscription?.();
+	removeNavigationSubscription = null;
 	activeFlare = null;
 	currentRoot = null;
 	pendingRouteName = null;
 	pendingRouteNameOwner = null;
-	lastPath = "";
 	stopWebVitals();
 	pageloadRoot = null;
 	pageloadRootStartNano = 0;
@@ -2163,54 +2508,70 @@ function applyRouteName(route, owner) {
 		...urlAttrs
 	};
 }
+function activeTracingFlare() {
+	return activeFlare;
+}
+
+//#endregion
+//#region src/tracing/roots/componentProfiler.ts
+/** Unix nanos on the same clock the tracer uses for span timestamps. */
+const nowNano = defaultNowNano;
 /**
-* 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.
+* 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 registerNavigationSource() {
-	const token = {};
-	if (navSource && activeFlare?.config.debug) console.debug("Flare: navigation source replaced");
-	navSource = token;
-	function active() {
-		return navSource === token;
+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;
 	}
-	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;
+/**
+* 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$1.Component,
+			startTimeUnixNano: record.startTimeUnixNano,
+			attributes: {
+				...record.attributes,
+				"flare.component.name": record.name
+			},
+			claimed: true
+		}).end(record.endTimeUnixNano);
+	} catch {}
 }
 
 //#endregion
@@ -2277,66 +2638,4 @@ function catchWindowErrors() {
 }
 
 //#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 };
+export { currentHref as C, absoluteHref as D, routeName as E, absoluteUrl as O, registerNavigationSource as S, resolveHref as T, BrowserFlushScheduler as _, recordComponentSpan as a, browserUrlContext as b, startBrowserTracing as c, instrumentOnce as d, insulate as f, collectBrowser as g, FetchFileReader as h, nowNano as i, stopBrowserTracing as l, CLIENT_VERSION as m, createFlareResolver as n, reserveSpanId as o, safeInvoke as p, activeComponentRoot as r, resolveComponentParent as s, catchWindowErrors as t, BrowserSpanType$1 as u, startBreadcrumbs as v, currentPath as w, withRequestPatches as x, traceRequests as y };