@ogygia/core 0.0.0 → 0.11.0

package/dist/runtime/beacon.js

@@ -0,0 +1,2190 @@
+import { hole_copy_of } from "./hash.js";
+import { tool_made } from "../tool-fetches.js";
+import { paint_blocker } from "./render-blocking.js";
+import { critical_outcome } from "./load-scheduler.js";
+import { devtools_switched_on } from "../insights/switch.js";
+import { charge, metered } from "./own-cost.js";
+// src/runtime/beacon.ts
+/**
+* THE BEACON — the browser's half of the profiler. When the document carries
+* `<meta name="ogygia-profiler-beacon" content="/__profiler/beacon">` (the profiler puts it there
+* for its own logged-in user, never for a visitor), this records what the browser saw of the page
+* and hands it over twice: to the server (so a report on a long-lived host can join it) and to
+* this browser's own IndexedDB (so a report on an ephemeral host, whose instance is gone before
+* the report is opened, still gets it — the profiler UI on the same origin reads it back).
+*
+* What it records: each island's wake (trigger → modules loaded → `data-hydrated`, and whether the
+* markup changed on the way), the app's own `mark()` timings, the web vitals, the whole VISIT —
+* navigation timing, every resource with bytes and blocking status, paints with the island the
+* largest paint sat in, long tasks, the first interaction per island, layout shifts with the
+* island they hit — the islands' markup before and after hydration (browser store only), and a
+* CPU trace of hydration where the browser allows one.
+*
+* Cost when the tag is absent: one `querySelector` on the first hydration, then a boolean. Nothing
+* here runs on the hydration path itself: samples are batched and sent on idle or when the page
+* hides.
+*/
+let target;
+let queue = [];
+let scheduled = false;
+let listening = false;
+let marks = [];
+const BEACON_KEY = Symbol.for("ogygia.beacon");
+let self_api;
+/** the page's owning copy when it is not this one, else null */
+function owner() {
+	self_api ??= {
+		beacon_mark,
+		beacon_failed,
+		beacon_hydrated,
+		beacon_watch,
+		beacon_record_cpu,
+		beacon_page,
+		beacon_warning,
+		beacon_hole_failed,
+		beacon_hole_answered,
+		beacon_hole_batch_missed,
+		beacon_entry_fallback,
+		beacon_hole_fetched,
+		beacon_nav
+	};
+	const g = globalThis;
+	const o = g[BEACON_KEY] ??= self_api;
+	return o === self_api ? null : o;
+}
+if (typeof document !== "undefined") owner();
+function beacon_mark(name, ms, attrs, t0) {
+	const o = owner();
+	if (o) return o.beacon_mark(name, ms, attrs, t0);
+	if (!collecting() || !name) return;
+	if (visit_marks.length >= 400) return;
+	if (endpoint() && marks.length < 400) marks.push({
+		name: String(name).slice(0, 120),
+		ms: Math.max(0, Math.round(ms * 100) / 100),
+		...t0 !== void 0 ? { t0: Math.round(t0 * 100) / 100 } : {},
+		...attrs ? { attrs } : {}
+	});
+	visit_marks.push({
+		name: String(name).slice(0, 120),
+		ms: Math.max(0, Math.round(ms * 100) / 100),
+		...t0 !== void 0 ? { t0: Math.round(t0 * 100) / 100 } : {}
+	});
+	schedule();
+}
+let vitals = null;
+let vitals_sent = false;
+const ISLAND_SEL = "ogygia-region[data-og-fp]";
+const r2 = (n) => Math.round(n * 100) / 100;
+let visit_islands = [];
+let visit_firsts = [];
+/** the last inputs, any target (a ring): which island something touched while it hydrated */
+const recent_inputs = [];
+/** `name="value"` pairs of one start tag (`<a href="x" hidden>`), as the browser serializes them. */
+function tag_attrs(tag) {
+	const out = /* @__PURE__ */ new Map();
+	let i = 1;
+	while (i < tag.length && tag[i] !== " " && tag[i] !== ">" && tag[i] !== "/") i++;
+	while (i < tag.length) {
+		while (i < tag.length && (tag[i] === " " || tag[i] === "\n" || tag[i] === "	" || tag[i] === "/")) i++;
+		if (i >= tag.length || tag[i] === ">") break;
+		const start = i;
+		while (i < tag.length && tag[i] !== "=" && tag[i] !== " " && tag[i] !== ">") i++;
+		const name = tag.slice(start, i);
+		let value = "";
+		if (tag[i] === "=") {
+			i++;
+			const q = tag[i];
+			if (q === "\"" || q === "'") {
+				const end = tag.indexOf(q, i + 1);
+				value = tag.slice(i + 1, end === -1 ? tag.length : end);
+				i = end === -1 ? tag.length : end + 1;
+			} else {
+				const s = i;
+				while (i < tag.length && tag[i] !== " " && tag[i] !== ">") i++;
+				value = tag.slice(s, i);
+			}
+		}
+		if (name) out.set(name, value);
+	}
+	return out;
+}
+/** The tag's name, lowercase (`<qds-button …>` → `qds-button`). */
+function tag_name(tag) {
+	let i = 1;
+	while (i < tag.length && tag[i] !== " " && tag[i] !== ">" && tag[i] !== "/" && tag[i] !== "\n") i++;
+	return tag.slice(1, i).toLowerCase();
+}
+/**
+* When two markups (comments out) differ ONLY in attributes — the same elements in the same order, the
+* same text — each attribute that differs (at most 20); `null` when text or elements differ. A walk of
+* both strings tag by tag, no regex: it runs once per changed island.
+*/
+function attr_changes(a, b) {
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length || j < b.length) {
+		const ti = a.indexOf("<", i);
+		const tj = b.indexOf("<", j);
+		if (a.slice(i, ti === -1 ? a.length : ti) !== b.slice(j, tj === -1 ? b.length : tj)) return null;
+		if (ti === -1 || tj === -1) return ti === tj ? out : null;
+		const ei = a.indexOf(">", ti);
+		const ej = b.indexOf(">", tj);
+		const x = a.slice(ti, ei === -1 ? a.length : ei + 1);
+		const y = b.slice(tj, ej === -1 ? b.length : ej + 1);
+		i = ti + x.length;
+		j = tj + y.length;
+		if (x === y) continue;
+		const tag = tag_name(x);
+		if (tag !== tag_name(y) || x[1] === "/" || y[1] === "/") return null;
+		const xa = tag_attrs(x);
+		const ya = tag_attrs(y);
+		for (const [name, v] of xa) if (ya.get(name) !== v && out.length < 20) out.push({
+			tag,
+			name,
+			from: v,
+			to: ya.has(name) ? ya.get(name) : null
+		});
+		for (const [name, v] of ya) if (!xa.has(name) && out.length < 20) out.push({
+			tag,
+			name,
+			from: null,
+			to: v
+		});
+	}
+	return out;
+}
+let visit_shifts = [];
+let visit_longtasks = [];
+/** the long tasks are frames drawn late (a browser with no long-task timing): see watch_frame_gaps */
+let longtasks_from_frames = false;
+/** main-thread ms per script URL (query off), from long animation frames */
+let visit_scripts = /* @__PURE__ */ new Map();
+/** scripts that forced style and layout (5 ms or more), each with its window on the page's clock */
+let visit_forced = [];
+/** long frames (50 ms or more) that began while the page scrolled, with their two biggest scripts */
+let visit_scroll_jank = [];
+/** when the page scrolled lately (at most one stamp per 50 ms, the last 200): the long frames are
+*  delivered after the fact, so each is matched to the scrolls around its own start */
+let scroll_times = [];
+const scrolled_near = (t) => scroll_times.some((s) => s >= t - 150 && s <= t + 50);
+let visit_interaction = null;
+/** the slowest interaction's id and its span so far (its entries arrive one by one) */
+let visit_interaction_id = 0;
+let visit_interaction_span = null;
+let visit_frames = [];
+const MAX_FRAMES = 40;
+/** Svelte's hydration warnings (dev): the server and the browser disagreed, Svelte kept the server's */
+let visit_warnings = [];
+function beacon_warning(w) {
+	const o = owner();
+	if (o) return o.beacon_warning(w);
+	if (!collecting()) return;
+	if (!make_room(visit_warnings, 50, (x) => x.t)) return;
+	visit_warnings.push(w);
+	if (early_visit_done) resend_soon();
+}
+let visit_holes_failed = [];
+function beacon_hole_failed(h) {
+	const o = owner();
+	if (o) return o.beacon_hole_failed(h);
+	if (!collecting() || visit_holes_failed.length >= 30 || visit_holes_failed.some((x) => x.id === h.id)) return;
+	visit_holes_failed.push(h);
+	if (early_visit_done) resend_soon();
+}
+const FONT_EXT = /* @__PURE__ */ new Set([
+	"woff",
+	"woff2",
+	"ttf",
+	"otf"
+]);
+const IMG_EXT = /* @__PURE__ */ new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"avif",
+	"svg"
+]);
+const LINK_AS = {
+	style: "css",
+	script: "script",
+	font: "font",
+	image: "img",
+	fetch: "fetch"
+};
+/**
+* A file's type, for the byte counts and the lanes: its extension first, then the `<link>` that
+* fetched it (`as`), then what started it. A `link` initiator is NOT a stylesheet by itself: a
+* `<link rel=preload>` fetches whatever its `as` says — a hole's preload fetches HTML, from a URL
+* with no extension, and every first-screen hole answer landed in the CSS column (and One clock's
+* CSS lane). (Chromium reports a modulepreload's initiator as `other`; its `.js` decides anyway.)
+*/
+function resource_type(ext, initiator, link_as) {
+	if (FONT_EXT.has(ext)) return "font";
+	if (ext === "css") return "css";
+	if (ext === "js" || ext === "mjs") return "script";
+	if (IMG_EXT.has(ext)) return "img";
+	if (initiator === "link") return link_as && LINK_AS[link_as] || (link_as ? "other" : "css");
+	if (initiator === "css") return "css";
+	if (initiator === "script") return "script";
+	if (initiator === "img") return "img";
+	if (initiator === "fetch" || initiator === "xmlhttprequest" || initiator === "beacon") return "fetch";
+	return "other";
+}
+let visit_hole_batches = [];
+/** The restorer's log (runtime/restore.ts `__og_restore_log`): its late and mismatched hosts. */
+function restore_log() {
+	const log = globalThis.__og_restore_log;
+	return log?.length ? { restores: log.slice(0, 20) } : {};
+}
+function beacon_hole_batch_missed(m) {
+	const o = owner();
+	if (o) return o.beacon_hole_batch_missed?.(m);
+	if (!collecting() || visit_hole_batches.length >= 10) return;
+	const ids = [];
+	for (const e of m.endpoints.slice(0, 32)) try {
+		ids.push(new URL(e, location.href).searchParams.get("id") ?? "");
+	} catch {
+		ids.push("");
+	}
+	visit_hole_batches.push({
+		sent: m.sent,
+		delivered: m.delivered,
+		status: m.status,
+		...m.refused ? { refused: m.refused } : {},
+		...m.final_url ? { final_url: m.final_url.slice(0, 300) } : {},
+		ids
+	});
+	if (early_visit_done) resend_soon();
+}
+/** The browser's timing of the request that answered a hole: the latest one for its URL done by
+*  `by` (the swap). It may predate the runtime (the document preloads first-screen holes). `left`
+*  is when it went on the wire (`requestStart`: after any wait for a connection), not when it was
+*  asked for. Null when the resource buffer has none (full, or no Resource Timing). */
+function hole_request_times(endpoint, by) {
+	try {
+		const url = new URL(endpoint, location.href).href;
+		let hit;
+		for (const e of performance.getEntriesByName(url, "resource")) if (e.responseStart > 0 && e.responseEnd <= by + 1) hit = e;
+		if (!hit) return null;
+		let queue;
+		let render;
+		for (const s of hit.serverTiming ?? []) if (s.name === "og-queue") queue = Math.round(s.duration);
+		else if (s.name === "og-render") render = Math.round(s.duration);
+		return {
+			left: Math.round(hit.requestStart || hit.startTime),
+			first: Math.round(hit.responseStart),
+			end: Math.round(hit.responseEnd),
+			...queue !== void 0 ? { queue } : {},
+			...render !== void 0 ? { render } : {}
+		};
+	} catch {}
+	return null;
+}
+let visit_holes_answered = [];
+let visit_entry_fallbacks = [];
+function beacon_entry_fallback(f) {
+	const o = owner();
+	if (o) return o.beacon_entry_fallback?.(f);
+	if (!collecting() || visit_entry_fallbacks.length >= 20 || visit_entry_fallbacks.some((x) => x.entry === f.entry)) return;
+	visit_entry_fallbacks.push({
+		entry: f.entry.slice(0, 300),
+		src: f.src.slice(0, 300),
+		recovered: f.recovered
+	});
+	if (early_visit_done) resend_soon();
+}
+/** each hole URL (absolute) → how many times the runtime asked the network for it */
+let hole_fetches = /* @__PURE__ */ new Map();
+/** The runtime asks for a hole's HTML (each ask, retries and re-asks included): what lets a
+*  preload followed by a download read as used-then-asked-again, not as a preload the browser could
+*  not use. */
+function beacon_hole_fetched(endpoint) {
+	const o = owner();
+	if (o) return o.beacon_hole_fetched?.(endpoint);
+	if (!collecting() || hole_fetches.size >= 200) return;
+	try {
+		const url = new URL(endpoint, location.href).href;
+		hole_fetches.set(url, (hole_fetches.get(url) ?? 0) + 1);
+	} catch {}
+}
+let holes_answered_els = /* @__PURE__ */ new WeakSet();
+/** A hole's first answer landed: the profiler weighs how long its fallback held the first screen.
+*  The element is read (id, place) only while measuring. */
+function beacon_hole_answered(el, start, batch) {
+	const o = owner();
+	if (o) return o.beacon_hole_answered?.(el, start, batch);
+	if (!collecting() || visit_holes_answered.length >= 30) return;
+	let id = "";
+	try {
+		id = new URL(el.getAttribute("endpoint") ?? "", location.href).searchParams.get("id") ?? "";
+	} catch {
+		id = "";
+	}
+	if (!id || holes_answered_els.has(el)) return;
+	holes_answered_els.add(el);
+	const rect = el.getBoundingClientRect();
+	const times = batch ? {
+		left: Math.round(batch.left),
+		first: Math.round(batch.at),
+		end: Math.round(batch.at),
+		batch: batch.size
+	} : hole_request_times(el.getAttribute("endpoint") ?? "", performance.now());
+	visit_holes_answered.push({
+		id,
+		n: visit_holes_answered.length,
+		start: Math.round(start),
+		t: Math.round(performance.now()),
+		below_fold: rect.top + scrollY > innerHeight,
+		p: hole_copy_of(el.getAttribute("endpoint") ?? ""),
+		...times
+	});
+	if (early_visit_done) resend_soon();
+}
+let visit_marks = [];
+let visit_paints = {};
+/** the largest paint's element: still in the document when the visit is read, or replaced (an
+*  island that rendered it again put a new one in its place — the hero painted twice). Only while
+*  its island is still there: an in-app navigation away takes both, and replaces nothing */
+let lcp_el = null;
+let lcp_region = null;
+/** an island's markup as the server sent it and after it hydrated — the browser store only */
+let snapshots = [];
+let visit_sent = false;
+const SNAPSHOT_CAP = 24e3;
+const MAX_SNAPSHOTS = 40;
+/** The snapshot of a changed island: whole when both fit, else the window around the change
+*  (`a`, `b`: the two markups without comments, already made for the compare). */
+function snapshot_of(fp, ssr, now, a, b) {
+	if (ssr.length <= SNAPSHOT_CAP && now.length <= SNAPSHOT_CAP) return {
+		fp,
+		ssr,
+		hydrated: now
+	};
+	const n = Math.min(a.length, b.length);
+	let i = 0;
+	while (i < n && a.charCodeAt(i) === b.charCodeAt(i)) i++;
+	let from = Math.max(0, i - SNAPSHOT_CAP / 4);
+	const lt = a.indexOf("<", from);
+	if (lt !== -1 && lt <= i) from = lt;
+	return {
+		fp,
+		ssr: a.slice(from, from + SNAPSHOT_CAP),
+		hydrated: b.slice(from, from + SNAPSHOT_CAP),
+		from
+	};
+}
+const fp_of = (node) => {
+	return (node && node.nodeType === 1 ? node : node && node.nodeType === 3 ? node.parentElement : null)?.closest?.(ISLAND_SEL)?.getAttribute("data-og-fp") ?? void 0;
+};
+/** What was clicked, told briefly: `button "Save"`, `a#home`, `input[name=q]`. No selector engine. */
+function describe_target(node) {
+	const el = node && node.nodeType === 1 ? node : node?.parentElement;
+	if (!el) return "";
+	const tag = el.tagName.toLowerCase();
+	const id = el.id ? `#${el.id.slice(0, 30)}` : "";
+	const name = el.getAttribute("name");
+	const label = el.getAttribute("aria-label") ?? (tag === "input" || tag === "select" || tag === "textarea" ? "" : (el.textContent ?? "").trim().slice(0, 30));
+	return `${tag}${id}${name ? `[name=${name.slice(0, 30)}]` : ""}${label ? ` "${label}"` : ""}`;
+}
+const rect_of = (r) => r ? [
+	Math.round(r.x),
+	Math.round(r.y),
+	Math.round(r.width),
+	Math.round(r.height)
+] : void 0;
+/** every resource entry the observer saw (the browser's own buffer stops at 250 by default) */
+let seen_resources = [];
+const MAX_SEEN_RESOURCES = 3e3;
+/** the files a visit lists one by one (the rest are in its totals by type) */
+const MAX_DETAIL_RESOURCES = 200;
+/** content-named files fetched again, at most (a page's own; the count past it is not worth more) */
+const MAX_REFETCHED = 40;
+/** text files (and the document) 4 KB or more sent without compression; the largest few by name */
+const UNCOMPRESSED_MIN = 4096;
+const MAX_UNCOMPRESSED = 10;
+/** extensions that compress well (text, and wasm), whatever fetched them */
+const TEXT_EXT = /* @__PURE__ */ new Set([
+	"js",
+	"mjs",
+	"css",
+	"html",
+	"htm",
+	"json",
+	"svg",
+	"txt",
+	"xml",
+	"map",
+	"wasm"
+]);
+function observe_vitals() {
+	visit_page();
+	if (vitals || typeof PerformanceObserver === "undefined") return;
+	const v = vitals = {};
+	try {
+		const nav = performance.getEntriesByType("navigation")[0];
+		if (nav && nav.responseStart > 0) v.ttfb = r2(nav.responseStart);
+	} catch {}
+	const observe = (type, cb) => {
+		try {
+			new PerformanceObserver((list) => cb(list.getEntries())).observe({
+				type,
+				buffered: true,
+				...type === "event" ? { durationThreshold: 16 } : {}
+			});
+		} catch {}
+	};
+	observe("paint", (entries) => {
+		for (const e of entries) if (e.name === "first-contentful-paint") v.fcp = visit_paints.fcp = r2(e.startTime);
+	});
+	try {
+		performance.setResourceTimingBufferSize(MAX_SEEN_RESOURCES);
+	} catch {}
+	observe("resource", (entries) => {
+		for (const e of entries) if (seen_resources.length < MAX_SEEN_RESOURCES) seen_resources.push(e);
+	});
+	observe("largest-contentful-paint", (entries) => {
+		const last = entries[entries.length - 1];
+		if (!last) return;
+		v.lcp = visit_paints.lcp = r2(last.startTime);
+		const fp = fp_of(last.element);
+		visit_paints.lcp_fp = fp;
+		visit_paints.lcp_url = last.url || void 0;
+		visit_paints.lcp_tag = last.element?.tagName?.toLowerCase();
+		visit_paints.lcp_lazy = last.element?.getAttribute?.("loading") === "lazy" ? true : void 0;
+		const pri = last.element?.getAttribute?.("fetchpriority");
+		visit_paints.lcp_priority = pri === "high" || pri === "low" ? pri : void 0;
+		lcp_el = last.element ?? null;
+		lcp_region = lcp_el?.closest("ogygia-region") ?? null;
+		if (early_visit_done) resend_soon();
+	});
+	let cls = 0;
+	try {
+		if (PerformanceObserver.supportedEntryTypes?.includes("layout-shift")) v.cls = 0;
+	} catch {}
+	observe("layout-shift", (entries) => {
+		for (const e of entries) {
+			if (e.hadRecentInput || typeof e.value !== "number") continue;
+			cls += e.value;
+			if (make_room(visit_shifts, 60, (s) => s.t)) {
+				const src = e.sources?.[0];
+				const tag = src?.node ? describe_target(src.node) : "";
+				visit_shifts.push({
+					t: r2(e.startTime),
+					value: Math.round(e.value * 1e4) / 1e4,
+					...src?.node ? { fp: fp_of(src.node) } : {},
+					...tag ? { tag } : {},
+					...src?.previousRect ? { from: rect_of(src.previousRect) } : {},
+					...src?.currentRect ? { to: rect_of(src.currentRect) } : {}
+				});
+			}
+		}
+		v.cls = Math.round(cls * 1e3) / 1e3;
+		if (early_visit_done) resend_soon();
+	});
+	observe("event", (entries) => {
+		for (const e of entries) {
+			if (!e.interactionId) continue;
+			const d = r2(e.duration);
+			const same = visit_interaction_id === e.interactionId;
+			if (!same && v.inp !== void 0 && d <= v.inp) continue;
+			if (v.inp === void 0 || d > v.inp) {
+				v.inp = d;
+				resend_soon();
+			}
+			const ps = e.processingStart ?? e.startTime;
+			const pe = e.processingEnd ?? ps;
+			const fold = same ? visit_interaction_span : null;
+			const span = visit_interaction_span = {
+				start: fold ? Math.min(fold.start, e.startTime) : e.startTime,
+				ps: fold ? Math.min(fold.ps, ps) : ps,
+				pe: fold ? Math.max(fold.pe, pe) : pe,
+				end: fold ? Math.max(fold.end, e.startTime + e.duration) : e.startTime + e.duration
+			};
+			visit_interaction_id = e.interactionId;
+			const named = !same || e.name === "click" || e.name === "keydown" ? e : null;
+			const fp = named ? fp_of(e.target) : visit_interaction?.fp;
+			visit_interaction = {
+				name: named ? e.name : visit_interaction.name,
+				t: r2(span.start),
+				ms: r2(span.end - span.start),
+				delay: r2(Math.max(0, span.ps - span.start)),
+				processing: r2(Math.max(0, span.pe - span.ps)),
+				presentation: r2(Math.max(0, span.end - span.pe)),
+				target: named ? describe_target(e.target) || visit_interaction?.target || "" : visit_interaction.target,
+				...fp ? { fp } : {}
+			};
+		}
+		if (visit_interaction) interaction_seen(visit_interaction);
+	});
+	observe("longtask", (entries) => {
+		for (const e of entries) if (make_room(visit_longtasks, 100, (l) => l.t)) visit_longtasks.push({
+			t: r2(e.startTime),
+			ms: r2(e.duration)
+		});
+	});
+	if (!supports("longtask")) watch_frame_gaps();
+	observe("long-animation-frame", (entries) => {
+		for (const e of entries) {
+			if (early_visit_done) resend_soon();
+			if (e.duration >= 50 && scrolled_near(e.startTime) && make_room(visit_scroll_jank, 20, (j) => j.start)) visit_scroll_jank.push({
+				start: r2(e.startTime),
+				ms: r2(e.duration),
+				scripts: (e.scripts ?? []).slice().sort((a, b) => (b.duration ?? 0) - (a.duration ?? 0)).slice(0, 2).map((s) => ({
+					url: (s.sourceURL ?? "").slice(0, 300),
+					fn: (s.sourceFunctionName ?? "").slice(0, 80),
+					invoker: (s.invoker ?? "").slice(0, 120),
+					ms: r2(s.duration ?? 0)
+				}))
+			});
+			for (const s of e.scripts ?? []) if ((s.forcedStyleAndLayoutDuration ?? 0) >= 5 && make_room(visit_forced, 30, (f) => f.start)) {
+				const start = s.startTime ?? e.startTime;
+				visit_forced.push({
+					start: r2(start),
+					end: r2(start + (s.duration ?? 0)),
+					ms: r2(s.forcedStyleAndLayoutDuration ?? 0),
+					url: (s.sourceURL ?? "").slice(0, 300),
+					fn: (s.sourceFunctionName ?? "").slice(0, 80)
+				});
+			}
+			visit_frames.push({
+				start: r2(e.startTime),
+				end: r2(e.startTime + e.duration),
+				scripts: (e.scripts ?? []).slice(0, 8).map((s) => ({
+					url: (s.sourceURL ?? "").slice(0, 300),
+					fn: (s.sourceFunctionName ?? "").slice(0, 80),
+					invoker: (s.invoker ?? "").slice(0, 120),
+					start: r2(s.startTime ?? e.startTime),
+					ms: r2(s.duration ?? 0),
+					...(s.forcedStyleAndLayoutDuration ?? 0) >= 1 ? { forced: r2(s.forcedStyleAndLayoutDuration) } : {}
+				}))
+			});
+			if (visit_frames.length > MAX_FRAMES) visit_frames.shift();
+			for (const s of e.scripts ?? []) {
+				const url = s.sourceURL ?? "";
+				if (!url || !(s.duration && s.duration > 0)) continue;
+				const q = url.indexOf("?");
+				const key = (q === -1 ? url : url.slice(0, q)).slice(0, 300);
+				const cur = visit_scripts.get(key);
+				if (cur) {
+					cur.ms += s.duration;
+					cur.count++;
+				} else if (visit_scripts.size < 100) visit_scripts.set(key, {
+					ms: s.duration,
+					count: 1
+				});
+			}
+		}
+	});
+	const note_input = (type) => (ev) => {
+		if (!(ev.target instanceof Element)) return;
+		recent_inputs.push({
+			t: performance.now(),
+			el: new WeakRef(ev.target),
+			type
+		});
+		if (recent_inputs.length > 64) recent_inputs.shift();
+	};
+	try {
+		for (const type of [
+			"pointerover",
+			"pointerdown",
+			"keydown",
+			"focusin"
+		]) document.addEventListener(type, note_input(type), {
+			capture: true,
+			passive: true
+		});
+	} catch {}
+	const seen = /* @__PURE__ */ new Set();
+	const first = (type) => (ev) => {
+		const fp = fp_of(ev.target);
+		if (!fp || seen.has(fp)) return;
+		seen.add(fp);
+		const at = ev.timeStamp > 0 && ev.timeStamp <= performance.now() ? ev.timeStamp : performance.now();
+		visit_firsts.push({
+			fp,
+			t: r2(at),
+			type
+		});
+	};
+	try {
+		document.addEventListener("pointerdown", first("pointer"), {
+			capture: true,
+			passive: true
+		});
+		document.addEventListener("keydown", first("key"), {
+			capture: true,
+			passive: true
+		});
+		document.addEventListener("scroll", () => {
+			const t = performance.now();
+			if (scroll_times.length && t - scroll_times[scroll_times.length - 1] < 50) return;
+			scroll_times.push(t);
+			if (scroll_times.length > 200) scroll_times.shift();
+		}, {
+			capture: true,
+			passive: true
+		});
+	} catch {}
+}
+/** sendBeacon and a keepalive fetch both refuse a body over 64 KB (UTF-16 length, with room) */
+const KEEPALIVE_MAX = 6e4;
+/** KEEPALIVE BYTES STILL QUEUED. The 64 KB cap is on everything a page has queued at once — every
+*  beacon and keepalive fetch not yet sent — not on each: a hide sends the islands, the vitals, the
+*  visit and the trace together, and Safari refused the rest once they passed it ("reached maximum
+*  amount of queued data"), the visit among them. A keepalive fetch is held until it settles; a
+*  beacon, which says nothing back, for the task that sent it — the burst a hide makes is what
+*  overflows, and one sent a moment earlier (the early visit) has left by then. */
+let keepalive_queued = 0;
+const BEACON_HOLD_MS = 0;
+/** the hide's own sends: the page is going away whatever its visibility reads (a link or a reload
+*  fires pagehide on a page still "visible") */
+let leaving = false;
+function hold_keepalive(bytes, settled) {
+	keepalive_queued += bytes;
+	const release = () => {
+		keepalive_queued = Math.max(0, keepalive_queued - bytes);
+	};
+	if (settled) settled.finally(release);
+	else setTimeout(release, BEACON_HOLD_MS);
+}
+/** what a keepalive request may still carry */
+function keepalive_room() {
+	return KEEPALIVE_MAX - keepalive_queued;
+}
+/** `slim`: the same message without what earlier messages already delivered, for a page going
+*  away with a body too big to leave (the server keeps the longest file list and merges regions).
+*  A page with ~300 islands sent 100 KB: refused by both, and the fetch's rejection went unhandled,
+*  so the profiler never got that page's browser side at all. */
+function send(body, slim) {
+	const url = endpoint();
+	if (!url) return;
+	const post = (b, keepalive) => {
+		try {
+			const settled = fetch(url, {
+				method: "POST",
+				body: b,
+				keepalive,
+				credentials: "same-origin",
+				headers: { "content-type": "text/plain" }
+			}).catch(() => {});
+			if (keepalive) hold_keepalive(b.length, settled);
+		} catch {}
+	};
+	const room = keepalive_room();
+	if (body.length > room) {
+		if (typeof document === "undefined" || !leaving && document.visibilityState === "visible") return post(body, false);
+		const s = slim?.();
+		if (!s || s.length > room) return;
+		body = s;
+	}
+	try {
+		if (typeof navigator !== "undefined" && navigator.sendBeacon && navigator.sendBeacon(url, body)) {
+			hold_keepalive(body.length);
+			return;
+		}
+	} catch {}
+	post(body, true);
+}
+function flush_vitals() {
+	if (vitals_sent || !vitals || !Object.keys(vitals).length) return;
+	vitals_sent = true;
+	send(JSON.stringify({
+		page: visit_page(),
+		at: Math.round(performance.timeOrigin),
+		vitals
+	}));
+}
+/** The navigation's steps before its first byte, each only when it took time (ms). */
+function nav_phases(n) {
+	const p = {};
+	const put = (k, v) => {
+		if (v > .5) p[k] = r2(v);
+	};
+	put("redirect", n.redirectEnd - n.redirectStart);
+	if (n.workerStart > 0) put("worker", n.fetchStart - n.workerStart);
+	put("dns", n.domainLookupEnd - n.domainLookupStart);
+	const tls = n.secureConnectionStart > 0 ? n.connectEnd - n.secureConnectionStart : 0;
+	put("connect", n.connectEnd - n.connectStart - tls);
+	put("tls", tls);
+	put("wait", n.responseStart - n.requestStart);
+	return Object.keys(p).length ? { phases: p } : {};
+}
+/** The slowest interaction with the scripts of the long frames it overlapped, each put in the phase
+*  it started in: `delay` (the input waited behind it), `handler` (it ran the interaction's
+*  handlers), `paint` (after them, before the next frame). The heaviest few. */
+function interaction_with_scripts(i) {
+	const end = i.t + i.ms;
+	const handlers_at = i.t + i.delay;
+	const paint_at = handlers_at + i.processing;
+	const out = [];
+	for (const f of visit_frames) {
+		if (f.end < i.t || f.start > end) continue;
+		for (const s of f.scripts) {
+			if (s.start + s.ms < i.t || s.start > end || !(s.ms > 0)) continue;
+			const phase = s.start < handlers_at ? "delay" : s.start <= paint_at ? "handler" : "paint";
+			out.push({
+				url: s.url,
+				fn: s.fn,
+				invoker: s.invoker,
+				ms: s.ms,
+				phase,
+				...s.forced ? { forced: s.forced } : {}
+			});
+		}
+	}
+	out.sort((a, b) => b.ms - a.ms);
+	return out.length ? {
+		...i,
+		scripts: out.slice(0, 6)
+	} : { ...i };
+}
+let faces_memo = null;
+/** The `@font-face` rules behind the fonts this page fetched: each family, its `font-display`
+*  (`auto` when unset), and the fetched files its `src` names. What says whether a late font left
+*  its text invisible. A cross-origin sheet the browser will not let us read is left out. No regex. */
+function font_faces_of(fetched) {
+	if (!fetched.size) return [];
+	const key = [...fetched].join("\n");
+	if (faces_memo?.key === key) return faces_memo.faces;
+	const out = [];
+	faces_memo = {
+		key,
+		faces: out
+	};
+	for (const sheet of document.styleSheets) {
+		let rules;
+		try {
+			rules = sheet.cssRules;
+		} catch {
+			continue;
+		}
+		for (const rule of rules) {
+			if (out.length >= 12) return out;
+			if (!(rule instanceof CSSFontFaceRule)) continue;
+			const style = rule.style;
+			const src = style.getPropertyValue("src");
+			const urls = [];
+			let at = src.indexOf("url(");
+			while (at !== -1 && urls.length < 6) {
+				const end = src.indexOf(")", at);
+				if (end === -1) break;
+				const raw = src.slice(at + 4, end).trim().split("\"").join("").split("'").join("");
+				try {
+					const url = new URL(raw, sheet.href ?? location.href).href.slice(0, 500);
+					if (fetched.has(url)) urls.push(url);
+				} catch {}
+				at = src.indexOf("url(", end);
+			}
+			if (!urls.length) continue;
+			const family = style.getPropertyValue("font-family").trim().split("\"").join("").split("'").join("").slice(0, 80);
+			out.push({
+				family,
+				display: style.getPropertyValue("font-display").trim() || "auto",
+				urls
+			});
+		}
+	}
+	return out;
+}
+/** IMAGES SENT FAR BIGGER THAN SHOWN: a loaded raster `<img>` whose pixels are at least 4× what
+*  its box shows on this screen (its device pixel ratio counted), and whose file is 50 KB or more —
+*  the bytes past what the box shows are bytes nobody sees. A hidden image (no box), a vector one,
+*  and one whose size the browser will not tell (cross-origin, no Timing-Allow-Origin) are left out.
+*  One layout read per send, at most 300 images. No regex. */
+function oversized_images() {
+	const out = [];
+	const dpr = devicePixelRatio || 1;
+	const imgs = document.images;
+	for (let i = 0; i < imgs.length && i < 300 && out.length < 10; i++) {
+		const img = imgs[i];
+		if (!img.complete || !img.naturalWidth || !img.naturalHeight) continue;
+		const url = img.currentSrc || img.src;
+		if (!url || url.startsWith("data:")) continue;
+		const q = url.indexOf("?");
+		if ((q === -1 ? url : url.slice(0, q)).toLowerCase().endsWith(".svg")) continue;
+		const w = img.clientWidth;
+		const h = img.clientHeight;
+		if (!w || !h) continue;
+		if (img.naturalWidth * img.naturalHeight < w * h * dpr * dpr * 4) continue;
+		const e = performance.getEntriesByName(url, "resource")[0];
+		const bytes = e ? e.encodedBodySize || e.transferSize : 0;
+		if (bytes < 5e4) continue;
+		const fp = fp_of(img);
+		out.push({
+			url: url.slice(0, 500),
+			natural: [img.naturalWidth, img.naturalHeight],
+			shown: [w, h],
+			dpr: r2(dpr),
+			bytes,
+			...fp ? { fp } : {}
+		});
+	}
+	return out;
+}
+/** PRELOADED, NEVER USED: a `<link rel="preload">` of an image, a font or a stylesheet the page
+*  fetched and, 3 s after load (when the browser itself warns), nothing on the page uses — no
+*  `<img>` / `srcset` / CSS rule names the image, no `@font-face` the font, no stylesheet link the
+*  sheet. Its bytes competed with what the first screen needed. A responsive preload
+*  (`imagesrcset`) and anything a cross-origin sheet might use are left out (it cannot be read).
+*  Asked once, after that moment; null before it. No regex. */
+let preloads_memo = null;
+function preloads_never_used(load_end) {
+	if (preloads_memo) return preloads_memo;
+	if (!(load_end > 0) || performance.now() - load_end < 3e3) return null;
+	const out = [];
+	const links = document.querySelectorAll("link[rel=\"preload\"][href][as]");
+	const css = [];
+	let opaque = false;
+	const faces = /* @__PURE__ */ new Set();
+	let sheets_read = false;
+	const read_sheets = () => {
+		if (sheets_read) return;
+		sheets_read = true;
+		for (const sheet of document.styleSheets) {
+			let rules;
+			try {
+				rules = sheet.cssRules;
+			} catch {
+				opaque = true;
+				continue;
+			}
+			for (const rule of rules) if (rule instanceof CSSFontFaceRule) {
+				const src = rule.style.getPropertyValue("src");
+				let at = src.indexOf("url(");
+				while (at !== -1) {
+					const end = src.indexOf(")", at);
+					if (end === -1) break;
+					try {
+						faces.add(new URL(src.slice(at + 4, end).trim().split("\"").join("").split("'").join(""), sheet.href ?? location.href).href);
+					} catch {}
+					at = src.indexOf("url(", end);
+				}
+			} else css.push(rule.cssText);
+		}
+	};
+	for (let i = 0; i < links.length && i < 30; i++) {
+		const l = links[i];
+		const as = l.getAttribute("as") ?? "";
+		if (as !== "image" && as !== "font" && as !== "style" || l.hasAttribute("imagesrcset")) continue;
+		const url = l.href;
+		const e = performance.getEntriesByName(url, "resource")[0];
+		if (!e) continue;
+		let used = false;
+		if (as === "style") {
+			for (const s of document.querySelectorAll("link[rel=\"stylesheet\"][href]")) if (s.href === url) used = true;
+		} else if (as === "image") {
+			for (const img of document.images) if (img.currentSrc === url || img.src === url || img.srcset && img.srcset.includes(l.getAttribute("href") ?? url)) used = true;
+			if (!used) {
+				for (const s of document.querySelectorAll("source[srcset]")) if ((s.getAttribute("srcset") ?? "").includes(l.getAttribute("href") ?? url)) used = true;
+			}
+			if (!used) {
+				read_sheets();
+				const raw = l.getAttribute("href") ?? url;
+				used = opaque || css.some((t) => t.includes(url) || t.includes(raw));
+			}
+		} else {
+			read_sheets();
+			used = opaque || faces.has(url);
+		}
+		if (!used) out.push({
+			url: url.slice(0, 500),
+			as,
+			bytes: e.encodedBodySize || e.transferSize || 0
+		});
+	}
+	preloads_memo = out;
+	return out;
+}
+let dom_memo = null;
+function dom_shape() {
+	const n = document.getElementsByTagName("*").length;
+	if (dom_memo?.n === n) return dom_memo.shape;
+	let shape = null;
+	if (n >= 6e4) shape = {
+		nodes: n,
+		depth: 0,
+		deepest: "",
+		widest: {
+			at: "",
+			children: 0
+		},
+		islands: []
+	};
+	else if (n >= 1500) {
+		const brief = (el) => {
+			let cls = "";
+			for (const c of el.classList) if (!c.startsWith("svelte-")) {
+				cls = c;
+				break;
+			}
+			return `${el.tagName.toLowerCase()}${el.id ? `#${el.id.slice(0, 30)}` : cls ? `.${cls.slice(0, 30)}` : ""}`;
+		};
+		let depth = 0;
+		const root = document.documentElement;
+		let deepest = root;
+		let widest = root;
+		let widest_n = root.childElementCount;
+		let el = root;
+		let d = 1;
+		while (el) {
+			if (d > depth) {
+				depth = d;
+				deepest = el;
+			}
+			const kids = el.childElementCount;
+			if (kids > widest_n) {
+				widest_n = kids;
+				widest = el;
+			}
+			const first = el.firstElementChild;
+			if (first) {
+				el = first;
+				d++;
+				continue;
+			}
+			while (el && el !== root && !el.nextElementSibling) {
+				el = el.parentElement;
+				d--;
+			}
+			el = el && el !== root ? el.nextElementSibling : null;
+		}
+		const islands = [];
+		for (const r of document.querySelectorAll(ISLAND_SEL)) {
+			const fp = r.getAttribute("data-og-fp");
+			if (fp) islands.push({
+				fp,
+				nodes: r.getElementsByTagName("*").length
+			});
+		}
+		islands.sort((a, b) => b.nodes - a.nodes);
+		shape = {
+			nodes: n,
+			depth,
+			deepest: brief(deepest),
+			widest: {
+				at: brief(widest),
+				children: widest_n
+			},
+			islands: islands.slice(0, 3)
+		};
+	}
+	dom_memo = {
+		n,
+		shape
+	};
+	return shape;
+}
+/** IMAGES THE BROWSER COULD NOT HOLD ROOM FOR: an `<img>` with a box whose computed aspect-ratio is
+*  `auto` — no width and height attributes (they make it `auto W / H`) and no CSS aspect-ratio —
+*  so the page below moved when its file arrived. A hidden one (no box, a hidden parent too) is
+*  left out. Their srcs, the first 8. */
+function images_unsized() {
+	const out = [];
+	const imgs = document.images;
+	for (let i = 0; i < imgs.length && i < 300 && out.length < 8; i++) {
+		const img = imgs[i];
+		if (img.hasAttribute("width") && img.hasAttribute("height")) continue;
+		if (!img.getClientRects().length) continue;
+		if (getComputedStyle(img).aspectRatio !== "auto") continue;
+		const src = img.currentSrc || img.src;
+		if (src && !src.startsWith("data:")) out.push(src.slice(0, 300));
+	}
+	return out;
+}
+/** IMAGES FAR BELOW THE FIRST SCREEN THAT LOADED AT START: a raster `<img>` whose top sits more
+*  than a screen and a half down the document, not `loading="lazy"`, its file 20 KB or more, and
+*  fetched before the page's load ended — its bytes competed with the first screen's files. A
+*  hidden image (no box) is left out. Positions are the document's (the scroll added back). */
+function images_eager_below(load_end) {
+	const out = [];
+	const fold = innerHeight * 1.5;
+	const imgs = document.images;
+	for (let i = 0; i < imgs.length && i < 300 && out.length < 10; i++) {
+		const img = imgs[i];
+		if (img.loading === "lazy") continue;
+		const url = img.currentSrc || img.src;
+		if (!url || url.startsWith("data:")) continue;
+		const r = img.getBoundingClientRect();
+		if (!r.width || !r.height) continue;
+		const top = Math.round(r.top + scrollY);
+		if (top < fold) continue;
+		const e = performance.getEntriesByName(url, "resource")[0];
+		if (!e || load_end > 0 && e.startTime > load_end) continue;
+		const bytes = e.encodedBodySize || e.transferSize || 0;
+		if (bytes < 2e4) continue;
+		const fp = fp_of(img);
+		out.push({
+			url: url.slice(0, 500),
+			top,
+			bytes,
+			...fp ? { fp } : {}
+		});
+	}
+	return out;
+}
+/** the visit as one object: the server's copy has no snapshots (they are big and the browser
+*  store keeps them) */
+function build_visit() {
+	return metered("visit", build_visit_now);
+}
+function build_visit_now() {
+	let nav;
+	try {
+		nav = performance.getEntriesByType("navigation")[0];
+	} catch {
+		nav = void 0;
+	}
+	if (!nav || !(nav.responseEnd > 0 || nav.domInteractive > 0)) return null;
+	const start_hidden = !(nav.responseStart > 0);
+	const ext_of = (name) => {
+		const q = name.indexOf("?");
+		const path = q === -1 ? name : name.slice(0, q);
+		const dot = path.lastIndexOf(".");
+		return dot > path.lastIndexOf("/") ? path.slice(dot + 1).toLowerCase() : "";
+	};
+	const link_as = /* @__PURE__ */ new Map();
+	const link_co = /* @__PURE__ */ new Map();
+	try {
+		for (const l of document.querySelectorAll("link[href][as], link[rel=\"modulepreload\"][href]")) {
+			link_as.set(l.href, l.getAttribute("as") ?? "script");
+			link_co.set(l.href, l.getAttribute("crossorigin"));
+		}
+	} catch {}
+	const preload_misses = [];
+	const type_of = (r) => resource_type(ext_of(r.name), r.initiatorType, link_as.get(r.name));
+	let resources = [];
+	const refetched = [];
+	const totals = /* @__PURE__ */ new Map();
+	let all_n = 0;
+	const uncompressed = [];
+	const raw_seen = /* @__PURE__ */ new Set();
+	try {
+		const all = (seen_resources.length ? seen_resources : performance.getEntriesByType("resource")).filter((r) => !r.name.includes("/__profiler/") && !tool_made(r));
+		all_n = all.length;
+		for (const r of all) {
+			const type = type_of(r);
+			const t = totals.get(type) ?? {
+				type,
+				count: 0,
+				transfer: 0,
+				size: 0
+			};
+			t.count++;
+			t.transfer += r.transferSize || 0;
+			t.size += r.decodedBodySize || 0;
+			totals.set(type, t);
+			if (r.decodedBodySize >= UNCOMPRESSED_MIN && r.encodedBodySize >= r.decodedBodySize && !raw_seen.has(r.name) && (type === "script" || type === "style" || TEXT_EXT.has(ext_of(r.name)) || r.initiatorType === "fetch" || r.initiatorType === "xmlhttprequest")) {
+				raw_seen.add(r.name);
+				uncompressed.push({
+					url: r.name.slice(0, 500),
+					type,
+					bytes: r.decodedBodySize
+				});
+			}
+		}
+		uncompressed.sort((a, b) => b.bytes - a.bytes);
+		uncompressed.length = Math.min(uncompressed.length, MAX_UNCOMPRESSED);
+		const by_url = /* @__PURE__ */ new Map();
+		for (const r of all) (by_url.get(r.name) ?? by_url.set(r.name, []).get(r.name)).push(r);
+		for (const [url, list] of by_url) {
+			if (list.length < 2 || preload_misses.length >= 20) continue;
+			const pre = list.find((r) => r.initiatorType === "link");
+			const downloads = list.filter((r) => r !== pre && r.initiatorType !== "link" && r.encodedBodySize > 0 && r.transferSize >= r.encodedBodySize);
+			const again = downloads[0];
+			if ((pre?.responseStatus ?? 0) >= 400) continue;
+			if (downloads.length < (hole_fetches.get(url) ?? 0)) continue;
+			if (pre && again) preload_misses.push({
+				url: url.slice(0, 500),
+				type: type_of(pre),
+				bytes: again.transferSize,
+				as: link_as.get(url) ?? "",
+				crossorigin: link_co.get(url) ?? null,
+				...hole_fetches.has(url) ? { hole: true } : {}
+			});
+		}
+		const reload = nav.type === "reload";
+		const origin = location.origin;
+		const entry_of = /* @__PURE__ */ new Map();
+		for (const el of document.querySelectorAll("ogygia-region[src][entry]")) {
+			const src = el.getAttribute("src");
+			try {
+				const host = el.parentElement?.closest("ogygia-region[endpoint]");
+				const hole = host ? new URL(host.getAttribute("endpoint"), location.href).searchParams.get("id") ?? "" : "";
+				entry_of.set(new URL(src, document.baseURI).href, {
+					entry: el.getAttribute("entry"),
+					...hole ? { hole: hole.slice(0, 40) } : {}
+				});
+			} catch {}
+		}
+		const runtime_src = document.querySelector("script[data-ogygia-runtime]")?.src ?? "";
+		const counted = /* @__PURE__ */ new Set();
+		for (const r of all) {
+			if (refetched.length >= MAX_REFETCHED || counted.has(r.name) || !r.name.startsWith(origin) || !r.name.includes("/immutable/")) continue;
+			const body = r.encodedBodySize;
+			if (!(r.transferSize > 0)) continue;
+			const how = body === 0 || r.transferSize < body ? "revalidated" : reload ? "downloaded" : null;
+			if (!how) continue;
+			counted.add(r.name);
+			const island = entry_of.get(r.name);
+			refetched.push({
+				url: r.name.slice(0, 500),
+				how,
+				bytes: body,
+				ms: r2(r.duration),
+				...island ? {
+					entry: island.entry.slice(0, 300),
+					...island.hole ? { hole: island.hole } : {}
+				} : {},
+				...r.name === runtime_src ? { runtime: true } : {}
+			});
+		}
+		const blocking = paint_blocker();
+		const keep = all.filter(blocking).slice(0, MAX_DETAIL_RESOURCES);
+		const lcp_res = visit_paints.lcp_url ? all.find((r) => r.name === visit_paints.lcp_url) : void 0;
+		if (lcp_res && !keep.includes(lcp_res)) keep.push(lcp_res);
+		const kept = new Set(keep);
+		for (const pass of [false, true]) for (const r of all) {
+			if (keep.length >= MAX_DETAIL_RESOURCES) break;
+			if (kept.has(r) || type_of(r) === "script" !== pass) continue;
+			kept.add(r);
+			keep.push(r);
+		}
+		keep.sort((a, b) => a.startTime - b.startTime);
+		resources = keep.map((r) => ({
+			url: r.name.slice(0, 500),
+			type: type_of(r),
+			start: r2(r.startTime),
+			end: r2(r.responseEnd || r.startTime + r.duration),
+			...r.requestStart ? { req_start: r2(r.requestStart) } : {},
+			...r.responseStart ? { res_start: r2(r.responseStart) } : {},
+			...r.transferSize ? { transfer: r.transferSize } : {},
+			...r.decodedBodySize ? { size: r.decodedBodySize } : {},
+			...blocking(r) ? { blocking: true } : {}
+		}));
+	} catch {
+		resources = [];
+	}
+	let fonts = [];
+	try {
+		fonts = font_faces_of(new Set(resources.filter((r) => r.type === "font").map((r) => r.url)));
+	} catch {}
+	let oversized = [];
+	let dom = null;
+	let wasted = null;
+	let below = [];
+	let unsized = null;
+	try {
+		oversized = oversized_images();
+		below = images_eager_below(nav.loadEventEnd);
+		unsized = images_unsized();
+		dom = dom_shape();
+		wasted = preloads_never_used(nav.loadEventEnd);
+	} catch {}
+	return {
+		at: Math.round(performance.timeOrigin),
+		origin: location.origin,
+		...unsupported_types(),
+		nav: {
+			...start_hidden ? { start_hidden: true } : {
+				req_start: r2(nav.requestStart),
+				res_start: r2(nav.responseStart)
+			},
+			...nav.responseEnd > 0 ? { res_end: r2(nav.responseEnd) } : {},
+			...nav.domInteractive ? { dom_interactive: r2(nav.domInteractive) } : {},
+			...nav.domContentLoadedEventEnd ? { dcl: r2(nav.domContentLoadedEventEnd) } : {},
+			...nav.loadEventEnd ? { load: r2(nav.loadEventEnd) } : {},
+			...nav.transferSize ? { transfer: nav.transferSize } : {},
+			...nav.decodedBodySize ? { size: nav.decodedBodySize } : {},
+			...nav.decodedBodySize >= UNCOMPRESSED_MIN && nav.encodedBodySize >= nav.decodedBodySize ? { raw: true } : {},
+			...nav.nextHopProtocol ? { protocol: nav.nextHopProtocol } : {},
+			...nav_phases(nav),
+			...nav.serverTiming?.length ? { server_timing: nav.serverTiming.slice(0, 8).map((s) => ({
+				name: s.name.slice(0, 40),
+				ms: r2(s.duration),
+				...s.description ? { desc: s.description.slice(0, 80) } : {}
+			})) } : {}
+		},
+		paints: {
+			...visit_paints,
+			...lcp_el && !lcp_el.isConnected && lcp_region?.isConnected ? { lcp_replaced: true } : {},
+			...critical_outcome() ? { held: critical_outcome() } : {}
+		},
+		resources,
+		...all_n > resources.length ? {
+			resource_totals: [...totals.values()],
+			resources_all: all_n
+		} : {},
+		...preload_misses.length ? { preload_misses } : {},
+		...uncompressed.length ? { uncompressed } : {},
+		...fonts.length ? { font_faces: fonts } : {},
+		...oversized.length ? { images_oversized: oversized } : {},
+		...dom ? { dom } : {},
+		...wasted?.length ? { preloads_unused: wasted } : {},
+		...below.length ? { images_eager_below: below } : {},
+		...unsized ? { images_unsized: unsized } : {},
+		...visit_forced.length ? { forced_layout: visit_forced.slice() } : {},
+		...visit_scroll_jank.length ? { scroll_jank: visit_scroll_jank.slice() } : {},
+		...refetched.length ? { refetched } : {},
+		...visit_navs.length ? { navs: visit_navs.slice() } : {},
+		longtasks: visit_longtasks,
+		...longtasks_from_frames ? { longtasks_from: "frames" } : {},
+		...island_boxes ? { shifts_from: "boxes" } : {},
+		islands: visit_islands,
+		firsts: visit_firsts,
+		shifts: visit_shifts,
+		...visit_interaction ? { interaction: interaction_with_scripts(visit_interaction) } : {},
+		...visit_scripts.size ? { scripts: [...visit_scripts].map(([url, s]) => ({
+			url,
+			ms: r2(s.ms),
+			count: s.count
+		})).sort((a, b) => b.ms - a.ms).slice(0, 50) } : {},
+		regions: visit_regions(),
+		...visit_warnings.length ? { warnings: visit_warnings.slice() } : {},
+		...visit_holes_failed.length ? { holes_failed: visit_holes_failed.slice() } : {},
+		...visit_holes_answered.length ? { holes_answered: visit_holes_answered.slice() } : {},
+		...visit_hole_batches.length ? { hole_batches: visit_hole_batches.slice() } : {},
+		...restore_log(),
+		...visit_entry_fallbacks.length ? { entry_fallbacks: visit_entry_fallbacks.slice() } : {},
+		...visit_marks.length ? { marks: visit_marks } : {},
+		...vitals && Object.keys(vitals).length ? { vitals: { ...vitals } } : {},
+		viewport: [innerWidth, innerHeight],
+		ua: navigator.userAgent.slice(0, 200),
+		...(() => {
+			const at = globalThis[Symbol.for("ogygia.dock-open-at")];
+			return typeof at === "number" ? { dock_open_at: r2(at) } : {};
+		})()
+	};
+}
+/** The visit goes out twice: EARLY (on the first idle, so the store has it even if the page is
+*  torn down before a write on hide can finish) and FINAL (on hide, with the last paints, the
+*  islands' final markup and the shifts). The server and the store fold the two by navigation
+*  start. */
+/**
+* THE PAGE A VISIT BELONGS TO: the one the document loaded as. The visit is the document's whole
+* story — its load, its vitals, and every in-app navigation after it (the router's body swaps keep
+* the document) — so it, its vitals and its CPU traces are filed under the page the visitor landed
+* on, never under wherever the address bar is when a later message leaves: a navigation to /b then
+* filed the rest of /a's visit (the navigation itself among it) under /b, where /a's report never
+* looks. Read at boot (observe_vitals), and on first use after a reset.
+*/
+let landing_page = null;
+function visit_page() {
+	if (landing_page === null && typeof location !== "undefined") landing_page = location.pathname;
+	return landing_page ?? "/";
+}
+function flush_visit(final) {
+	if (visit_sent) return;
+	const visit = build_visit();
+	if (!visit) return;
+	if (final) {
+		visit_sent = true;
+		for (const s of snapshots) {
+			const el = document.querySelector(`ogygia-region[data-og-fp="${s.fp}"]`);
+			if (el) {
+				const html = s.from === void 0 ? el.innerHTML : without_runtime_marks(without_comments(el.innerHTML)).slice(s.from, s.from + SNAPSHOT_CAP);
+				if (html !== s.hydrated) s.final = html.slice(0, SNAPSHOT_CAP);
+			}
+		}
+	}
+	if (!endpoint()) return;
+	send(JSON.stringify({
+		page: visit_page(),
+		visit
+	}), () => {
+		const no_files = JSON.stringify({
+			page: visit_page(),
+			visit: {
+				...visit,
+				resources: []
+			}
+		});
+		return no_files.length <= keepalive_room() ? no_files : JSON.stringify({
+			page: visit_page(),
+			visit: {
+				...visit,
+				resources: [],
+				regions: [],
+				islands: []
+			}
+		});
+	});
+	store_visit({
+		key: `${visit_page()}|${visit.at}`,
+		page: visit_page(),
+		at: visit.at,
+		visit,
+		snapshots
+	});
+}
+const DB_NAME = "ogygia-profiler";
+const DB_VERSION = 1;
+function open_db() {
+	return new Promise((resolve) => {
+		try {
+			const req = indexedDB.open(DB_NAME, DB_VERSION);
+			req.onupgradeneeded = () => {
+				const db = req.result;
+				if (!db.objectStoreNames.contains("reports")) db.createObjectStore("reports", { keyPath: "id" });
+				if (!db.objectStoreNames.contains("visits")) db.createObjectStore("visits", { keyPath: "key" });
+			};
+			req.onsuccess = () => resolve(req.result);
+			req.onerror = () => resolve(null);
+			req.onblocked = () => resolve(null);
+		} catch {
+			resolve(null);
+		}
+	});
+}
+async function store_visit(rec) {
+	const db = await open_db();
+	if (!db) return;
+	try {
+		const store = db.transaction("visits", "readwrite").objectStore("visits");
+		const prior = store.get(rec.key);
+		prior.onsuccess = () => {
+			const old = prior.result;
+			if (old) {
+				const union = (xs, ys, key) => {
+					const m = /* @__PURE__ */ new Map();
+					for (const x of xs ?? []) m.set(key(x), x);
+					for (const y of ys ?? []) m.set(key(y), y);
+					return [...m.values()];
+				};
+				const ov = old.visit;
+				const nv = rec.visit;
+				const arr = (o) => Array.isArray(o) ? o : [];
+				rec = {
+					...rec,
+					visit: {
+						...ov,
+						...nv,
+						nav: {
+							...ov.nav,
+							...nv.nav
+						},
+						paints: {
+							...ov.paints,
+							...nv.paints
+						},
+						islands: union(arr(ov.islands), arr(nv.islands), (i) => `${i.fp}|${i.t0}`),
+						firsts: union(arr(ov.firsts), arr(nv.firsts), (f) => String(f.fp)),
+						shifts: union(arr(ov.shifts), arr(nv.shifts), (s) => `${s.t}|${s.value}`),
+						longtasks: union(arr(ov.longtasks), arr(nv.longtasks), (l) => `${l.t}|${l.ms}`),
+						marks: union(arr(ov.marks), arr(nv.marks), (m) => `${m.name}|${m.t0 ?? ""}|${m.ms}`),
+						resources: arr(nv.resources).length >= arr(ov.resources).length ? nv.resources : ov.resources
+					},
+					snapshots: union(old.snapshots, rec.snapshots, (s) => s.fp)
+				};
+			}
+			store.put(rec);
+			const all = store.getAllKeys();
+			all.onsuccess = () => {
+				const keys = all.result.sort();
+				for (const k of keys.slice(0, Math.max(0, keys.length - 30))) store.delete(k);
+			};
+		};
+	} catch {}
+}
+let cpu = null;
+let cpu_sent = false;
+const CPU_WINDOW_MS = 8e3;
+/** devtools: the load trace, and any recording started from the Page tab, kept in the page */
+let cpu_kept = [];
+/** why there is no trace: 'unsupported' (no API), 'no-policy' (the document did not opt in) */
+let cpu_off = null;
+let cpu_started_at = 0;
+function make_profiler() {
+	const Ctor = globalThis.Profiler;
+	if (!Ctor) {
+		cpu_off = "unsupported";
+		return null;
+	}
+	try {
+		return new Ctor({
+			sampleInterval: 10,
+			maxBufferSize: 3e4
+		});
+	} catch {
+		cpu_off = "no-policy";
+		return null;
+	}
+}
+/** islands that failed to hydrate (never `data-hydrated`), with the error: the CPU window does not
+*  wait for them, and the visit reports them */
+const failed_fps = /* @__PURE__ */ new Map();
+let visit_navs = [];
+function beacon_nav(n) {
+	const o = owner();
+	if (o) return o.beacon_nav?.(n);
+	if (!collecting() || visit_navs.length >= 20) return;
+	let split = {};
+	try {
+		const entries = n.href ? performance.getEntriesByName(n.href) : [];
+		let e;
+		for (const x of entries) if (x.initiatorType === "fetch" && x.responseEnd <= n.fetched + 1 && (!e || x.startTime > e.startTime)) e = x;
+		if (e && e.responseStart > 0) {
+			const asked = e.requestStart > 0 ? e.requestStart : e.startTime;
+			split = {
+				server: r2(Math.max(0, e.responseStart - asked)),
+				download: r2(Math.max(0, e.responseEnd - e.responseStart)),
+				...e.transferSize || e.encodedBodySize ? { bytes: e.transferSize || e.encodedBodySize } : {},
+				...e.startTime < n.t - 1 ? { prefetched: true } : {}
+			};
+		}
+	} catch {
+		split = {};
+	}
+	if (first_nav_t === void 0) {
+		first_nav_t = n.t;
+		snapshot_firsts = snapshots.length;
+	}
+	visit_navs.push({
+		from: n.from.slice(0, 300),
+		to: n.to.slice(0, 300),
+		type: (n.type || "link").slice(0, 20),
+		t: r2(n.t),
+		fetched: r2(n.fetched),
+		styled: r2(n.styled),
+		swapped: r2(n.swapped),
+		...split
+	});
+	resend_soon();
+}
+function beacon_failed(el, message, since, turn) {
+	const o = owner();
+	if (o) return o.beacon_failed(el, message, since, turn);
+	if (!collecting()) return;
+	const fp = el.getAttribute("data-og-fp");
+	if (!fp) return;
+	failed_fps.set(fp, (message ?? "").slice(0, 300));
+	if (typeof since === "number") failed_spans.set(fp, [r2(since), r2(performance.now())]);
+	if (typeof turn === "number") failed_turns.set(fp, r2(turn));
+}
+const failed_spans = /* @__PURE__ */ new Map();
+const failed_turns = /* @__PURE__ */ new Map();
+const MEASURED_TYPES = [
+	"layout-shift",
+	"longtask",
+	"event",
+	"largest-contentful-paint",
+	"long-animation-frame"
+];
+/** whether this browser can observe an entry type */
+function supports(type) {
+	try {
+		return (PerformanceObserver.supportedEntryTypes ?? []).includes(type);
+	} catch {
+		return false;
+	}
+}
+/**
+* WHAT A WAKE MOVED, where the browser reports no layout shifts (Safari): each island's box as the
+* server drew it, noted at boot before any island wakes, and again once it woke. An island whose
+* height changed while its bottom sat on the screen moved its content by that much: a shift, scored
+* the way a layout shift traced to it is (its box's share of the screen × how far, against the
+* screen's larger side), on the island's fingerprint. An estimate — content moving inside a box of
+* the same height is not seen — and the visit says its shifts are these (`shifts_from: 'boxes'`).
+*/
+let island_boxes = null;
+/** an element's box: its own, or — a region draws no box of its own — its children's together */
+function box_of(el) {
+	const r = el.getBoundingClientRect();
+	if (r.width || r.height) return {
+		top: r.top,
+		bottom: r.bottom,
+		left: r.left,
+		width: r.width
+	};
+	let top = Infinity;
+	let bottom = -Infinity;
+	let left = Infinity;
+	let right = -Infinity;
+	for (const c of el.children) {
+		const b = c.getBoundingClientRect();
+		if (!b.width && !b.height) continue;
+		top = Math.min(top, b.top);
+		bottom = Math.max(bottom, b.bottom);
+		left = Math.min(left, b.left);
+		right = Math.max(right, b.right);
+	}
+	return top === Infinity ? null : {
+		top,
+		bottom,
+		left,
+		width: right - left
+	};
+}
+function note_island_boxes() {
+	if (island_boxes || typeof innerHeight === "undefined") return;
+	island_boxes = /* @__PURE__ */ new WeakMap();
+	for (const el of document.querySelectorAll("ogygia-region[data-og-fp]:not([data-hydrated])")) {
+		const b = box_of(el);
+		if (b) island_boxes.set(el, {
+			top: b.top + scrollY,
+			height: b.bottom - b.top
+		});
+	}
+}
+/** when a woken island's box is looked at again: two frames on (what its mount drew a frame later —
+*  a banner opened in a requestAnimationFrame), and half a second on (inside the 600 ms a wake's
+*  shifts are counted against it) */
+const BOX_LOOK_AGAIN_MS = 500;
+function estimate_wake_shift(el, fp, t) {
+	const before = island_boxes?.get(el);
+	if (!before) return;
+	island_boxes.delete(el);
+	let last = before;
+	const look = (at) => {
+		const moved = box_shift(el, fp, last, at);
+		if (moved) last = moved;
+	};
+	look(t);
+	if (typeof requestAnimationFrame !== "undefined") requestAnimationFrame(() => requestAnimationFrame(() => look(performance.now())));
+	setTimeout(() => look(performance.now()), BOX_LOOK_AGAIN_MS);
+}
+/** the island's box against `before`: a shift when its height changed with its bottom on the screen;
+*  the box it has now (the next look's `before`), or null when nothing moved */
+function box_shift(el, fp, before, t) {
+	const after = box_of(el);
+	if (!after) return null;
+	const dh = after.bottom - after.top - before.height;
+	if (Math.abs(dh) < 1) return null;
+	const now = {
+		top: after.top + scrollY,
+		height: after.bottom - after.top
+	};
+	const vw = innerWidth;
+	const vh = innerHeight;
+	if (before.top - scrollY + before.height >= vh) return now;
+	const moved = Math.min(Math.abs(dh), vh);
+	const seen = Math.max(0, Math.min(vh, after.bottom) - Math.max(0, after.top));
+	const value = Math.round(seen * Math.min(after.width, vw) / (vh * vw) * (moved / Math.max(vw, vh)) * 1e4) / 1e4;
+	if (value < 1e-4 || !make_room(visit_shifts, 60, (s) => s.t)) return now;
+	const tag = describe_target(el);
+	visit_shifts.push({
+		t: r2(t),
+		value,
+		fp,
+		...tag ? { tag } : {},
+		from: [
+			Math.round(after.left),
+			Math.round(before.top - scrollY),
+			Math.round(after.width),
+			Math.round(before.height)
+		],
+		to: [
+			Math.round(after.left),
+			Math.round(after.top),
+			Math.round(after.width),
+			Math.round(after.bottom - after.top)
+		]
+	});
+	if (early_visit_done) resend_soon();
+	return now;
+}
+/** a frame's budget at 60 Hz, and how late a frame must be to count: a long task's 50 ms */
+const FRAME_MS = 1e3 / 60;
+const STALL_MS = 50;
+/** how long past the load event the frames are watched, and never past this from the start */
+const FRAMES_AFTER_LOAD_MS = 3e3;
+const FRAMES_MAX_MS = 2e4;
+/**
+* A browser with no long-task timing (Safari): every long-task finding went silent there. The frames
+* the page draws stand in — from its first frame (none comes while the paint is blocked, so a slow
+* stylesheet is never a stall) until a few seconds after the load event, a frame that came more than
+* 50 ms past its budget means the main thread was held that long. Each is kept as a long task, and
+* the visit says its long tasks are frame gaps. A hidden page draws no frames: a gap across a hide is
+* not counted.
+*/
+function watch_frame_gaps() {
+	if (longtasks_from_frames || typeof requestAnimationFrame === "undefined" || typeof document === "undefined") return;
+	longtasks_from_frames = true;
+	let last = 0;
+	const tick = (now) => {
+		if (document.visibilityState !== "visible") last = 0;
+		else {
+			const late = last ? now - last - FRAME_MS : 0;
+			if (late > STALL_MS && make_room(visit_longtasks, 100, (l) => l.t)) visit_longtasks.push({
+				t: r2(last + FRAME_MS),
+				ms: r2(late)
+			});
+			last = now;
+		}
+		const loaded = performance.getEntriesByType("navigation")[0]?.loadEventEnd || 0;
+		if (now >= FRAMES_MAX_MS || loaded && now >= loaded + FRAMES_AFTER_LOAD_MS) return;
+		requestAnimationFrame(tick);
+	};
+	requestAnimationFrame(tick);
+}
+/** `{ unsupported: [...] }` for the entry types this browser cannot observe, or `{}`. */
+function unsupported_types() {
+	let types = [];
+	try {
+		types = PerformanceObserver.supportedEntryTypes ?? [];
+	} catch {
+		return { unsupported: MEASURED_TYPES.slice() };
+	}
+	const missing = MEASURED_TYPES.filter((t) => !types.includes(t));
+	return missing.length ? { unsupported: missing } : {};
+}
+/** Every region on the page as the visit ends: where it sits (document px, so the server can tell
+*  the first screen from below it), how it wakes, whether it woke, and a failure's error. One
+*  layout read per region, when a visit message is built (idle or hide), never on the hydrate path. */
+function visit_regions() {
+	const out = [];
+	try {
+		const sy = typeof scrollY === "number" ? scrollY : 0;
+		for (const el of document.querySelectorAll("ogygia-region[data-og-fp]")) {
+			if (out.length >= 400) break;
+			const fp = el.getAttribute("data-og-fp");
+			let box = el.getBoundingClientRect();
+			if (!box.height && !box.width) for (const c of el.children) {
+				const b = c.getBoundingClientRect();
+				if (b.height || b.width) {
+					box = b;
+					break;
+				}
+			}
+			const failed = failed_fps.get(fp);
+			out.push({
+				fp,
+				...el.getAttribute("entry") ? { entry: el.getAttribute("entry") } : {},
+				...el.getAttribute("wake") ? { wake: el.getAttribute("wake") } : {},
+				...el.getAttribute("render") === "defer" ? { defer: true } : {},
+				...el.hasAttribute("data-hydrated") ? { hydrated: true } : {},
+				...failed !== void 0 ? {
+					failed,
+					...failed_spans.has(fp) ? { failed_span: failed_spans.get(fp) } : {},
+					...failed_turns.has(fp) ? { failed_turn: failed_turns.get(fp) } : {}
+				} : {},
+				top: Math.round(box.top + sy),
+				height: Math.round(box.height),
+				...!box.height && !box.width ? {
+					hidden: true,
+					...is_headless(el) ? { headless: true } : {}
+				} : {}
+			});
+		}
+	} catch {}
+	return out;
+}
+/** a slow device can still be waking islands at 8 s: keep sampling while one woke in the last
+*  1.5 s, up to 20 s — else the hydration the trace is for would be cut off */
+const CPU_WINDOW_MAX_MS = 2e4;
+const CPU_QUIET_MS = 1500;
+function start_cpu() {
+	if (cpu || cpu_sent || !collecting()) return;
+	cpu = make_profiler();
+	if (!cpu) return;
+	cpu_started_at = performance.now();
+	const check = () => {
+		const now = performance.now();
+		const last = visit_islands.length ? visit_islands[visit_islands.length - 1].done : 0;
+		let waiting = false;
+		try {
+			for (const el of document.querySelectorAll("ogygia-region[data-og-fp]:not([data-hydrated]):not([wake]):not([render=\"defer\"]), ogygia-region[data-og-fp][wake=\"load\"]:not([data-hydrated])")) if (!failed_fps.has(el.getAttribute("data-og-fp") ?? "")) {
+				waiting = true;
+				break;
+			}
+		} catch {
+			waiting = false;
+		}
+		if ((now - last < CPU_QUIET_MS || waiting) && now - cpu_started_at < CPU_WINDOW_MAX_MS) setTimeout(check, CPU_QUIET_MS);
+		else flush_cpu(false);
+	};
+	setTimeout(check, CPU_WINDOW_MS);
+}
+async function flush_cpu(hiding) {
+	if (!cpu || cpu_sent) return;
+	const p = cpu;
+	cpu = null;
+	cpu_sent = true;
+	let trace;
+	try {
+		trace = await p.stop();
+	} catch {
+		return;
+	}
+	if (DEVTOOLS && trace) cpu_kept = [{
+		trace,
+		from: cpu_started_at,
+		to: performance.now(),
+		label: "page load"
+	}, ...cpu_kept.slice(0, 4)];
+	if (!hiding) start_interaction_cpu();
+	const url = endpoint();
+	if (!url || !trace) return;
+	const body = JSON.stringify({
+		page: visit_page(),
+		cpu: trace
+	});
+	const keepalive = hiding && body.length <= keepalive_room();
+	if (hiding && !keepalive) return;
+	try {
+		const settled = fetch(url, {
+			method: "POST",
+			body,
+			credentials: "same-origin",
+			headers: { "content-type": "text/plain" },
+			...keepalive ? { keepalive: true } : {}
+		}).catch(() => {});
+		if (keepalive) hold_keepalive(body.length, settled);
+	} catch {}
+}
+let icpu = null;
+let icpu_timer = null;
+let icpu_done = false;
+const ICPU_MAX_MS = 6e4;
+const ICPU_SLOW_MS = 200;
+/** the interaction the running sampler caught, when one did */
+let icpu_caught = null;
+function start_interaction_cpu() {
+	if (icpu || icpu_done || !collecting()) return;
+	icpu = make_profiler();
+	if (!icpu) return;
+	icpu_timer = setTimeout(() => void stop_interaction_cpu(false), ICPU_MAX_MS);
+}
+/** the event observer saw a new slowest interaction: a slow one ends the sampling shortly after */
+function interaction_seen(i) {
+	if (!icpu || icpu_caught || i.ms < ICPU_SLOW_MS) return;
+	const handlers_at = i.t + i.delay;
+	icpu_caught = {
+		t: i.t,
+		wait: [i.t, handlers_at],
+		handler: [handlers_at, handlers_at + i.processing]
+	};
+	if (icpu_timer) clearTimeout(icpu_timer);
+	icpu_timer = setTimeout(() => void stop_interaction_cpu(false), 300);
+}
+async function stop_interaction_cpu(hiding) {
+	if (!icpu) return;
+	const p = icpu;
+	icpu = null;
+	icpu_done = true;
+	if (icpu_timer) clearTimeout(icpu_timer);
+	icpu_timer = null;
+	let trace;
+	try {
+		trace = await p.stop();
+	} catch {
+		return;
+	}
+	let caught = icpu_caught;
+	if (!trace || !caught) return;
+	const i = visit_interaction;
+	if (i && i.t === caught.t) {
+		const handlers_at = i.t + i.delay;
+		caught = {
+			t: i.t,
+			wait: [i.t, handlers_at],
+			handler: [handlers_at, handlers_at + i.processing]
+		};
+	}
+	if (DEVTOOLS) cpu_kept = [{
+		trace,
+		from: caught.wait[0],
+		to: caught.handler[1],
+		label: "interaction",
+		spans: caught
+	}, ...cpu_kept.slice(0, 4)];
+	const url = endpoint();
+	if (!url) return;
+	const body = JSON.stringify({
+		page: visit_page(),
+		cpu: trace,
+		interaction: caught
+	});
+	const keepalive = hiding && body.length <= keepalive_room();
+	if (hiding && !keepalive) return;
+	try {
+		const settled = fetch(url, {
+			method: "POST",
+			body,
+			credentials: "same-origin",
+			headers: { "content-type": "text/plain" },
+			...keepalive ? { keepalive: true } : {}
+		}).catch(() => {});
+		if (keepalive) hold_keepalive(body.length, settled);
+	} catch {}
+}
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+const DEVTOOLS_LAZY = typeof __OGYGIA_DEVTOOLS_LAZY__ !== "undefined" ? __OGYGIA_DEVTOOLS_LAZY__ : false;
+let opted;
+function devtools_measures() {
+	if (!DEVTOOLS) return false;
+	if (!DEVTOOLS_LAZY) return true;
+	return opted ??= devtools_switched_on();
+}
+/** when the document's first in-app navigation started (its first page's record ends there) */
+let first_nav_t;
+/**
+* Room in a capped list of the visit. Full: the oldest entry from AFTER the document's first in-app
+* navigation goes — the page in view keeps its record (a long session of navigations filled the
+* lists with the pages before it: one 320-island page left every later page with no islands at all,
+* and the Page tab found nothing there), and the page the document loaded as keeps all of its own
+* (the profiler's report is about that one). `false`: full of the first page's, the new one waits.
+*/
+/** how many snapshots the first page took (a snapshot has no time of its own) */
+let snapshot_firsts = 0;
+function snapshot_room() {
+	if (snapshots.length < MAX_SNAPSHOTS) return true;
+	if (first_nav_t === void 0 || snapshots.length <= snapshot_firsts) return false;
+	snapshots.splice(snapshot_firsts, 1);
+	return true;
+}
+function make_room(list, cap, t_of) {
+	if (list.length < cap) return true;
+	if (first_nav_t === void 0) return false;
+	const from = first_nav_t;
+	const i = list.findIndex((x) => t_of(x) >= from);
+	if (i === -1) return false;
+	list.splice(i, 1);
+	return true;
+}
+/** recording at all: the profiler's tag, or a devtools build (a lazy one: once opted in) */
+function collecting() {
+	return devtools_measures() || endpoint() !== null;
+}
+function endpoint() {
+	if (target !== void 0) return target;
+	if (typeof document === "undefined") return target = null;
+	const href = document.querySelector("meta[name=\"ogygia-profiler-beacon\"]")?.getAttribute("content") ?? "";
+	return target = href ? href : null;
+}
+let early_visit_done = false;
+let resend_timer = null;
+let resends = 0;
+const RESEND_MAX = 8;
+function resend_soon() {
+	if (!endpoint() || visit_sent || resends >= RESEND_MAX) return;
+	if (resend_timer) clearTimeout(resend_timer);
+	resend_timer = setTimeout(() => {
+		resend_timer = null;
+		resends++;
+		flush_visit(false);
+	}, 1500);
+}
+function flush() {
+	metered("send", flush_now);
+}
+function flush_now() {
+	scheduled = false;
+	if (queue.length || marks.length) send(JSON.stringify({
+		page: location.pathname,
+		...queue.length ? { islands: queue.splice(0, 400) } : {},
+		...marks.length ? { marks: marks.splice(0, 400) } : {}
+	}));
+	if (!early_visit_done) {
+		early_visit_done = true;
+		flush_visit(false);
+		send_after_preload_check();
+	}
+}
+/** A page with image, font or stylesheet preloads: the visit once more after the 3 s past load
+*  that tells a preload nothing used — a visitor who leaves without the page hiding cleanly (a
+*  closed tab, a crash) would otherwise never send it. resend_soon waits 1.5 s itself. */
+function send_after_preload_check() {
+	try {
+		if (!document.querySelector("link[rel=\"preload\"][as=\"image\"]:not([imagesrcset]), link[rel=\"preload\"][as=\"font\"], link[rel=\"preload\"][as=\"style\"]")) return;
+		if (document.readyState === "complete") {
+			const nav = performance.getEntriesByType("navigation")[0];
+			setTimeout(resend_soon, Math.max(0, 1700 - (performance.now() - (nav?.loadEventEnd ?? 0))));
+		} else addEventListener("load", () => setTimeout(resend_soon, 1700), { once: true });
+	} catch {}
+}
+/** the page is going away: the islands still queued, then the vitals (final only now), the visit */
+function on_hide() {
+	leaving = true;
+	try {
+		flush();
+		flush_vitals();
+		flush_visit(true);
+	} finally {
+		leaving = false;
+	}
+	flush_cpu(true);
+	stop_interaction_cpu(true);
+}
+function schedule() {
+	if (scheduled) return;
+	scheduled = true;
+	if (!listening) {
+		listening = true;
+		observe_vitals();
+		start_cpu();
+		document.addEventListener("visibilitychange", () => document.visibilityState === "hidden" && on_hide());
+		addEventListener("pagehide", on_hide);
+	}
+	const idle = globalThis.requestIdleCallback;
+	if (idle) idle(flush, { timeout: 2e3 });
+	else setTimeout(flush, 1500);
+}
+/**
+* Record one island's hydration. `t0` is when the wake began (before the module load), `t_loaded`
+* when its modules were in hand, `t_done` when `data-hydrated` was set; `ssr_html` is the markup
+* the server sent (the runtime's own copy), compared with what the island shows now. No-op
+* without the tag.
+*/
+function beacon_hydrated(el, t0, t_loaded, t_done, ssr_html, t_turn) {
+	const o = owner();
+	if (o) return o.beacon_hydrated(el, t0, t_loaded, t_done, ssr_html, t_turn);
+	if (!collecting()) return;
+	const c0 = performance.now();
+	island_record(el, t0, t_loaded, t_done, ssr_html, t_turn);
+	charge("islands", c0);
+}
+function island_record(el, t0, t_loaded, t_done, ssr_html, t_turn) {
+	const fp = el.getAttribute("data-og-fp");
+	if (!fp) return;
+	const recovered = el.hasAttribute("data-og-recovered");
+	const reason = (el.getAttribute("data-og-recovered") || "").slice(0, 300) || void 0;
+	const sent = endpoint() ? {
+		fp,
+		entry: el.getAttribute("entry") ?? "",
+		ms: Math.max(0, r2(t_done - t0)),
+		load: Math.max(0, r2(t_loaded - t0)),
+		...recovered ? { recovered: true } : {},
+		...reason ? { reason } : {}
+	} : null;
+	if (sent) queue.push(sent);
+	let changed;
+	let attrs = null;
+	const room = make_room(visit_islands, 400, (i) => i.t0);
+	if (typeof ssr_html === "string" && room) {
+		const now = el.innerHTML;
+		if (now !== ssr_html) {
+			const a = without_runtime_marks(without_comments(ssr_html));
+			const b = without_runtime_marks(without_comments(now));
+			changed = a !== b;
+			if (changed) {
+				attrs = attr_changes(a, b);
+				if (snapshot_room()) snapshots.push(snapshot_of(fp, ssr_html, now, a, b));
+			}
+		} else changed = false;
+	}
+	let input;
+	for (let k = recent_inputs.length - 1; k >= 0; k--) {
+		const x = recent_inputs[k];
+		if (x.t < t0) break;
+		const target = x.el.deref();
+		if (x.t <= t_done && target && el.contains(target)) {
+			input = x.type;
+			break;
+		}
+	}
+	if (island_boxes) estimate_wake_shift(el, fp, t_done);
+	if (early_visit_done) resend_soon();
+	let markers;
+	if (recovered && typeof ssr_html === "string") {
+		const open = count_of(ssr_html, "<!--[");
+		const close = count_of(ssr_html, "<!--]");
+		if (open !== close) markers = [open, close];
+	}
+	const rec = room ? {
+		fp,
+		...el.getAttribute("entry") ? { entry: el.getAttribute("entry") } : {},
+		t0: r2(t0),
+		loaded: r2(t_loaded),
+		...t_turn !== void 0 && t_turn >= t_loaded ? { turn: r2(t_turn) } : {},
+		done: r2(t_done),
+		...recovered ? { recovered: true } : {},
+		...changed ? { changed: true } : {},
+		...attrs ? { attrs } : {},
+		...input ? { input } : {},
+		...el.hasAttribute("data-og-healed") ? { healed: true } : {},
+		...typeof ssr_html === "string" ? { ssr_bytes: ssr_html.length } : {},
+		...markers ? { markers } : {}
+	} : null;
+	if (rec) visit_islands.push(rec);
+	if (rec || sent) queueMicrotask(() => {
+		const fx = performance.now();
+		if (fx - t_done < 1) return;
+		if (rec) rec.fx = r2(fx);
+		if (sent) sent.ms = Math.max(0, r2(fx - t0));
+	});
+	schedule();
+}
+/** the attributes the runtime itself sets, empty, on the regions inside an island's markup */
+const RUNTIME_MARKS = [
+	" data-nested=\"\"",
+	" data-hydrated=\"\"",
+	" data-og-kept=\"\"",
+	" data-revalidated=\"\""
+];
+/** `html` without the runtime's own marks (string search, no regex: it runs per changed hydration) */
+function without_runtime_marks(html) {
+	for (const m of RUNTIME_MARKS) if (html.includes(m)) html = html.split(m).join("");
+	return html;
+}
+/** A HEADLESS island: it renders nothing meant to be seen — no text of its own, and every element
+*  child marked `hidden` (a marker its effects hang on) — so it exists for its effects, and the
+*  screen sizes that would show it are no question. */
+function is_headless(el) {
+	for (const n of el.childNodes) {
+		if (n.nodeType === 3 && (n.textContent ?? "").trim()) return false;
+		if (n.nodeType === 1 && !n.hasAttribute("hidden")) return false;
+	}
+	return true;
+}
+/** How many times `needle` occurs in `html` (string search). */
+function count_of(html, needle) {
+	let n = 0;
+	for (let at = html.indexOf(needle); at !== -1; at = html.indexOf(needle, at + needle.length)) n++;
+	return n;
+}
+/** `html` with every `<!-- … -->` removed (string search, no regex: it runs per hydration). */
+function without_comments(html) {
+	let at = html.indexOf("<!--");
+	if (at === -1) return html;
+	let out = "";
+	let from = 0;
+	while (at !== -1) {
+		out += html.slice(from, at);
+		const end = html.indexOf("-->", at + 4);
+		if (end === -1) return out;
+		from = end + 3;
+		at = html.indexOf("<!--", from);
+	}
+	return out + html.slice(from);
+}
+/** Start watching the page's paints, shifts, long tasks and first interactions now (the devtools
+*  boot calls this, so a page whose islands never wake is still measured). Idempotent. */
+function beacon_watch() {
+	const o = owner();
+	if (o) return o.beacon_watch();
+	if (!collecting() || typeof document === "undefined") return;
+	if (!supports("layout-shift")) note_island_boxes();
+	schedule();
+}
+/** Devtools: sample the main thread for `ms` from now (a click, a scroll, a nav) and keep the trace
+*  in the page. Resolves when it is kept; false when the browser cannot sample here. */
+async function beacon_record_cpu(ms, label) {
+	const o = owner();
+	if (o) return o.beacon_record_cpu(ms, label);
+	if (!DEVTOOLS) return false;
+	const p = make_profiler();
+	if (!p) return false;
+	const from = performance.now();
+	await new Promise((ok) => setTimeout(ok, Math.max(200, Math.min(3e4, ms))));
+	try {
+		cpu_kept = [{
+			trace: await p.stop(),
+			from,
+			to: performance.now(),
+			label
+		}, ...cpu_kept.slice(0, 4)];
+		return true;
+	} catch {
+		return false;
+	}
+}
+function beacon_page() {
+	const o = owner();
+	if (o) return o.beacon_page();
+	if (!collecting()) return null;
+	return {
+		vitals: { ...vitals },
+		visit: build_visit(),
+		islands: visit_islands.slice(),
+		firsts: visit_firsts.slice(),
+		shifts: visit_shifts.slice(),
+		longtasks: visit_longtasks.slice(),
+		...longtasks_from_frames ? { longtasks_from: "frames" } : {},
+		...island_boxes ? { shifts_from: "boxes" } : {},
+		marks: visit_marks.slice(),
+		snapshots: snapshots.slice(),
+		cpu: {
+			state: cpu ? "recording" : cpu_kept.length ? "done" : "off",
+			off: cpu_off,
+			traces: cpu_kept.slice()
+		}
+	};
+}
+/** @internal tests */
+function _reset_beacon() {
+	const g = globalThis;
+	if (!self_api || g[BEACON_KEY] === self_api) delete g[BEACON_KEY];
+	target = void 0;
+	queue = [];
+	marks = [];
+	scheduled = false;
+	vitals = null;
+	vitals_sent = false;
+	cpu = null;
+	cpu_sent = false;
+	cpu_kept = [];
+	cpu_off = null;
+	icpu = null;
+	if (icpu_timer) clearTimeout(icpu_timer);
+	icpu_timer = null;
+	icpu_done = false;
+	icpu_caught = null;
+	opted = void 0;
+	failed_fps.clear();
+	failed_spans.clear();
+	failed_turns.clear();
+	visit_navs = [];
+	first_nav_t = void 0;
+	snapshot_firsts = 0;
+	landing_page = null;
+	seen_resources = [];
+	faces_memo = null;
+	dom_memo = null;
+	preloads_memo = null;
+	visit_islands = [];
+	visit_firsts = [];
+	visit_shifts = [];
+	visit_longtasks = [];
+	longtasks_from_frames = false;
+	island_boxes = null;
+	keepalive_queued = 0;
+	visit_scripts = /* @__PURE__ */ new Map();
+	visit_forced = [];
+	visit_scroll_jank = [];
+	scroll_times = [];
+	visit_interaction = null;
+	visit_interaction_id = 0;
+	visit_interaction_span = null;
+	visit_frames = [];
+	visit_warnings = [];
+	visit_holes_failed = [];
+	visit_holes_answered = [];
+	visit_hole_batches = [];
+	visit_entry_fallbacks = [];
+	holes_answered_els = /* @__PURE__ */ new WeakSet();
+	hole_fetches = /* @__PURE__ */ new Map();
+	visit_marks = [];
+	visit_paints = {};
+	lcp_el = lcp_region = null;
+	snapshots = [];
+	visit_sent = false;
+	early_visit_done = false;
+	resends = 0;
+}
+/** @internal tests */
+function _beacon_state() {
+	return {
+		target,
+		queued: queue.length,
+		marks: marks.length,
+		scheduled,
+		snapshots: snapshots.length
+	};
+}
+/** @internal tests: the size-aware send */
+const _beacon_send = send;
+/** @internal tests: a send from inside the hide (a page leaving while it still reads "visible") */
+function _beacon_send_leaving(body, slim) {
+	leaving = true;
+	try {
+		send(body, slim);
+	} finally {
+		leaving = false;
+	}
+}
+if (typeof document !== "undefined" && owner() === null && (devtools_measures() || !!document.querySelector("meta[name=\"ogygia-profiler-beacon\"]")) && !supports("longtask")) watch_frame_gaps();
+export { _beacon_send, _beacon_send_leaving, _beacon_state, _reset_beacon, attr_changes, beacon_entry_fallback, beacon_failed, beacon_hole_answered, beacon_hole_batch_missed, beacon_hole_failed, beacon_hole_fetched, beacon_hydrated, beacon_mark, beacon_nav, beacon_page, beacon_record_cpu, beacon_warning, beacon_watch, hole_request_times, is_headless, resource_type, without_comments, without_runtime_marks };