@flareapp/js 2.10.0 → 2.12.0

package/dist/{catchWindowErrors-zf246a2G.cjs → catchWindowErrors-BWKVBTkt.cjs}

@@ -73,10 +73,11 @@ var FormChangeRecorder = class {
 //#endregion
 //#region src/tracing/utils/absoluteHref.ts
 /**
-* Resolve a router-reported href against the page we are on. Returns the `URL`, so a caller that
-* wants the pathname as well as the href does not parse it a second time.
+* Resolves a router-reported href against the current page. Returns the `URL`, so a caller that also
+* wants the pathname does not have to parse it again.
 *
-* Undefined outside a browser or for an unparseable href, so the caller can leave its attribute alone.
+* Returns undefined outside a browser or for an unparseable href, so the caller can leave its
+* attribute alone.
 */
 function absoluteUrl(href) {
 	if (href == null || typeof window === "undefined") return;
@@ -87,9 +88,9 @@ function absoluteUrl(href) {
 	}
 }
 /**
-* 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.
+* The href form of `absoluteUrl`. Pass a value built by the router's own `createHref`/`resolve`, not
+* a bare path — routers strip the app's base path, so `origin + path` gives an address the server
+* does not have.
 */
 function absoluteHref(href) {
 	return absoluteUrl(href)?.href;
@@ -100,9 +101,14 @@ function absoluteHref(href) {
 function currentPath() {
 	return typeof location !== "undefined" ? location.pathname : "";
 }
+/** The whole address, query string included. */
 function currentHref() {
 	return typeof location !== "undefined" ? location.href : "";
 }
+/**
+* Prefers the router's route template (`/product/:id`) over the raw path, so all urls of one route
+* group together. If `derive` throws, the fallback path is used instead of breaking the app.
+*/
 function routeName(derive, fallbackPath, url) {
 	try {
 		const name = derive();
@@ -119,9 +125,9 @@ function routeName(derive, fallbackPath, url) {
 	};
 }
 /**
-* `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`.
+* `build` is the router's own href builder (vue-router `resolve`, React Router `createHref`). It restores
+* the app's base path and hash prefix, so an app served from `/app/` reports `/app/product/p01` instead
+* of `/product/p01`. Falls back to `fallbackHref` if `build` throws.
 */
 function resolveHref(build, fallbackHref) {
 	let href = fallbackHref;
@@ -133,12 +139,6 @@ function resolveHref(build, fallbackHref) {
 
 //#endregion
 //#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.
-* Ported from Sentry's `fill` (packages/core/src/utils/object.ts), minus the
-* prototype/own-property copying we do not need for `fetch`.
-*/
 function fill(source, name, replacer) {
 	const original = source[name];
 	if (typeof original !== "function") return;
@@ -152,7 +152,6 @@ function fill(source, name, replacer) {
 	});
 	source[name] = wrapped;
 }
-/** Restore a previously `fill`ed property to its original. Safe if never filled. */
 function unfill(source, name) {
 	const current = source[name];
 	if (current && current.__flare_original__) source[name] = current.__flare_original__;
@@ -262,7 +261,6 @@ function registerNavigationSource() {
 		}
 	};
 }
-/** A name from an earlier call is only valid while that source is still registered. */
 function isActiveNavigationSource(token) {
 	return token !== null && source === token;
 }
@@ -331,12 +329,6 @@ How to fix: use one Flare instance, and check your bundle for two copies of @fla
 function hasRequestSubscribers() {
 	return subscribers.size > 0 || mutator !== null;
 }
-/**
-* 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 publishRequestStart(start) {
 	const handlers = [];
 	for (const subscriber of subscribers) try {
@@ -367,17 +359,7 @@ function publishRequestStart(start) {
 
 //#endregion
 //#region src/tracing/requests/internalRequest.ts
-/**
-* Marks a request the SDK makes for its own bookkeeping (right now: fetching a source file so a
-* stack frame can show a code snippet). The fetch patch passes those straight through: they are
-* not the app's traffic, so tracing them puts a span in the customer's waterfall for a request
-* their code never made, and propagating a `traceparent` on them is just as wrong.
-*
-* Flare's ingest calls are excluded by URL instead (`isFlareIngestUrl`), because their endpoints
-* are known up front. A snippet fetch targets the customer's own asset, so only the caller knows.
-*/
 const INTERNAL_REQUEST_KEY = "__flare_internal_request__";
-/** An init that marks the request as Flare's own. Unknown init keys are ignored by `fetch`. */
 function internalRequestInit(init) {
 	return {
 		...init,
@@ -390,16 +372,9 @@ function isInternalRequest(init) {
 
 //#endregion
 //#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));
 }
-/**
-* Whether the current global `fetch` is native. A polyfilled fetch (e.g. whatwg-fetch) is
-* XHR-backed; skip instrumenting it so the XHR patch is the single source for those requests.
-* Ported from Sentry, including the hidden-iframe fallback used when another library has already
-* wrapped `fetch` and the direct toString check is unreliable.
-*/
 function supportsNativeFetch() {
 	const globals = globalThis;
 	if (typeof globals.fetch !== "function") return false;
@@ -427,10 +402,6 @@ function supportsNativeFetch() {
 
 //#endregion
 //#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 = [];
@@ -638,12 +609,6 @@ function unpatchXHR() {
 //#endregion
 //#region src/instrumentation/requests/requestPatches.ts
 let subscriptions = 0;
-/**
-* Keeps fetch and XHR patched while at least one subscriber lives. Counted, so turning tracing off
-* cannot remove a patch that breadcrumbs still need.
-*
-* @param subscribe registers one subscriber and returns its own teardown
-*/
 function withRequestPatches(subscribe) {
 	if (subscriptions === 0) {
 		instrumentFetch();
@@ -666,7 +631,6 @@ function withRequestPatches(subscribe) {
 
 //#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;
@@ -674,8 +638,6 @@ function shouldPropagate(url, absoluteUrl, currentOrigin, targets) {
 	}
 	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 = [];
@@ -690,16 +652,9 @@ function headerPairsFrom(source) {
 		return null;
 	}
 }
-/** Fetch accepts any iterable of string pairs as HeadersInit (Map, URLSearchParams, cross-realm Headers). */
 function isIterable(value) {
 	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.iterator] === "function";
 }
-/**
-* A new `RequestInit` carrying `traceparent`, without mutating the caller's `Request` or `init`.
-* Caller-wins: a `traceparent` the caller already set is left alone, matching XHR's
-* `hasAppTraceparent` skip. Returning an init rather than a rebuilt `Request` keeps the caller's
-* single-shot body intact.
-*/
 function mergeTraceparentHeader(input, init, traceparent) {
 	const source = init?.headers ?? (typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0);
 	let headers;
@@ -739,7 +694,6 @@ const REQUEST_SPAN_TYPES = {
 	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 {
@@ -747,7 +701,6 @@ function browserUrlContext() {
 		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);
@@ -775,20 +728,10 @@ function matchesIngestHref(href, ingestHref) {
 	const next = href.charAt(ingestHref.length);
 	return next === "" || next === "/" || next === "?" || next === "#";
 }
-/**
-* True when `resolved` targets one of Flare's own ingest endpoints (never traced). The configured
-* URLs are resolved against `base` first: a relative one (a customer proxying ingest through their
-* own origin) would otherwise never match, so every flush POST would open a span that arms the next
-* flush, forever.
-*/
 function isFlareIngestUrl(resolved, config, base) {
 	if (!resolved) return false;
 	return resolvedIngestHrefs(config, base).some((ingestHref) => matchesIngestHref(resolved.href, ingestHref));
 }
-/**
-* Shared request-span attributes for a fetch/XHR call. The `url.*` attributes are redacted the same
-* way as error reports, so tokens and reset codes never leak.
-*/
 function requestSpanAttributes(method, resolved, url, config) {
 	return {
 		"http.request.method": method,
@@ -797,12 +740,6 @@ function requestSpanAttributes(method, resolved, url, config) {
 		...resolved && resolved.port ? { "server.port": Number(resolved.port) } : {}
 	};
 }
-/**
-* Completion mapping shared by fetch and XHR: record the status and mark an error on 5xx.
-* `zeroIsError` additionally maps status 0 to error. XHR passes it only for http(s), where status
-* 0 at DONE is always a network/CORS failure or abort; file:// and custom schemes return 0 on
-* success, so it isn't set there. Fetch never passes it (an opaque no-cors response is 0, not error).
-*/
 function endHttpRequestSpan(span, status, opts) {
 	span.setAttribute("http.response.status_code", status);
 	if (status >= 500 || opts?.zeroIsError && status === 0) span.setStatus({ code: _flareapp_core.SpanStatusCode.Error });
@@ -815,21 +752,10 @@ function finishHttpSpanError(span, error) {
 	});
 	span.end();
 }
-/**
-* Propagation gate plus `traceparent` build shared by fetch and XHR. Returns null when
-* `shouldPropagate` rejects the URL (caller then skips header injection).
-*/
 function traceparentFor(span, resolved, url, origin, config) {
 	if (!shouldPropagate(resolved ? resolved.href : url, resolved, origin, config.tracePropagationTargets)) return null;
 	return (0, _flareapp_core.buildTraceparent)(span.traceId, span.spanId, span.isRecording);
 }
-/**
-* Open a request span for one outgoing fetch or XHR call. Null means the URL is one of Flare's own
-* ingest endpoints, so the caller passes the request through untraced.
-*
-* `absoluteUrl` comes back with the span because both callers need it afterwards: for the traceparent
-* gate, and for XHR's http(s)-only status-0 rule.
-*/
 function startHttpRequestSpan(tracer, request) {
 	const { method, url, urls, spanType } = request;
 	const config = tracer.config;
@@ -849,12 +775,6 @@ function startHttpRequestSpan(tracer, request) {
 
 //#endregion
 //#region src/tracing/requests/traceRequests.ts
-/**
-* 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.
-*/
 function zeroIsError(absoluteUrl) {
 	return absoluteUrl !== null && (absoluteUrl.protocol === "http:" || absoluteUrl.protocol === "https:");
 }
@@ -865,7 +785,6 @@ function propagate(span, absoluteUrl, start, urls, tracer) {
 	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;
@@ -941,7 +860,6 @@ var RequestRecorder = class {
 
 //#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 = [
@@ -975,10 +893,6 @@ var BrowserFlushScheduler = class {
 
 //#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);
@@ -995,13 +909,86 @@ function cookie(denylist) {
 	return { "http.request.cookies": cookies };
 }
 
+//#endregion
+//#region src/browser/context/deviceReaders.ts
+const EFFECTIVE_TYPES = [
+	"slow-2g",
+	"2g",
+	"3g",
+	"4g"
+];
+function readScreen() {
+	if (typeof screen === "undefined" || typeof screen.width !== "number" || typeof screen.height !== "number") return null;
+	const scale = typeof devicePixelRatio === "number" ? devicePixelRatio : void 0;
+	return scale != null ? {
+		width: screen.width,
+		height: screen.height,
+		scale
+	} : {
+		width: screen.width,
+		height: screen.height
+	};
+}
+function readNetwork(nav) {
+	const network = {};
+	if (typeof nav.onLine === "boolean") network.online = nav.onLine;
+	const connection = nav.connection;
+	if (connection) {
+		const { effectiveType, downlink, rtt } = connection;
+		if (effectiveType && EFFECTIVE_TYPES.includes(effectiveType)) network.effectiveType = effectiveType;
+		if (typeof downlink === "number") network.downlinkMbps = downlink;
+		if (typeof rtt === "number") network.rttMs = rtt;
+	}
+	return Object.keys(network).length > 0 ? network : null;
+}
+function readTimezone() {
+	try {
+		return Intl.DateTimeFormat().resolvedOptions().timeZone || void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/browser/context/deviceInfo.ts
+var BrowserDeviceInfoProvider = class {
+	staticInfo = null;
+	collect() {
+		if (typeof window === "undefined" || typeof navigator === "undefined") return {};
+		const nav = navigator;
+		const info = {};
+		const staticInfo = this.readStatic(nav);
+		const screen = readScreen();
+		const device = {
+			...staticInfo.device,
+			...screen ? { screen } : {}
+		};
+		if (Object.keys(device).length > 0) info.device = device;
+		if (staticInfo.locale) info.locale = staticInfo.locale;
+		const network = readNetwork(nav);
+		if (network) info.network = network;
+		return info;
+	}
+	readStatic(nav) {
+		if (this.staticInfo) return this.staticInfo;
+		const device = {};
+		if (typeof nav.deviceMemory === "number") device.memoryGb = nav.deviceMemory;
+		if (typeof nav.hardwareConcurrency === "number") device.cpuCores = nav.hardwareConcurrency;
+		const locale = {};
+		if (nav.language) locale.language = nav.language;
+		const timezone = readTimezone();
+		if (timezone) locale.timezone = timezone;
+		this.staticInfo = {
+			device: Object.keys(device).length > 0 ? device : void 0,
+			locale: Object.keys(locale).length > 0 ? locale : void 0
+		};
+		return this.staticInfo;
+	}
+};
+const browserDeviceInfoProvider = new BrowserDeviceInfoProvider();
+
 //#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),
@@ -1030,6 +1017,7 @@ function browserEntryPoint(config, urlOverride) {
 }
 const collectBrowser = (config) => {
 	const attrs = { ...browserEntryPoint(config) };
+	Object.assign(attrs, (0, _flareapp_core.deviceInfoToAttributes)(browserDeviceInfoProvider.collect()));
 	if (typeof window === "undefined") return attrs;
 	if (window?.location?.hostname) attrs["host.name"] = window.location.hostname;
 	Object.assign(attrs, request(config.urlDenylist));
@@ -1056,7 +1044,7 @@ var FetchFileReader = class {
 
 //#endregion
 //#region src/env/index.ts
-const CLIENT_VERSION = typeof process !== "undefined" && true ? "2.10.0" : "?";
+const CLIENT_VERSION = typeof process !== "undefined" && true ? "2.12.0" : "?";
 
 //#endregion
 //#region src/tracing/utils/instrumentationGuard.ts
@@ -1076,16 +1064,16 @@ function safeInvoke(fn) {
 }
 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
+* Instruments `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 would add another listener set that is never removed. Keyed on the object, so a 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.
+* `install` hands each teardown to `track` as it produces it. A router's `subscribe`/`on`/guard call
+* can throw during the host's bootstrap, so a throw part-way through unwinds what already succeeded
+* (newest first) instead of reaching the host.
 *
-* @returns the cleanup, or a no-op when the install failed and already unwound itself.
+* @returns The cleanup function, or a no-op if install failed and already unwound itself.
 */
 function instrumentOnce(target, install) {
 	instrumented.get(target)?.();
@@ -1111,15 +1099,6 @@ function instrumentOnce(target, install) {
 
 //#endregion
 //#region src/browser/context/collectBrowserSpanContext.ts
-/**
-* Entry point plus request identity for a pageload/navigation root. Deliberately leaner than the report
-* context: no cookies, no structured query params, no host.name (that is resource-level). Captured at
-* span start, so a long-lived root reflects the page it represents rather than the page at close.
-*
-* @param hrefOverride destination href for a router that reports where it is going before the URL
-* commits. Only the URL-derived keys come from it; the rest always reflect the live document. An
-* unparseable override falls back to the live location instead of throwing into root creation.
-*/
 function collectBrowserSpanContext(config, hrefOverride) {
 	if (typeof window === "undefined") return {};
 	const url = absoluteUrl(hrefOverride);
@@ -1128,16 +1107,6 @@ function collectBrowserSpanContext(config, hrefOverride) {
 		...request(config.urlDenylist, url?.href)
 	};
 }
-/**
-* Updates a root's url after a redirect, or when a newer navigation replaces this one. The root opened
-* with the first destination, so without this it reports a page the user never reached.
-*
-* Does not touch `flare.entry_point.handler.identifier` or `http.route`. Those hold the route template,
-* and reading them back from the href would turn `/product/[id]` into `/product/p01`.
-*
-* Always sets `url.query`, even to an empty string. You can overwrite a span attribute but not remove
-* it, so going from `/a?x=1` to `/b` would otherwise keep the old query.
-*/
 function browserSpanUrlAttributes(config, href) {
 	if (typeof window === "undefined") return {};
 	const resolved = absoluteUrl(href);
@@ -1935,28 +1904,12 @@ const onTTFB = (onReport, opts = {}) => {
 
 //#endregion
 //#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
-* the later span disagreeing about the same vital.
-*/
 const EARLY_VITALS = ["ttfb", "fcp"];
-/** The one place a vital becomes a wire key. Both the pageload stamp and the late span go through it. */
 function vitalAttributes(vitals) {
 	const attributes = {};
 	for (const [name, value] of Object.entries(vitals)) if (typeof value === "number") attributes[`browser.web_vital.${name}`] = value;
 	return attributes;
 }
-/**
-* Turns the leftover values into one zero-duration span. Pure on purpose: the shape is what the backend
-* groups on, and this way it is testable without a tracer or a clock.
-*
-* Both timestamps sit at the pageload root's start. `spans_2` buckets on `start_time_unix_nano`, so
-* stamping the report moment would drop a tab left open for forty minutes into a minute forty minutes
-* after the page actually loaded.
-*
-* Returns null when nothing is left to report, so the caller emits no span at all.
-*/
 function buildVitalsSpan(input) {
 	const vitals = vitalAttributes(input.vitals);
 	if (Object.keys(vitals).length === 0) return null;
@@ -1986,10 +1939,6 @@ function defaultSubscribers() {
 		onINP: (cb) => onINP(cb, { reportAllChanges: true })
 	};
 }
-/**
-* Subscribes at most once per document: upstream's on* functions return no unsubscribe handle, so a
-* second call would attach a second set of observers with no way to detach either.
-*/
 function startWebVitals(subscribers = defaultSubscribers()) {
 	recording = true;
 	if (subscribed) return;
@@ -2009,21 +1958,10 @@ function record(name, metric) {
 	if (!recording || typeof metric?.value !== "number") return;
 	collected[name] = metric.value;
 }
-/**
-* Stops recording and drops what was collected. The observers themselves cannot be detached, and both
-* the `subscribed` and `taken` latches deliberately survive: clearing `subscribed` would let a re-enable
-* attach a second set of observers that is just as undetachable as the first, and clearing `taken` would
-* let those surviving observers refill `collected` and ship a second `browser_web_vital` for the same
-* document once the page is re-enabled and later hidden.
-*/
 function stopWebVitals() {
 	recording = false;
 	collected = {};
 }
-/**
-* The vitals that are already final when the pageload root closes, removed from `collected` so the late
-* span cannot report them a second time. Naturally idempotent: a second call finds the keys gone.
-*/
 function takeEarlyVitals() {
 	if (!recording) return null;
 	const taking = {};
@@ -2036,7 +1974,6 @@ function takeEarlyVitals() {
 	}
 	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;
@@ -2044,29 +1981,76 @@ function takeWebVitals() {
 	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/componentSelfTime.ts
+/**
+* Only a parent that never records leaves an entry behind: an async child that registers after its
+* parent already shipped. The normal path frees every entry the moment the parent records, so this
+* cap is a backstop, not a working limit.
+*/
+const MAX_TRACKED_PARENTS = 256;
+const childIntervals = /* @__PURE__ */ new Map();
+/** Files a recorded child under its parent, so the parent can subtract it. */
+function trackChildInterval(parentSpanId, startTimeUnixNano, endTimeUnixNano) {
+	const existing = childIntervals.get(parentSpanId);
+	if (existing) {
+		existing.push([startTimeUnixNano, endTimeUnixNano]);
+		return;
+	}
+	(0, _flareapp_core.evictLruIfNew)(childIntervals, parentSpanId, MAX_TRACKED_PARENTS);
+	childIntervals.set(parentSpanId, [[startTimeUnixNano, endTimeUnixNano]]);
+}
+/**
+* Duration minus the time the component's own children already account for, and consumes those
+* children. Grandchildren need no handling: they sit inside a child's interval.
+*
+* Children that record after their parent are not subtracted, so the value is self time at commit.
+* That covers async components and `<Suspense>`, and a vue-router layout too: the initial route
+* resolves after the layout mounted, so the page component's work falls outside the layout's window
+* and the layout keeps its full duration.
+*/
+function takeSelfTime(spanId, startTimeUnixNano, endTimeUnixNano) {
+	const children = childIntervals.get(spanId);
+	childIntervals.delete(spanId);
+	const duration = endTimeUnixNano - startTimeUnixNano;
+	if (!children) return Math.max(0, duration);
+	return Math.max(0, duration - coveredTime(children, startTimeUnixNano, endTimeUnixNano));
+}
+function resetComponentSelfTime() {
+	childIntervals.clear();
+}
+/**
+* The union of the intervals, clamped to the parent window. A sum would double-count: React starts
+* every component during render and ends them all during commit, so siblings overlap, and summing
+* their durations exceeds the parent's own.
+*/
+function coveredTime(intervals, start, end) {
+	intervals.sort((a, b) => a[0] - b[0]);
+	let covered = 0;
+	let cursor = start;
+	for (const [childStart, childEnd] of intervals) {
+		const from = Math.max(childStart, cursor);
+		const to = Math.min(childEnd, end);
+		if (to > from) {
+			covered += to - from;
+			cursor = to;
+		}
+	}
+	return covered;
+}
+
 //#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;
@@ -2091,17 +2075,9 @@ var IdleRootController = class {
 	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;
@@ -2138,8 +2114,6 @@ var IdleRootController = class {
 			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);
 	}
@@ -2177,21 +2151,14 @@ var IdleRootController = class {
 
 //#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 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;
@@ -2200,10 +2167,6 @@ function navigationTiming() {
 function navigationEntry(perf) {
 	return perf.getEntriesByType("navigation")[0];
 }
-/**
-* The pageload root's start time in unix nanoseconds, backdated to navigation start via the
-* Navigation Timing entry. Falls back to the tracer's clock when the API is unavailable.
-*/
 function pageloadStartNano() {
 	const perf = navigationTiming();
 	if (!perf) return (0, _flareapp_core.defaultNowNano)();
@@ -2214,13 +2177,6 @@ function computePageloadEndNano(timeOriginMs, loadEventEndMs, domContentLoadedEv
 	if (!endMs) return nowNano;
 	return Math.round((timeOriginMs + endMs) * 1e6);
 }
-/**
-* The pageload root's end time in unix nanoseconds, taken from the Navigation
-* Timing `loadEventEnd` (the browser's own "page finished loading" mark), falling
-* back to `domContentLoadedEventEnd`, then the tracer's clock when neither has
-* fired yet or the API is unavailable. Used as the pageload root's close floor so a
-* childless pageload reports its real load duration rather than idle-timeout padding.
-*/
 function pageloadEndNano() {
 	const perf = navigationTiming();
 	if (!perf) return (0, _flareapp_core.defaultNowNano)();
@@ -2249,8 +2205,6 @@ function resolveTimeouts(config) {
 		childSpanTimeout: config.childSpanTimeout ?? DEFAULT_IDLE_TIMEOUTS.childSpanTimeout
 	};
 }
-/** No-ops once the controller has ended: it can close itself asynchronously via a timer, before this
-*  module's `controller` reference is cleared. */
 function withLiveController(fn) {
 	if (!controller || controller.isEnded) return;
 	try {
@@ -2259,13 +2213,13 @@ function withLiveController(fn) {
 		if (activeFlare?.config.debug) console.error("Flare: browser tracing controller callback failed", error);
 	}
 }
-/** Run `fn` only while the current root is still open. Swallows a throw, like `withLiveController`. */
 function ifRootLive(fn) {
 	withLiveController(() => fn());
 }
 function startRoot(flare, options) {
 	const { spanType, startTimeUnixNano, name = location.pathname, urlOverride, hold, backdated } = options;
 	let root;
+	resetComponentSelfTime();
 	try {
 		const context = collectBrowserSpanContext(flare.config, urlOverride);
 		root = flare.startSpan(name, {
@@ -2327,14 +2281,6 @@ function openNavigationRoot(flare, opts) {
 		hold: opts.hold
 	});
 }
-/**
-* Writes the already-final vitals onto the pageload root itself, from `IdleRootController`'s beforeEnd
-* hook. Whatever has not reported yet stays in `collected` and rides the later `browser_web_vital`
-* span instead, so no vital is ever sent twice and none is lost.
-*
-* Swallows its own failures: this runs inside the root's close path, and a throw here would leave the
-* root open forever.
-*/
 function stampEarlyVitals(root, flare) {
 	try {
 		const early = takeEarlyVitals();
@@ -2344,19 +2290,6 @@ function stampEarlyVitals(root, flare) {
 		if (flare.config.debug) console.error("Flare: failed to stamp web vitals on the pageload root", error);
 	}
 }
-/**
-* Emits whatever the pageload root could not carry as one zero-duration `browser_web_vital` span,
-* parented to that root. Page hide only, and once per document.
-*
-* Deliberately NOT on navigation: LCP, CLS and INP keep moving all document long, so emitting at the
-* first route change froze them a second after load, and a session whose first action was a nav click
-* reported no INP at all. One span per document is a backend constraint, so the emit waits for the last
-* moment we get instead. The cost is a page whose hide event never fires reports no vitals.
-*
-* `pageloadRoot` has usually ended by now; reading `traceId` and `spanId` off an ended span is fine,
-* and passing the `Span` rather than a `{ traceId, spanId }` pair is what makes sampling inherit:
-* `resolveTrace()` reads `parent.isRecording` instead of re-rolling the sampler.
-*/
 function emitWebVitals(flare) {
 	const root = pageloadRoot;
 	const route = pageloadRoute;
@@ -2384,7 +2317,6 @@ function emitWebVitals(flare) {
 		if (flare.config.debug) console.error("Flare: failed to emit web vitals", error);
 	}
 }
-/** Opens a backdated pageload root, then a navigation root per History change. No-op outside a browser. Idempotent. */
 function startBrowserTracing(flare) {
 	if (typeof window === "undefined" || typeof history === "undefined" || typeof location === "undefined") return;
 	if (uninstall) return;
@@ -2444,7 +2376,6 @@ function startBrowserTracing(flare) {
 		document.removeEventListener("visibilitychange", onVisibilityChange);
 	};
 }
-/** Idempotent. */
 function stopBrowserTracing() {
 	withLiveController((live) => live.endNow());
 	controller = null;
@@ -2459,15 +2390,12 @@ function stopBrowserTracing() {
 	pendingRouteName = null;
 	pendingRouteNameOwner = null;
 	stopWebVitals();
+	resetComponentSelfTime();
 	pageloadRoot = null;
 	pageloadRootStartNano = 0;
 	pageloadRoute = null;
 	pageloadContext = {};
 }
-/**
-* Computes the url attributes a route rename carries, or null when there is nothing to add. Guarded
-* so the pin below (which runs outside ifRootLive's own try/catch) cannot throw into the host.
-*/
 function urlAttributesFor(route) {
 	if (route.url === void 0 || !activeFlare) return null;
 	try {
@@ -2476,12 +2404,6 @@ function urlAttributesFor(route) {
 		return null;
 	}
 }
-/**
-* Rename the current root and update the attributes that go with the name, and pin the pageload's route
-* for the vitals emit. No-op once it closed; the pin is NOT gated the same way, see below.
-* With no root yet the name is held for the pageload root that opens next, rather than dropped.
-* `owner` stamps who is holding it, so a stale or superseded source cannot land its name later.
-*/
 function applyRouteName(route, owner) {
 	const root = currentRoot;
 	if (!root) {
@@ -2517,8 +2439,8 @@ function activeTracingFlare() {
 /** 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.
+* Reserved up front so descendants can point at a span before it is recorded. Null when the trace
+* is at its span cap, since descendants record before this span does and would be orphaned.
 */
 function reserveSpanId(traceId) {
 	if (traceId !== void 0 && !activeTracingFlare()?.tracer.claimSpanSlot(traceId)) return null;
@@ -2538,18 +2460,18 @@ function activeComponentRoot() {
 	}
 }
 /**
-* 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.
+* An ancestor's context is only usable while it still belongs to the live trace. A component that
+* survives a navigation (a layout around a swapped page body) froze its context under the old
+* 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.
+* Records only while the reserved root is still the live recording root, and drops the span
+* otherwise. Dropping avoids re-running the sampler for a dead trace and avoids adding a child to
+* a root that already shipped.
 */
 function recordComponentSpan(record) {
 	try {
@@ -2557,6 +2479,7 @@ function recordComponentSpan(record) {
 		if (!flare) return;
 		const root = flare.tracer.getActiveSpan();
 		if (!root || root.traceId !== record.parent.traceId || !root.isRecording) return;
+		const selfTime = takeSelfTime(record.spanId, record.startTimeUnixNano, record.endTimeUnixNano);
 		flare.startSpan(record.name, {
 			spanId: record.spanId,
 			parent: {
@@ -2567,19 +2490,17 @@ function recordComponentSpan(record) {
 			startTimeUnixNano: record.startTimeUnixNano,
 			attributes: {
 				...record.attributes,
-				"flare.component.name": record.name
+				"flare.component.name": record.name,
+				"flare.component.self_time_ns": selfTime
 			},
 			claimed: true
 		}).end(record.endTimeUnixNano);
+		trackChildInterval(record.parent.parentSpanId, record.startTimeUnixNano, record.endTimeUnixNano);
 	} catch {}
 }
 
 //#endregion
 //#region src/createFlareResolver.ts
-/**
-* `process.env.NODE_ENV` is replaced inline by bundlers. The try/catch keeps a process-less
-* environment safe: treat "undetermined" as production (warn, never crash).
-*/
 function isDevMode() {
 	try {
 		return process.env.NODE_ENV !== "production";
@@ -2588,11 +2509,10 @@ function isDevMode() {
 	}
 }
 /**
-* Builds a per-package Flare resolver: `registerDefaultFlare` (wired once by the web entry) and
-* `resolveFlare` (called at wiring time). Each call holds its own default-provider state. The check
-* that warns about the Electron `__flare` bridge uses `packageName` in its message;
-* `injectInstruction` replaces the closing hint for packages whose advice differs (for example
-* svelte, which points at the preprocessor's importSource).
+* Builds a per-package Flare resolver: `registerDefaultFlare` (set once by the web entry) and
+* `resolveFlare` (called at wiring time). Each call keeps its own default-provider state.
+* `packageName` names the package in the Electron-bridge warning; `injectInstruction` overrides the
+* closing hint for packages with different advice (for example Svelte's preprocessor importSource).
 */
 function createFlareResolver(config) {
 	const { packageName } = config;