@flareapp/js 2.8.0 → 2.9.0

package/dist/{componentProfiler-C6qY96Bt.cjs → catchWindowErrors-cR2D7kju.cjs}

@@ -1,126 +1,138 @@
 let _flareapp_core = require("@flareapp/core");
 
-//#region src/browser/BrowserFlushScheduler.ts
-var BrowserFlushScheduler = class {
-	register(flush) {
-		if (typeof document === "undefined" || !document) return;
-		document.addEventListener("visibilitychange", () => {
-			if (document.visibilityState === "hidden") flush({ keepalive: true });
-		});
-		if (typeof window !== "undefined" && window) window.addEventListener("pagehide", () => flush({ keepalive: true }));
-	}
-};
+//#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 {
-		...(0, _flareapp_core.urlAttributes)(hrefOverride ?? window.location.href, urlDenylist),
-		"user_agent.original": window.navigator.userAgent,
-		"http.request.referrer": (0, _flareapp_core.redactUrlQuery)(window.document.referrer, urlDenylist),
-		"document.ready_state": window.document.readyState
-	};
-}
+//#region src/breadcrumbs/ClickRecorder.ts
+var ClickRecorder = class {
+	type = _flareapp_core.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)), (0, _flareapp_core.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"] = (0, _flareapp_core.redactUrlQuery)(href, config.urlDenylist);
-		const pathname = urlOverride ? urlOverride.pathname : window?.location?.pathname;
-		if (pathname) {
-			attrs["flare.entry_point.handler.identifier"] = pathname;
-			attrs["http.route"] = pathname;
-			attrs["flare.entry_point.handler.type"] = "browser";
-		}
+//#region src/breadcrumbs/FormChangeRecorder.ts
+var FormChangeRecorder = class {
+	type = _flareapp_core.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), (0, _flareapp_core.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 = _flareapp_core.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, (0, _flareapp_core.defaultNowNano)());
+	}
+	clean(href) {
+		return (0, _flareapp_core.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,
-		...(0, _flareapp_core.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: _flareapp_core.SpanStatusCode.Error });
-	span.end();
-}
-function finishHttpSpanError(span, error) {
-	span.setStatus({
-		code: _flareapp_core.SpanStatusCode.Error,
-		message: error instanceof Error ? error.message : String(error)
-	});
-	span.end();
-}
-/**
-* Propagation gate plus `traceparent` build shared by fetch and XHR. Returns null when
-* `shouldPropagate` rejects the URL (caller then skips header injection).
-*/
-function traceparentFor(span, resolved, url, origin, config) {
-	if (!shouldPropagate(resolved ? resolved.href : url, resolved, origin, config.tracePropagationTargets)) return null;
-	return (0, _flareapp_core.buildTraceparent)(span.traceId, span.spanId, span.isRecording);
-}
-/**
-* Open a request span for one outgoing fetch or XHR call. Null means the URL is one of Flare's own
-* ingest endpoints, so the caller passes the request through untraced.
+* 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: _flareapp_core.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: _flareapp_core.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: _flareapp_core.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: _flareapp_core.BrowserSpanType.Fetch,
+	xhr: _flareapp_core.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,
+		...(0, _flareapp_core.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: _flareapp_core.SpanStatusCode.Error });
+	span.end();
+}
+function finishHttpSpanError(span, error) {
+	span.setStatus({
+		code: _flareapp_core.SpanStatusCode.Error,
+		message: error instanceof Error ? error.message : String(error)
+	});
+	span.end();
+}
+/**
+* Propagation gate plus `traceparent` build shared by fetch and XHR. Returns null when
+* `shouldPropagate` rejects the URL (caller then skips header injection).
+*/
+function traceparentFor(span, resolved, url, origin, config) {
+	if (!shouldPropagate(resolved ? resolved.href : url, resolved, origin, config.tracePropagationTargets)) return null;
+	return (0, _flareapp_core.buildTraceparent)(span.traceId, span.spanId, span.isRecording);
+}
+/**
+* Open a request span for one outgoing fetch or XHR call. Null means the URL is one of Flare's own
+* ingest endpoints, so the caller passes the request through untraced.
 *
-* 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 = (0, _flareapp_core.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: _flareapp_core.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": (0, _flareapp_core.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, (0, _flareapp_core.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 {
+		...(0, _flareapp_core.urlAttributes)(hrefOverride ?? window.location.href, urlDenylist),
+		"user_agent.original": window.navigator.userAgent,
+		"http.request.referrer": (0, _flareapp_core.redactUrlQuery)(window.document.referrer, urlDenylist),
+		"document.ready_state": window.document.readyState
+	};
+}
+
+//#endregion
+//#region src/browser/context/collectBrowser.ts
+function browserEntryPoint(config, urlOverride) {
+	if (typeof window === "undefined") return { "flare.entry_point.type": "web" };
+	const attrs = { "flare.entry_point.type": "web" };
+	const href = urlOverride ? urlOverride.href : window?.location?.href;
+	if (href) {
+		attrs["flare.entry_point.value"] = (0, _flareapp_core.redactUrlQuery)(href, config.urlDenylist);
+		const pathname = urlOverride ? urlOverride.pathname : window?.location?.pathname;
+		if (pathname) {
+			attrs["flare.entry_point.handler.identifier"] = pathname;
+			attrs["http.route"] = pathname;
+			attrs["flare.entry_point.handler.type"] = "browser";
 		}
-		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 (0, _flareapp_core.defaultNowNano)();
-	return computePageloadStartNano(perf.timeOrigin, navigationEntry(perf)?.startTime);
-}
-function computePageloadEndNano(timeOriginMs, loadEventEndMs, domContentLoadedEventEndMs, nowNano) {
-	const endMs = loadEventEndMs || domContentLoadedEventEndMs || 0;
-	if (!endMs) return nowNano;
-	return Math.round((timeOriginMs + endMs) * 1e6);
+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 (0, _flareapp_core.defaultNowNano)();
-	const entry = navigationEntry(perf);
-	return computePageloadEndNano(perf.timeOrigin, entry?.loadEventEnd, entry?.domContentLoadedEventEnd, (0, _flareapp_core.defaultNowNano)());
+function browserSpanUrlAttributes(config, href) {
+	if (typeof window === "undefined") return {};
+	const resolved = absoluteUrl(href);
+	if (!resolved) return {};
+	const attributes = (0, _flareapp_core.urlAttributes)(resolved.href, config.urlDenylist);
+	return {
+		"url.query": "",
+		...attributes,
+		"flare.entry_point.value": attributes["url.full"]
+	};
 }
 
 //#endregion
-//#region src/tracing/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 (0, _flareapp_core.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 (0, _flareapp_core.defaultNowNano)();
+	const entry = navigationEntry(perf);
+	return computePageloadEndNano(perf.timeOrigin, entry?.loadEventEnd, entry?.domContentLoadedEventEnd, (0, _flareapp_core.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;
@@ -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: _flareapp_core.BrowserSpanType.Navigation,
 		startTimeUnixNano: (0, _flareapp_core.defaultNowNano)(),
-		name: path
+		name: opts.path,
+		urlOverride: opts.url,
+		hold: opts.hold
 	});
 }
 /**
@@ -2037,7 +2389,20 @@ 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, (0, _flareapp_core.defaultNowNano)(), finalTimeoutNano, pageloadTraced);
@@ -2053,26 +2418,8 @@ function startBrowserTracing(flare) {
 		const owner = pendingRouteNameOwner;
 		pendingRouteName = null;
 		pendingRouteNameOwner = null;
-		if (owner === navSource) applyRouteName(route);
+		if (isActiveNavigationSource(owner)) applyRouteName(route);
 	}
-	const handle = () => {
-		if (!uninstall) return;
-		try {
-			onUrlChanged(flare);
-		} catch (error) {
-			if (flare.config.debug) console.error("Flare: browser tracing navigation handler failed", error);
-		}
-	};
-	function wrapHistoryMethod(original) {
-		return function(...args) {
-			const result = original.apply(this, args);
-			handle();
-			return result;
-		};
-	}
-	fill(history, "pushState", wrapHistoryMethod);
-	fill(history, "replaceState", wrapHistoryMethod);
-	window.addEventListener("popstate", handle);
 	function endRootAndFlush() {
 		if (controller && !controller.isEnded) try {
 			controller.endNow();
@@ -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 = _flareapp_core.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 (0, _flareapp_core.spanId)();
+}
+/** The root a top-level component nests under. Null when tracing is off or no root is recording. */
+function activeComponentRoot() {
+	try {
+		const root = activeTracingFlare()?.tracer.getActiveSpan();
+		if (!root || !root.isRecording) return null;
+		return {
+			traceId: root.traceId,
+			parentSpanId: root.spanId
+		};
+	} catch {
+		return null;
 	}
-	return {
-		startNavigation(opts) {
-			if (!active() || !activeFlare) return;
-			const path = opts?.path ?? currentPath();
-			lastPath = path;
-			withLiveController((live) => live.endNow());
-			startRoot(activeFlare, {
-				spanType: _flareapp_core.BrowserSpanType.Navigation,
-				startTimeUnixNano: (0, _flareapp_core.defaultNowNano)(),
-				name: path,
-				urlOverride: opts?.url,
-				hold: opts?.hold
-			});
-		},
-		setActiveRouteName(route) {
-			if (!active()) return;
-			applyRouteName(route, token);
-		},
-		settleNavigation(route) {
-			if (!active()) return;
-			applyRouteName(route, token);
-			withLiveController((live) => live.releaseHold());
-		},
-		unregister() {
-			if (!active()) return;
-			withLiveController((live) => live.releaseHold());
-			navSource = null;
-			lastPath = currentPath();
-			pendingRouteName = null;
-			pendingRouteNameOwner = null;
-		}
-	};
 }
-/** For sibling tracing modules (the component-profiler seam) that need the live tracer. */
-function activeTracingFlare() {
-	return activeFlare;
+/**
+* An ancestor's context is only usable while it still belongs to the live trace. A profiled component
+* that survives a navigation (a layout around a swapped page body) froze its context under the pageload
+* trace, and `recordComponentSpan` would drop anything pointing at that closed root.
+*/
+function resolveComponentParent(inherited, live) {
+	if (inherited && live && inherited.traceId === live.traceId) return inherited;
+	return live;
+}
+/**
+* Records only while the reserved root is still the live recording root, and drops the span otherwise.
+* Dropping avoids starting a fresh TraceState for a dead trace, which would re-run the sampler, and
+* avoids adding a child to a root that already shipped.
+*/
+function recordComponentSpan(record) {
+	try {
+		const flare = activeTracingFlare();
+		if (!flare) return;
+		const root = flare.tracer.getActiveSpan();
+		if (!root || root.traceId !== record.parent.traceId || !root.isRecording) return;
+		flare.startSpan(record.name, {
+			spanId: record.spanId,
+			parent: {
+				traceId: record.parent.traceId,
+				spanId: record.parent.parentSpanId
+			},
+			spanType: _flareapp_core.BrowserSpanType.Component,
+			startTimeUnixNano: record.startTimeUnixNano,
+			attributes: {
+				...record.attributes,
+				"flare.component.name": record.name
+			},
+			claimed: true
+		}).end(record.endTimeUnixNano);
+	} catch {}
 }
 
 //#endregion
@@ -2276,68 +2637,6 @@ function catchWindowErrors() {
 	});
 }
 
-//#endregion
-//#region src/tracing/componentProfiler.ts
-/** Unix nanos on the same clock the tracer uses for span timestamps. */
-const nowNano = _flareapp_core.defaultNowNano;
-/**
-* Reserved up front so descendants can point at a span before it is recorded. Null when the trace is at
-* its span cap: descendants record before this span does, so an id the cap will refuse orphans them.
-*/
-function reserveSpanId(traceId) {
-	if (traceId !== void 0 && !activeTracingFlare()?.tracer.claimSpanSlot(traceId)) return null;
-	return (0, _flareapp_core.spanId)();
-}
-/** The root a top-level component nests under. Null when tracing is off or no root is recording. */
-function activeComponentRoot() {
-	try {
-		const root = activeTracingFlare()?.tracer.getActiveSpan();
-		if (!root || !root.isRecording) return null;
-		return {
-			traceId: root.traceId,
-			parentSpanId: root.spanId
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* An ancestor's context is only usable while it still belongs to the live trace. A profiled component
-* that survives a navigation (a layout around a swapped page body) froze its context under the pageload
-* trace, and `recordComponentSpan` would drop anything pointing at that closed root.
-*/
-function resolveComponentParent(inherited, live) {
-	if (inherited && live && inherited.traceId === live.traceId) return inherited;
-	return live;
-}
-/**
-* Records only while the reserved root is still the live recording root, and drops the span otherwise.
-* Dropping avoids starting a fresh TraceState for a dead trace, which would re-run the sampler, and
-* avoids adding a child to a root that already shipped.
-*/
-function recordComponentSpan(record) {
-	try {
-		const flare = activeTracingFlare();
-		if (!flare) return;
-		const root = flare.tracer.getActiveSpan();
-		if (!root || root.traceId !== record.parent.traceId || !root.isRecording) return;
-		flare.startSpan(record.name, {
-			spanId: record.spanId,
-			parent: {
-				traceId: record.parent.traceId,
-				spanId: record.parent.parentSpanId
-			},
-			spanType: _flareapp_core.BrowserSpanType.Component,
-			startTimeUnixNano: record.startTimeUnixNano,
-			attributes: {
-				...record.attributes,
-				"flare.component.name": record.name
-			},
-			claimed: true
-		}).end(record.endTimeUnixNano);
-	} catch {}
-}
-
 //#endregion
 Object.defineProperty(exports, 'BrowserFlushScheduler', {
   enumerable: true,
@@ -2375,6 +2674,12 @@ Object.defineProperty(exports, 'activeComponentRoot', {
     return activeComponentRoot;
   }
 });
+Object.defineProperty(exports, 'browserUrlContext', {
+  enumerable: true,
+  get: function () {
+    return browserUrlContext;
+  }
+});
 Object.defineProperty(exports, 'catchWindowErrors', {
   enumerable: true,
   get: function () {
@@ -2393,16 +2698,16 @@ Object.defineProperty(exports, 'createFlareResolver', {
     return createFlareResolver;
   }
 });
-Object.defineProperty(exports, 'currentPath', {
+Object.defineProperty(exports, 'currentHref', {
   enumerable: true,
   get: function () {
-    return currentPath;
+    return currentHref;
   }
 });
-Object.defineProperty(exports, 'instrumentFetch', {
+Object.defineProperty(exports, 'currentPath', {
   enumerable: true,
   get: function () {
-    return instrumentFetch;
+    return currentPath;
   }
 });
 Object.defineProperty(exports, 'instrumentOnce', {
@@ -2411,12 +2716,6 @@ Object.defineProperty(exports, 'instrumentOnce', {
     return instrumentOnce;
   }
 });
-Object.defineProperty(exports, 'instrumentXHR', {
-  enumerable: true,
-  get: function () {
-    return instrumentXHR;
-  }
-});
 Object.defineProperty(exports, 'insulate', {
   enumerable: true,
   get: function () {
@@ -2471,6 +2770,12 @@ Object.defineProperty(exports, 'safeInvoke', {
     return safeInvoke;
   }
 });
+Object.defineProperty(exports, 'startBreadcrumbs', {
+  enumerable: true,
+  get: function () {
+    return startBreadcrumbs;
+  }
+});
 Object.defineProperty(exports, 'startBrowserTracing', {
   enumerable: true,
   get: function () {
@@ -2483,15 +2788,15 @@ Object.defineProperty(exports, 'stopBrowserTracing', {
     return stopBrowserTracing;
   }
 });
-Object.defineProperty(exports, 'unpatchFetch', {
+Object.defineProperty(exports, 'traceRequests', {
   enumerable: true,
   get: function () {
-    return unpatchFetch;
+    return traceRequests;
   }
 });
-Object.defineProperty(exports, 'unpatchXHR', {
+Object.defineProperty(exports, 'withRequestPatches', {
   enumerable: true,
   get: function () {
-    return unpatchXHR;
+    return withRequestPatches;
   }
 });