@ogygia/devtools 0.0.0-stage → 0.11.0

package/dist/profiler/report.js

@@ -0,0 +1,2638 @@
+import { another_routes_file } from "./route-files.js";
+import { sequential_ms } from "./net.js";
+import { browser_findings, browser_page_report } from "./browser-findings.js";
+import { memo_candidates, span_values, sync_io } from "./insights.js";
+import { fmt_bytes, page_score } from "./score.js";
+import { unread_rows } from "./drill.js";
+import { render_steps } from "./steps.js";
+import { own_requests } from "./own-requests.js";
+import { io_kind } from "./async-io.js";
+import { PHASE_LABEL, chain_steps } from "./timeline.js";
+import { DOM_LARGE, TESTING_ENGINE_VERSION, browser_of, engine_of, explain_held_open, fp_compare, hazard_fix, hazard_words, inline_threshold_tune, late_found, lcp_font, lcp_rivals, runtime_scripts, vital_parts } from "@ogygia/core/insights";
+import { unscoped_finding } from "@ogygia/core/internal/instruments";
+// src/profiler/report.ts
+/** a file's name from its URL, for a score detail line */
+function asset_name(url) {
+	const q = url.indexOf("?");
+	const path = q === -1 ? url : url.slice(0, q);
+	return path.slice(path.lastIndexOf("/") + 1) || path;
+}
+/** The union of intervals' length: what overlapping spans cost in wall time. */
+function wall_of(ivs) {
+	const sorted = [...ivs].sort((a, b) => a[0] - b[0]);
+	let wall = 0;
+	let cur = null;
+	for (const [a, b] of sorted) if (cur && a <= cur[1]) cur[1] = Math.max(cur[1], b);
+	else {
+		if (cur) wall += cur[1] - cur[0];
+		cur = [a, b];
+	}
+	if (cur) wall += cur[1] - cur[0];
+	return wall;
+}
+/** FAIR SHARES of overlapping intervals: at every instant the wall is split evenly among the
+*  intervals open then, so the shares add up to exactly the union's length. For 242 renders run
+*  together, one's start-to-end (97 ms) is mostly waiting on the other 241; its share (0.8 ms) is
+*  its part of the 185 ms they cost. Also the peak number open at once. O(n log n): the share of
+*  [a, b] is S(b) − S(a), where S is the running integral of 1 / (number open). */
+function fair_shares(ivs) {
+	const ev = [];
+	for (const [a, b] of ivs) {
+		ev.push([a, 1]);
+		ev.push([b, -1]);
+	}
+	ev.sort((x, y) => x[0] - y[0] || x[1] - y[1]);
+	const times = [];
+	const integral = [];
+	let open = 0;
+	let peak = 0;
+	let s = 0;
+	let t_prev = ev.length ? ev[0][0] : 0;
+	for (const [t, d] of ev) {
+		if (open > 0) s += (t - t_prev) / open;
+		t_prev = t;
+		open += d;
+		if (open > peak) peak = open;
+		times.push(t);
+		integral.push(s);
+	}
+	const at = (t) => {
+		let lo = 0;
+		let hi = times.length - 1;
+		let k = 0;
+		while (lo <= hi) {
+			const mid = lo + hi >> 1;
+			if (times[mid] <= t) {
+				k = mid;
+				lo = mid + 1;
+			} else hi = mid - 1;
+		}
+		return integral[k] ?? 0;
+	};
+	return {
+		shares: ivs.map(([a, b]) => Math.max(0, at(b) - at(a))),
+		peak
+	};
+}
+/** Fold the recording's spans per name. */
+function span_rows(spans) {
+	if (!spans?.length) return [];
+	const by = /* @__PURE__ */ new Map();
+	for (const s of spans) {
+		let g = by.get(s.name);
+		if (!g) by.set(s.name, g = {
+			list: [],
+			callers: /* @__PURE__ */ new Map()
+		});
+		g.list.push(s);
+		if (s.caller) g.callers.set(s.caller, (g.callers.get(s.caller) ?? 0) + 1);
+	}
+	const r2 = (n) => Math.round(n * 100) / 100;
+	const children = /* @__PURE__ */ new Map();
+	for (const s of spans) if (s.parent !== void 0) (children.get(s.parent) ?? children.set(s.parent, []).get(s.parent)).push(s);
+	const self_of = (s) => {
+		if (s.open || s.ms < 0) return 0;
+		const kids = children.get(s.id);
+		if (!kids?.length) return s.ms;
+		const end = s.start + s.ms;
+		const inside = kids.filter((k) => !k.open && k.ms >= 0).map((k) => [Math.max(k.start, s.start), Math.min(k.start + k.ms, end)]).filter(([a, b]) => b > a);
+		return Math.max(0, s.ms - wall_of(inside));
+	};
+	return [...by.entries()].map(([name, g]) => {
+		const done = g.list.filter((s) => !s.open && s.ms >= 0).map((s) => s.ms).sort((a, b) => a - b);
+		const hit = g.list.filter((s) => s.attrs?.cache === "hit").length;
+		const miss = g.list.filter((s) => s.attrs?.cache === "miss");
+		const keys = /* @__PURE__ */ new Set();
+		for (const s of g.list) for (const k of Object.keys(s.attrs ?? {})) if (k !== "cache") keys.add(k);
+		const finished = g.list.filter((s) => !s.open && s.ms >= 0);
+		const wall = wall_of(finished.map((s) => [s.start, s.start + s.ms]));
+		const fair = fair_shares(finished.map((s) => [s.start, s.start + s.ms]));
+		const share = new Map(finished.map((s, i) => [s, fair.shares[i]]));
+		const share_sorted = [...fair.shares].sort((a, b) => a - b);
+		const by = {};
+		for (const k of keys) {
+			const groups = /* @__PURE__ */ new Map();
+			let usable = true;
+			for (const s of finished) {
+				const v = s.attrs?.[k];
+				if (v === void 0) continue;
+				if (typeof v !== "string" && typeof v !== "boolean") {
+					usable = false;
+					break;
+				}
+				const key = String(v);
+				(groups.get(key) ?? groups.set(key, []).get(key)).push(s);
+				if (groups.size > 60) {
+					usable = false;
+					break;
+				}
+			}
+			if (!usable || groups.size < 2 || groups.size > g.list.length / 2) continue;
+			const rows = [...groups].map(([value, list]) => {
+				const sorted = list.map((s) => s.ms).sort((a, b) => a - b);
+				return {
+					value,
+					count: list.length,
+					total_ms: r2(sorted.reduce((a, c) => a + c, 0)),
+					wall_ms: r2(wall_of(list.map((s) => [s.start, s.start + s.ms]))),
+					share_ms: r2(list.reduce((a, s) => a + (share.get(s) ?? 0), 0)),
+					p50_ms: sorted[Math.floor(sorted.length / 2)] ?? 0,
+					max_ms: sorted.at(-1) ?? 0
+				};
+			}).sort((a, b) => b.wall_ms - a.wall_ms || b.total_ms - a.total_ms);
+			if (rows.length > 12) {
+				const rest = rows.splice(12);
+				rows.push({
+					value: `(${rest.length} more)`,
+					count: rest.reduce((a, r) => a + r.count, 0),
+					total_ms: r2(rest.reduce((a, r) => a + r.total_ms, 0)),
+					wall_ms: r2(rest.reduce((a, r) => a + r.wall_ms, 0)),
+					share_ms: r2(rest.reduce((a, r) => a + r.share_ms, 0)),
+					p50_ms: 0,
+					max_ms: Math.max(...rest.map((r) => r.max_ms))
+				});
+			}
+			by[k] = rows;
+		}
+		return {
+			name,
+			count: g.list.length,
+			total_ms: r2(done.reduce((a, c) => a + c, 0)),
+			wall_ms: r2(wall),
+			self_ms: r2(finished.reduce((a, s) => a + self_of(s), 0)),
+			by,
+			share_p50_ms: r2(share_sorted[Math.floor(share_sorted.length / 2)] ?? 0),
+			peak: fair.peak,
+			p50_ms: done[Math.floor(done.length / 2)] ?? 0,
+			max_ms: done.at(-1) ?? 0,
+			errors: g.list.filter((s) => s.error).length,
+			open: g.list.filter((s) => s.open).length,
+			...hit || miss.length ? { cache: {
+				hit,
+				miss: miss.length,
+				miss_ms: r2(miss.reduce((a, s) => a + Math.max(s.ms, 0), 0))
+			} } : {},
+			callers: [...g.callers.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([c]) => c),
+			attr_keys: [...keys].sort()
+		};
+	}).sort((a, b) => b.total_ms - a.total_ms);
+}
+const fmt_ms = (n) => n >= 100 ? n.toFixed(0) : n >= 10 ? n.toFixed(1) : n.toFixed(2);
+const fmt_pct = (part, whole) => whole > 0 ? (part / whole * 100).toFixed(1) + "%" : "—";
+const round1 = (n) => Math.round(n * 10) / 10;
+/** The dev server's own packages: their work (module loading, transforms) exists only in dev. */
+const DEV_TOOLS = /* @__PURE__ */ new Set([
+	"vite",
+	"rolldown",
+	"rollup",
+	"esbuild",
+	"vite-node",
+	"vitefu",
+	"postcss",
+	"lightningcss",
+	"@sveltejs/vite-plugin-svelte"
+]);
+/** A sampled origin that is a dev tool's: `fn (vite)` — a package in the brackets, not a `file:line`. */
+function dev_tool_caller(caller) {
+	const open = caller.lastIndexOf("(");
+	if (open === -1 || !caller.endsWith(")")) return false;
+	const pkg = caller.slice(open + 1, -1);
+	return DEV_TOOLS.has(pkg) || pkg.startsWith("@rolldown/") || pkg.startsWith("@vitejs/");
+}
+const CALL_KEYWORDS = /* @__PURE__ */ new Set([
+	"if",
+	"for",
+	"while",
+	"switch",
+	"return",
+	"await",
+	"function",
+	"catch",
+	"typeof",
+	"new",
+	"yield"
+]);
+/**
+* Where inside a hot function its time lands, when one line holds the biggest share and it is not
+* the function's own first line: that line, its code, and the function it calls there. Once V8
+* inlines a callee its time is the caller's own — a load "burning" 85 ms is often one call in it
+* (measured on /inferno: newestReview inlined into load, named in one run of six). No regex.
+*/
+function hot_line_of(f, app_fns) {
+	const top = f.lines?.[0];
+	if (!top || top.line === f.line || top.ms < f.self_ms * .4 || !f.src) return null;
+	const text = f.src.lines[top.line - f.src.start];
+	if (text === void 0) return null;
+	const code = text.trim();
+	if (!code) return null;
+	let calls;
+	let start = -1;
+	for (let i = 0; i < code.length; i++) {
+		const c = code.charCodeAt(i);
+		if (c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 36) {
+			if (start === -1) start = i;
+			continue;
+		}
+		if (c === 40 && start !== -1) {
+			const name = code.slice(start, i);
+			const plain = (start === 0 || code.charCodeAt(start - 1) !== 46) && name.charCodeAt(0) >= 97 && name.charCodeAt(0) <= 122;
+			if (!CALL_KEYWORDS.has(name) && name !== f.name && (app_fns.has(name) || plain)) {
+				calls = name;
+				break;
+			}
+		}
+		start = -1;
+	}
+	return {
+		line: top.line,
+		ms: top.ms,
+		code: code.length > 100 ? code.slice(0, 99) + "…" : code,
+		...calls ? { calls } : {}
+	};
+}
+/** A render that mostly waited: on its timeline, waiting (calls, and what no hook saw) is 60% of a
+*  render of 20 ms or more; with no timeline, the window's CPU under a quarter (the old reading). */
+function mostly_waited(tl, busy_pct) {
+	if (!tl) return busy_pct < 25;
+	return tl.window_ms >= 20 && tl.wait_ms + tl.gap_ms >= tl.window_ms * .6;
+}
+/** "most of it" only when it is (over half); the biggest of several smaller parts otherwise */
+const share_word = (part, whole) => whole > 0 && part > whole * .5 ? "most of it" : "the biggest part";
+/** Three significant figures — for costs that can be nanoseconds (a getter called five million
+*  times) where a fixed decimal rounds the whole signal to zero. */
+const sig3 = (n) => n === 0 || !Number.isFinite(n) ? 0 : Number(n.toPrecision(3));
+/** ms per call: `null` when the call count is unknown (an anonymous function coverage cannot
+*  count) — dividing by one there would report the whole total as the cost of a single call. */
+const per_call = (total_ms, calls) => calls ? sig3(total_ms / calls) : null;
+const fmt_kb = (bytes) => bytes < 1024 && bytes > 0 ? `${bytes} B` : `${Math.round(bytes / 1024)} KB`;
+/** page mode renders the page N times; per-render figures divide by it */
+const runs_of = (meta) => meta.trigger === "page" ? Math.max(meta.runs?.length ?? 1, 1) : 1;
+/** A URL path with its variable segments (numbers, uuids, hashes, long tokens) folded to `:id`. */
+function path_template(url) {
+	try {
+		const u = new URL(url);
+		const tpl = u.pathname.split("/").map((seg) => /^\d+$/.test(seg) || /^[A-Za-z]{0,4}[-_]?\d+$/.test(seg) || /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(seg) || /^[0-9a-f]{16,}$/i.test(seg) || seg.length > 20 && /\d/.test(seg) ? ":id" : seg).join("/");
+		return {
+			host: u.host,
+			tpl
+		};
+	} catch {
+		return {
+			host: "",
+			tpl: url
+		};
+	}
+}
+/** N+1 shapes: the same endpoint hit once per item. */
+function n_plus_one(net, min = 5) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const c of net) {
+		if (c.ms < 0) continue;
+		const { host, tpl } = path_template(c.url);
+		if (!tpl.includes(":id") && !c.url.includes("?")) continue;
+		const key = c.method + " " + host + tpl;
+		const g = groups.get(key) ?? {
+			host,
+			tpl,
+			count: 0,
+			ms: 0
+		};
+		g.count++;
+		g.ms += c.ms + (c.body_ms ?? 0);
+		groups.set(key, g);
+	}
+	return [...groups.values()].filter((g) => g.count >= min).sort((a, b) => b.count - a.count).map((g) => ({
+		...g,
+		ms: Math.round(g.ms * 100) / 100
+	}));
+}
+/** The plain-language bottleneck read, as structured data. The HTML verdict and
+* the JSON report both render from this, so they never drift. */
+/** THE PAGE'S WEIGHT, as findings: the JS it runs at start (and what the biggest files hold), what
+*  blocks the first paint, the code kept for later. From page-assets.ts — the score reads the same. */
+/** The page's own origin, from its weighed files: its islands' (always same-origin), else its first
+*  script's. '' when nothing was weighed. */
+function page_origin(pa) {
+	if (!pa) return "";
+	for (const via of [
+		"island",
+		"script",
+		"modulepreload"
+	]) for (const a of pa.assets) if (a.via === via) try {
+		return new URL(a.url).origin;
+	} catch {}
+	return "";
+}
+/** Main-thread ms per host from the browser CPU analysis (functions by their script URL). */
+function cpu_by_host(extras) {
+	const a = extras.client_cpu?.analysis;
+	if (!a) return null;
+	const m = /* @__PURE__ */ new Map();
+	for (const f of a.functions) {
+		if (!f.path.startsWith("http")) continue;
+		let host = "";
+		try {
+			host = new URL(f.path).host;
+		} catch {
+			continue;
+		}
+		m.set(host, (m.get(host) ?? 0) + f.self_ms);
+	}
+	return m;
+}
+/**
+* THE PAGE'S JS AT START, as the score and the findings both read it: the files weighed from the
+* HTML and their imports, plus the scripts the profiler user's own browser loaded at runtime that
+* nothing in the HTML names (runtime_scripts — a CDN library fetching its parts, a runtime's
+* on-demand chunk). Without the second half, a page that loads its JS from a script weighed light.
+*/
+function start_js(extras) {
+	const pa = extras.assets;
+	if (!pa) return null;
+	let runtime = null;
+	let woke_early = null;
+	let runtime_parts = null;
+	const v = extras.visit;
+	if (v?.resources.length) {
+		const until = (v.nav.load ?? v.nav.res_end) + 3e3;
+		const loaded_by = v.nav.load ?? v.nav.dcl ?? v.nav.res_end;
+		const at_start = new Set(v.resources.filter((r) => r.type === "script" && r.start <= loaded_by).map((r) => r.url));
+		for (const a of pa.assets) if (a.lazy && a.kind === "script" && at_start.has(a.url)) {
+			const b = a.phase ? runtime_parts ??= {
+				bytes: 0,
+				wire: 0,
+				files: 0
+			} : woke_early ??= {
+				bytes: 0,
+				wire: 0,
+				files: 0
+			};
+			b.bytes += a.bytes;
+			b.wire += a.wire;
+			b.files++;
+		}
+		runtime = runtime_scripts(pa.assets, v.resources, page_origin(pa), until);
+	}
+	const t = pa.totals;
+	return {
+		js: t.js + (runtime?.bytes ?? 0) + (woke_early?.bytes ?? 0) + (runtime_parts?.bytes ?? 0),
+		js_wire: t.js_wire + (runtime?.wire ?? 0) + (woke_early?.wire ?? 0) + (runtime_parts?.wire ?? 0),
+		js_files: t.js_files + (runtime?.files ?? 0) + (woke_early?.files ?? 0) + (runtime_parts?.files ?? 0),
+		runtime,
+		woke_early,
+		runtime_parts
+	};
+}
+/** The modules the build shipped twice whose copies are both in files this page loads (its weighed
+*  files and its visit's scripts), each with the bytes the second copy costs; the costliest first. */
+function page_duplicates(extras) {
+	if (!extras.dupes?.length || !extras.assets) return [];
+	const path_of = (u) => {
+		try {
+			return new URL(u).pathname;
+		} catch {
+			return u;
+		}
+	};
+	const loaded = /* @__PURE__ */ new Set();
+	for (const a of extras.assets.assets) loaded.add(path_of(a.url));
+	for (const r of extras.visit?.resources ?? []) if (r.type === "script") loaded.add(path_of(r.url));
+	const here = (file) => {
+		for (const p of loaded) if (p.endsWith(file)) return true;
+		return false;
+	};
+	return extras.dupes.map((d) => ({
+		name: d.name,
+		copies: d.copies.filter((c) => here(c.file))
+	})).filter((d) => d.copies.length >= 2).map((d) => ({
+		...d,
+		extra: d.copies.reduce((s, c) => s + c.bytes, 0) - Math.max(...d.copies.map((c) => c.bytes))
+	})).sort((a, b) => b.extra - a.extra);
+}
+/** A visit that loaded with the devtools dock open and recorded its first paint right after the
+*  dock began to show (the same line as the Page tab's dock-in-paint): its paints may be the dock's. */
+function dock_skewed(v) {
+	const fcp = v?.paints?.fcp;
+	const at = v?.dock_open_at;
+	return typeof fcp === "number" && typeof at === "number" && fcp >= at && fcp - at <= 250;
+}
+/** What a browser hid, from what the report knows itself. Safari reports each of another origin's
+*  files as 0 bytes (Timing-Allow-Origin or not): the report weighed the files the page names and
+*  their imports, and a visit from another engine measured what scripts loaded — a hidden size takes
+*  the weight, marked. And only Chromium says which files held the first paint: for another engine,
+*  the files the HTML makes blocking (a head stylesheet, a classic sync script) are marked so. And a
+*  font downloaded again takes the Vary header the weighing read (the cause, in Safari, with Origin). */
+function with_hidden_filled(v, origin, assets, other) {
+	if (!origin) return v;
+	const known = /* @__PURE__ */ new Map();
+	for (const r of other?.resources ?? []) if (r.size) known.set(r.url, {
+		size: r.size,
+		transfer: r.transfer ?? 0
+	});
+	for (const a of assets?.assets ?? []) if (a.bytes) known.set(a.url, {
+		size: a.bytes,
+		transfer: a.wire
+	});
+	const engine = engine_of(v.ua);
+	const blocking = engine && engine !== "chromium" ? new Set((assets?.assets ?? []).filter((a) => a.blocking).map((a) => a.url)) : null;
+	if (!known.size && !blocking?.size) return v;
+	let filled = false;
+	const resources = v.resources.map((r) => {
+		let out = r;
+		if (blocking?.has(r.url) && !r.blocking) out = {
+			...out,
+			blocking: true
+		};
+		const w = r.size || r.url.startsWith(origin + "/") ? void 0 : known.get(r.url);
+		if (w) out = {
+			...out,
+			size: w.size,
+			transfer: r.transfer || w.transfer,
+			weighed: true
+		};
+		if (out !== r) filled = true;
+		return out;
+	});
+	const vary = new Map((assets?.assets ?? []).filter((a) => a.kind === "font" && a.vary).map((a) => [a.url, a.vary]));
+	const misses = vary.size ? v.preload_misses?.map((m) => m.type === "font" && !m.vary && vary.has(m.url) ? {
+		...m,
+		vary: vary.get(m.url)
+	} : m) : void 0;
+	const misses_filled = !!misses?.some((m, i) => m !== v.preload_misses[i]);
+	return filled || misses_filled ? {
+		...v,
+		resources,
+		...misses_filled ? { preload_misses: misses } : {}
+	} : v;
+}
+/** browser findings whose answer is the screen's: below its first screen, hidden on it, images it
+*  shows smaller or lower down */
+const SCREEN_CODES = /* @__PURE__ */ new Set([
+	"eager-offscreen",
+	"eager-hidden",
+	"images-eager-below",
+	"image-oversized"
+]);
+const IN_BROWSER = "In the browser: ";
+const screen_of = (v) => v?.viewport ? `${v.viewport[0]}×${v.viewport[1]}` : null;
+/** A remote function's name from its call's address (`/<appDir>/remote/<file hash>/<name>/<argument>`),
+*  or the address when it is not one. */
+function remote_function_name(path) {
+	const parts = path.split("/");
+	const at = parts.lastIndexOf("remote", parts.length - 3);
+	return at > 0 && parts[at + 2] ? parts[at + 2] : path;
+}
+/** a path group is a warning from this much of one render (and 15% of its busy time): under it, a note */
+const PATH_WARN_MS = 3;
+/** findings about a server render — its CPU, components, calls, memory — that mean nothing when the
+*  build's file answered (no render ran: `run_static`) */
+const RENDER_ONLY = /* @__PURE__ */ new Set([
+	"low-confidence",
+	"phases",
+	"top-cpu",
+	"top-component",
+	"component-heavy",
+	"component-repeat",
+	"hot-function",
+	"cold-start",
+	"cold-instance",
+	"slower-each-run",
+	"component-cold-run",
+	"component-variance",
+	"sequential-network",
+	"mostly-waiting",
+	"slow-upstream",
+	"n-plus-one",
+	"gc-heavy",
+	"gc-pause",
+	"gc-cause",
+	"alloc-burst",
+	"path-group",
+	"serialization",
+	"markup-heavy",
+	"logic-heavy",
+	"hot-list",
+	"retained-per-render",
+	"mem-growth",
+	"span-slow",
+	"span-repeat",
+	"memo-candidate",
+	"deopt",
+	"sync-io",
+	"billed-wait",
+	"sequential-awaits",
+	"unseen-wait",
+	"window-requests"
+]);
+function page_weight_findings(meta, extras, info, warn) {
+	const pa = extras.assets;
+	if (!pa) {
+		if (extras.assets_missing) info("page-unweighed", `The page's files were not weighed: ${extras.assets_missing}.`);
+		return;
+	}
+	const t = {
+		...pa.totals,
+		...start_js(extras)
+	};
+	const islands = island_rows_of(meta).length;
+	const named = pa.assets.filter((x) => x.kind === "script" && !x.lazy).slice(0, 3).map((x) => `${asset_name(x.url)} ${fmt_bytes(x.bytes)}${x.contains?.length ? ` (${x.contains.slice(0, 4).join(", ")})` : ""}`);
+	const holes_answered = new Set((extras.visit?.holes_answered ?? []).map((h) => h.id)).size;
+	const by_holes = !!t.runtime?.island_entries && holes_answered > 0;
+	if (t.runtime && t.runtime.bytes >= 10240) {
+		const rt = t.runtime;
+		const own = rt.by.find((b) => b.who === "this app");
+		const others = rt.by.filter((b) => b.who !== "this app");
+		(rt.bytes >= 51200 ? warn : info)("runtime-scripts", by_holes && own ? `Your browser also loaded ${fmt_bytes(rt.bytes)} of JS in ${rt.files} file${rt.files === 1 ? "" : "s"} that the page's HTML and its imports never name: ${fmt_bytes(own.bytes)} (${own.files}) is this app's, the code of ${rt.island_entries} island${rt.island_entries === 1 ? "" : "s"} that arrived inside the page's holes (${holes_answered} answered) — no HTML can name what a hole will hold${others.length ? `; other scripts fetched the rest at runtime — ${others.slice(0, 3).map((b) => `${b.who} ${fmt_bytes(b.bytes)} (${b.files})`).join(", ")}` : ""}. They count in the page's JS.` : `Your browser also loaded ${fmt_bytes(rt.bytes)} of JS in ${rt.files} file${rt.files === 1 ? "" : "s"} that the page's HTML and its imports never name: other scripts fetched ${rt.files === 1 ? "it" : "them"} at runtime — ${rt.by.slice(0, 3).map((b) => `${b.who} ${fmt_bytes(b.bytes)} (${b.files})`).join(", ")}. They count in the page's JS.`, { fix: by_holes && own ? `The islands a hole holds wake as it lands: fine if they are needed at once. Otherwise give them a later wake inside the hole (\`wake: 'visible'\` or \`'interaction'\`), or make the parts that never change lakes.${others.length ? " A library that loads its own parts costs more than its first file: load it where it is used, or self-host the parts it needs." : ""}` : "A library that loads its own parts (a component CDN, a tag manager) costs more than its first file: load it where it is used, or self-host the parts it needs." });
+	}
+	{
+		const twice = page_duplicates(extras);
+		const extra = twice.reduce((s, d) => s + d.extra, 0);
+		if (twice.length && extra >= 2048) {
+			const top = twice[0];
+			(extra >= 10240 ? warn : info)("duplicate-module", `${twice.length === 1 ? `Two copies of ${top.name} ship` : `${twice.length} modules ship twice`} on this page${twice.length === 1 ? "" : ` (the heaviest, ${top.name})`}: in ${top.copies.map((c) => `${asset_name(c.file)} (${fmt_bytes(c.bytes)}${c.from ? `, from ${c.from}` : ""})`).join(" and ")}${twice.length > 1 ? `, ${fmt_bytes(extra)} loaded twice in all` : ""}. One module reached by two paths — a package's source and its build, or two of its versions — so the browser downloads, parses and runs it twice.`, { fix: "Make every import reach one copy: import the package by its public entry everywhere (not a path into its src or dist), and keep one version installed (`pnpm dedupe`, or `resolve.dedupe` in the Vite config)." });
+		}
+	}
+	if (t.js >= 153600) (t.js >= 307200 ? warn : info)("js-at-start", `The browser runs ${fmt_bytes(t.js)} of JS in ${t.js_files} files to start this page (${fmt_bytes(t.js_wire)} on the wire${t.runtime ? `, ${fmt_bytes(t.runtime.bytes)} of it loaded at runtime${by_holes ? ", mostly islands inside its holes" : " by other scripts"}` : ""}${t.woke_early ? `, ${fmt_bytes(t.woke_early.bytes)} of it islands that wake when visible and were on your first screen` : ""}${t.runtime_parts ? `, ${fmt_bytes(t.runtime_parts.bytes)} of it the ogygia runtime's parts it loaded as the islands woke` : ""})${t.lazy_js - (t.woke_early?.bytes ?? 0) - (t.runtime_parts?.bytes ?? 0) > 0 ? `, and ${fmt_bytes(t.lazy_js - (t.woke_early?.bytes ?? 0) - (t.runtime_parts?.bytes ?? 0))} more loads only when an island needs it` : ""}. The biggest: ${named.join("; ")}.`, { fix: islands ? "Wake the heaviest islands when visible or on interaction, move heavy imports server-side, or make static subtrees lakes." : "This page hydrates as a whole (no islands): render it csr=false and make only its interactive parts islands, so their code loads when they need it." });
+	else if (t.lazy_js >= 51200) info("js-lazy", `${fmt_bytes(t.lazy_js)} of island JS waits until it is needed: the page starts with ${fmt_bytes(t.js)}.`);
+	if (t.blocking_count >= 3 || t.blocking >= 102400) {
+		const files = pa.assets.filter((x) => x.blocking).slice(0, 4).map((x) => `${asset_name(x.url)} ${fmt_bytes(x.bytes)}`);
+		const tune = inline_threshold_tune(pa.assets.filter((x) => x.blocking));
+		warn("render-blocking", `${t.blocking_count} files (${fmt_bytes(t.blocking)}) must arrive before anything paints: ${files.join(", ")}.`, { fix: tune ? `Inline the small stylesheets: with \`kit: { inlineStyleThreshold: ${tune.threshold} }\` in svelte.config.js, ${tune.files} of these sheets (${fmt_bytes(tune.bytes)}) arrive inside the HTML, and the first paint waits on ${t.blocking_count - tune.files} file${t.blocking_count - tune.files === 1 ? "" : "s"} instead of ${t.blocking_count}. Merge or trim the rest; load scripts as modules or with defer.` : "Inline the small stylesheets, merge the rest, load scripts as modules or with defer." });
+	}
+	if (pa.unscoped?.length) {
+		const f = unscoped_finding(pa.unscoped);
+		warn(f.code, f.message, { fix: f.fix });
+	}
+	if (pa.missed.length) {
+		const why = /* @__PURE__ */ new Map();
+		for (const m of pa.missed_why ?? []) {
+			const k = m.why.startsWith("status ") || m.why.startsWith("error") ? m.why.split(":")[0] : m.why;
+			why.set(k, (why.get(k) ?? 0) + 1);
+		}
+		const reasons = [...why].map(([k, n]) => `${n} ${k}`).join(", ");
+		info("assets-missed", `${pa.missed.length} file(s) the page loads could not be weighed${reasons ? ` (${reasons})` : " (a 404, a timeout, or the time budget)"}: ${pa.missed.slice(0, 3).map(asset_name).join(", ")}.${why.has("budget") || why.has("timeout") ? " Profile with `weigh=full` for totals that hold run to run." : ""}`);
+	}
+}
+function derive_findings(a, meta, extras) {
+	const out = [];
+	const info = (code, message, extra = {}) => out.push({
+		severity: "info",
+		code,
+		message,
+		...extra
+	});
+	const warn = (code, message, extra = {}) => out.push({
+		severity: "warn",
+		code,
+		message,
+		...extra
+	});
+	const R = runs_of(meta);
+	const pr = (ms) => ms / R;
+	const per_r = R > 1 ? " per render" : "";
+	const busy_pct = a.duration_ms > 0 ? a.busy_ms / a.duration_ms * 100 : 0;
+	const net = extras.net.filter((c) => c.ms >= 0);
+	const net_total = net.reduce((s, c) => s + c.ms + (c.body_ms ?? 0), 0);
+	const seq = sequential_ms(extras.net);
+	const net_errors = extras.net.filter((c) => c.error).length;
+	const tl = a.timeline;
+	info("summary", `Over ${fmt_ms(meta.duration_ms)} ms the CPU was busy ${busy_pct.toFixed(0)}%` + (net.length ? ` and ${net.length} outbound network calls took ${fmt_ms(net_total)} ms combined.` : "."));
+	if (meta.trigger === "page") {
+		if (meta.redirected_from && meta.page) info("redirected", meta.redirect_stub ? `Profiled ${meta.page}: ${meta.redirected_from} is a redirect the build wrote as a page (a meta refresh, answered 200, since a prerendered route has no server to send a 3xx), and its visitors land on ${meta.page}.` : `Profiled ${meta.page} — followed a redirect from ${meta.redirected_from}.`);
+		const status = meta.run_status ?? 200;
+		const bytes = meta.run_bytes ?? 0;
+		if (status >= 300) warn("not-a-render", `The profiled renders returned HTTP ${status}, not a page. This is almost always an unfollowed redirect or an error route — the numbers below are not your page. Check the path.`);
+		else if (bytes > 0 && bytes < 512) warn("not-a-render", `Each render returned only ${bytes} bytes — too small to be the real page (an error, an empty shell, or a cached stub). The profile below is not representative.`);
+		else if (a.components.length === 0 && a.sample_count < 200) {
+			const runs = [...meta.runs ?? []].sort((x, y) => x - y);
+			const ms = runs.length ? runs[runs.length >> 1] : void 0;
+			info("low-confidence", `${ms !== void 0 ? `This page renders in about ${fmt_ms(ms)} ms: o` : "O"}nly ${a.sample_count} CPU sample${a.sample_count === 1 ? "" : "s"} and no component took measurable time — there is little here to make faster, and too little for the numbers below to be exact. (Expected a heavier page? A cached or prerendered answer looks like this too: check the URL.)`);
+		}
+		if (meta.warmup_ms !== void 0 && meta.runs?.length) {
+			const median = [...meta.runs].sort((x, y) => x - y)[Math.floor(meta.runs.length / 2)];
+			if (median > 0 && meta.warmup_ms > median * 8 && meta.warmup_ms > 200) info("cached-after-first", `The first (warm-up) render took ${fmt_ms(meta.warmup_ms)} ms but the timed runs averaged ~${fmt_ms(median)} ms — the app appears to cache this page after the first render, so the profile reflects cache hits, not the ${fmt_ms(meta.warmup_ms)} ms first paint.`);
+		}
+		if (meta.budget_note) info("budget", meta.budget_note);
+		if (meta.heap_guard?.skipped.length) warn("heap-near-limit", `The server's heap was nearly full (${meta.heap_guard.used_mb} of ${meta.heap_guard.limit_mb} MB), so the profiler left out ${meta.heap_guard.skipped.join(", ")}: one more render of this page could have run it out of memory and ended the process. What it keeps per render is the cause.`, { fix: "Fix what a render keeps alive (the Kept per render pattern names the line), and restart the server before profiling again." });
+	}
+	if (tl) {
+		const parts = tl.phases.filter((p) => p.cpu_ms + p.wait_ms >= tl.window_ms * .03).map((p) => `${PHASE_LABEL[p.phase]} ${fmt_ms(p.cpu_ms)} ms` + (p.wait_ms >= .5 ? ` + ${fmt_ms(p.wait_ms)} ms waiting` : "") + (p.top?.length && p.cpu_ms >= tl.window_ms * .1 ? ` (${p.top.slice(0, 2).map((o) => `${o.label} ${fmt_ms(o.ms)} ms`).join(", ")})` : ""));
+		if (parts.length) info("phases", `Of the ${fmt_ms(tl.window_ms)} ms render: ${parts.join(" · ")}` + (tl.gap_ms >= tl.window_ms * .05 ? ` · ${fmt_ms(tl.gap_ms)} ms unaccounted` : "") + ".");
+		if (meta.lambda && tl.wait_ms >= tl.window_ms * .3 && tl.wait_ms >= 50) info("billed-wait", `On AWS Lambda a request is billed for its whole duration: ${fmt_ms(tl.window_ms)} ms here, and ${fmt_ms(tl.wait_ms)} ms of it (${fmt_pct(tl.wait_ms, tl.window_ms)}) is waiting on calls, not computing. Every millisecond of waiting cut is billed time cut, the same as CPU.`, { fix: "Start independent calls together, cache what repeats across requests, and fetch less per render: the wait patterns above name the lines." });
+		const group = [...tl.parallelizable].sort((x, y) => y.save_ms - x.save_ms)[0];
+		if (group && group.save_ms >= Math.max(5, tl.window_ms * .05)) warn("sequential-awaits", `${group.calls.length} calls ran one after another for ${fmt_ms(group.ms)} ms: ${group.calls.join(", ")}. Started together they would cost ${fmt_ms(group.ms - group.save_ms)} ms — about ${fmt_ms(group.save_ms)} ms saved.`, { fix: "Start them together (Promise.all) when they are independent; a call that needs an earlier result stays sequential." });
+		if (tl.gap_ms > tl.window_ms * .3 && tl.gap_ms > 20) warn("unseen-wait", `${fmt_ms(tl.gap_ms)} ms (${fmt_pct(tl.gap_ms, tl.window_ms)}) of the render waited on something the recorder cannot see — a database driver over its own socket pool, a worker, a queue.`, { fix: "Wrap that client in performance.measure() spans; they show under User timings and on the timeline next time." });
+	}
+	for (const g of n_plus_one(net).slice(0, 2)) warn("n-plus-one", `${g.count} calls to ${g.host}${g.tpl} — one per item, ${fmt_ms(g.ms)} ms together.`, { fix: "Batch them: one request with the ids (or a bulk endpoint), or fetch the list with its children included." });
+	if (meta.trigger === "window") {
+		const reqs = meta.requests.filter((r) => !r.internal && r.ms >= 0);
+		if (reqs.length) {
+			const slow = [...reqs].sort((x, y) => y.ms - x.ms).slice(0, 3);
+			const split = (r) => {
+				const wait = Math.max(0, r.ms - r.cpu_ms);
+				return `${r.method} ${r.path.split("?")[0]} ${fmt_ms(r.ms)} ms (${fmt_ms(r.cpu_ms)} ms CPU, ${fmt_ms(wait)} ms waiting${r.net_count ? `, ${fmt_ms(r.net_ms)} ms of it on ${r.net_count} outbound call${r.net_count === 1 ? "" : "s"}` : ""})`;
+			};
+			const overlapped = reqs.some((r) => r.inflight > 0);
+			(slow[0].ms >= 1e3 ? warn : info)("window-requests", `${reqs.length} request${reqs.length === 1 ? "" : "s"} in the window; the slowest: ${slow.map(split).join(" · ")}.` + (overlapped ? " Some ran at the same time: their CPU is the process’s over each one, so it overlaps." : ""), slow[0].ms >= 1e3 ? { fix: slow[0].cpu_ms >= slow[0].ms * .5 ? "It is computing: profile that page on its own (page mode) for the lines." : "It is waiting: the network table and the upstream split say on what." } : {});
+		}
+	}
+	if (meta.trigger !== "window" && !tl?.parallelizable.length && net.length >= 2 && seq > meta.duration_ms * .5 && busy_pct < 60) warn("sequential-network", `Network calls ran back-to-back for ${fmt_ms(seq)} ms of the window — usually sequential awaits.`, { fix: "Start independent calls together with Promise.all." });
+	else if (meta.trigger !== "window" && (meta.run_status ?? 200) < 300 && mostly_waited(tl, busy_pct) && (net.length || !tl || tl.wait_ms >= tl.gap_ms)) {
+		const part = tl ? `: ${fmt_ms(tl.wait_ms + tl.gap_ms)} of the ${fmt_ms(tl.window_ms)} ms render` : "";
+		info("mostly-waiting", net.length ? `Mostly waiting on the network, not computing${part}.` : `Mostly waiting, not computing${part}, and on no HTTP call: a timer, a file, or a database/socket client (the waiting table names it).`);
+	}
+	const th = top_hosts(net)[0];
+	if (th && th.total > meta.duration_ms * .2) info("slow-upstream", `Slowest upstream: ${th.host || "(unknown)"} — ${th.count} calls, ${fmt_ms(th.total)} ms.`);
+	if (net_errors) warn("network-errors", `${net_errors} network call${net_errors > 1 ? "s" : ""} failed.`);
+	const tb = a.buckets.find((b) => b.category !== "idle" && b.category !== "profiler");
+	if (tb) info("top-cpu", `Biggest CPU consumer: ${tb.key} (${fmt_ms(pr(tb.self_ms))} ms${per_r}, ${fmt_pct(tb.self_ms, a.busy_ms)} of busy time).`);
+	const by_total = [...a.components].sort((x, y) => y.total_ms - x.total_ms);
+	const is_root = (n) => /^_(?:page|layout|error)$|^Root$/.test(n);
+	const heavy = by_total.find((c) => !is_root(c.name) && c.total_ms >= a.busy_ms * .2 && c.total_ms >= 5) ?? by_total.find((c) => c.total_ms >= a.busy_ms * .2 && c.total_ms >= 5);
+	if (heavy) {
+		const n = heavy.calls ?? 0;
+		const heavy_ms = heavy.total_ms / runs_of(meta);
+		const at = {
+			anchor: `comp:${heavy.name}`,
+			file: heavy.url,
+			line: heavy.line
+		};
+		if (n >= 20) warn("component-repeat", `${heavy.name} rendered ${n} times per render — ${fmt_ms(heavy_ms)} ms, ${fmt_pct(heavy.total_ms, a.busy_ms)} of busy, ${fmt_ms(heavy_ms / n)} ms each.`, {
+			...at,
+			fix: "Render fewer: paginate or window the list, or move it below the fold into a deferred hole so the page ships without it."
+		});
+		else if (heavy_ms / Math.max(n, 1) >= 20) {
+			const inside = a.functions.find((f) => f.key !== heavy.key && f.self_ms >= heavy.total_ms * .2 && f.stacks?.[0]?.frames.some((fr) => fr.n === heavy.name));
+			warn("component-heavy", `One render of ${heavy.name} costs ${fmt_ms(heavy_ms / Math.max(n, 1))} ms (${fmt_pct(heavy.total_ms, a.busy_ms)} of busy)` + (inside ? ` — ${share_word(inside.self_ms, heavy.total_ms)} is ${inside.name} (${inside.url}:${inside.line}), ${fmt_ms(inside.self_ms / runs_of(meta))} ms.` : "."), {
+				...at,
+				fix: "Compute the expensive part once (in load, or a per-request cache) and pass the result as a prop, or render it in a deferred hole."
+			});
+		} else info("top-component", `Most expensive component: ${heavy.name} at ${fmt_ms(heavy_ms)} ms ${meta.trigger === "window" ? "across the window" : "per render"}.`, at);
+	} else if (by_total[0]) {
+		const tc = by_total[0];
+		info("top-component", `Most expensive component: ${tc.name} at ${fmt_ms(tc.total_ms / runs_of(meta))} ms ${meta.trigger === "window" ? "across the window" : "per render"}.`, {
+			anchor: `comp:${tc.name}`,
+			file: tc.url,
+			line: tc.line
+		});
+	}
+	const own = a.functions.filter((f) => f.category === "app" || f.category === "dependency");
+	const hot = own[0];
+	const top3 = own.slice(0, 3).filter((f) => f.self_ms >= 5);
+	const top3_ms = top3.reduce((s, f) => s + f.self_ms, 0);
+	const single = !!hot && hot.self_ms >= a.busy_ms * .2;
+	const crowd = !!hot && !single && top3.length === 3 && hot.self_ms >= a.busy_ms * .12 && top3_ms >= a.busy_ms * .4;
+	const where = (f) => f.label ? `the function at ${f.url}:${f.line}` : `${f.name} (${f.url}:${f.line})`;
+	if (hot && hot.self_ms >= 5 && (single || crowd)) {
+		const from = hot.stacks?.[0]?.frames.find((fr) => fr.c === "component" || fr.c === "app");
+		const spot = hot_line_of(hot, new Set(a.functions.filter((f) => f.category === "app").map((f) => f.name)));
+		const close = own.slice(1, 3).filter((f) => f.self_ms >= 5 && f.self_ms >= hot.self_ms * .75);
+		const spot_lead = crowd ? `In ${hot.name}, the biggest part` : spot && share_word(spot.ms, hot.self_ms) === "most of it" ? "Most of it" : "The biggest part";
+		warn("hot-function", (crowd ? `No one function dominates, but three together burn ${fmt_ms(pr(top3_ms))} ms${per_r} (${fmt_pct(top3_ms, a.busy_ms)} of busy): ${top3.map((f) => `${where(f)} ${fmt_pct(f.self_ms, a.busy_ms)}`).join(", ")}.` : `${hot.label ? `The function at ${hot.url}:${hot.line} (\`${hot.label}\`)` : hot.name} burns ${fmt_ms(pr(hot.self_ms))} ms${per_r} (${fmt_pct(hot.self_ms, a.busy_ms)} of busy)${hot.label ? "" : ` at ${hot.url}:${hot.line}`}` + (hot.calls ? `, ${hot.calls} calls per render` : "") + (from ? `, called from ${from.n}` : "") + "." + (close.length ? ` Close behind: ${close.map((f) => `${where(f)} ${fmt_pct(f.self_ms, a.busy_ms)}`).join(", ")}.` : "")) + (spot ? ` ${spot_lead} lands on line ${spot.line}: \`${spot.code}\`` + (spot.calls ? ` — ${spot.calls} is called there, and V8 counts a function it inlined as the caller's own time: look inside ${spot.calls}.` : ".") : ""), {
+			anchor: `fn:${hot.key}`,
+			file: hot.url,
+			line: spot?.line ?? hot.line,
+			fix: hot.category === "dependency" ? `It is ${hot.pkg}'s — cache or batch what you ask of it per request, and check the call count against what the page really needs.` : "Hoist per-request work out of per-row code, precompute it in load, or cache the result across requests."
+		});
+	}
+	const ser = a.functions.filter((f) => f.pkg === "devalue" || f.name === "stringify" && f.category === "dependency");
+	const ser_ms = Math.max(0, ser.reduce((s, f) => s + f.self_ms, 0) - kit_load_serialize_ms(a));
+	if (ser_ms >= a.busy_ms * .1 && ser_ms >= 5) warn("serialization", `Serializing data took ${fmt_ms(pr(ser_ms))} ms${per_r} (${fmt_pct(ser_ms, a.busy_ms)} of busy) — the page's load data and island props on their way to the browser.`, {
+		anchor: ser[0] ? `fn:${ser[0].key}` : void 0,
+		fix: "Ship less: return from load only what the page reads, keep big blobs out of page.data, and let islands take props rather than reading $page whole."
+	});
+	const runs = meta.trigger === "page" ? Math.max(meta.runs?.length ?? 1, 1) : 1;
+	const spans = span_rows(extras.spans);
+	const window_ms = tl?.window_ms ?? meta.duration_ms / runs;
+	const in_one = meta.trigger === "window" ? "during the window" : "in one render";
+	for (const s of spans) {
+		const per_render = s.count / runs;
+		const ms_per_render = s.total_ms / runs;
+		const site = s.callers[0] ? ` (${s.callers[0]})` : "";
+		if (s.errors) warn("span-errors", `${s.name} failed ${s.errors} time${s.errors === 1 ? "" : "s"}${site}.`, { fix: "A failed span is a request that paid for work it could not use — read the error on the Spans table." });
+		if (s.open) warn("span-open", `${s.name} never ended ${s.open} time${s.open === 1 ? "" : "s"}${site} — a hung call, or a span.start() without end().`);
+		const wall_per_render = s.wall_ms / runs;
+		if (per_render >= 5 && wall_per_render >= Math.max(5, window_ms * .05)) {
+			const bk = Object.keys(s.by)[0];
+			const top = bk ? s.by[bk][0] : void 0;
+			const overlap = s.wall_ms < s.total_ms * .6;
+			const top_share = top ? [...s.by[bk]].sort((x, y) => y.share_ms - x.share_ms)[0] : void 0;
+			const by_top = overlap ? top_share && bk && !top_share.value.startsWith("(") && top_share.share_ms >= s.wall_ms * .2 ? ` The biggest part is ${bk} ${top_share.value}: ${Math.round(top_share.count / runs)} of them, ${fmt_ms(top_share.share_ms / runs)} ms of the ${fmt_ms(wall_per_render)} ms (${fmt_pct(top_share.share_ms, s.wall_ms)}).` : "" : top && bk && !top.value.startsWith("(") && top.wall_ms >= s.wall_ms * .2 ? ` Most of it is ${bk} ${top.value}: ${Math.round(top.count / runs)} of them, ${fmt_ms(top.wall_ms / runs)} ms of wall.` : "";
+			if (overlap) warn("span-repeat", `${s.name} ran ${Math.round(per_render)} times ${in_one}${site}, up to ${s.peak} at once, and together they took ${fmt_ms(wall_per_render)} ms. Each one's part of that is about ${fmt_ms(s.share_p50_ms)} ms; its own start to end (${fmt_ms(s.p50_ms)} ms) is mostly waiting its turn behind the others.${by_top}`, { fix: "They already overlap, so batching gains little: the cost is each one (make it cheaper, or cache it) and how many there are (render fewer)." });
+			else warn("span-repeat", `${s.name} ran ${Math.round(per_render)} times ${in_one}${site}, ${fmt_ms(ms_per_render)} ms together, ${fmt_ms(s.p50_ms)} ms each.${by_top}`, { fix: "Once per item is the N+1 shape: batch it (one call for all the ids), or fetch the parent with its children included." });
+		} else if ((s.wall_ms < s.total_ms * .6 ? wall_per_render : ms_per_render) >= Math.max(10, window_ms * .2)) {
+			const together = s.wall_ms < s.total_ms * .6;
+			const took = together ? wall_per_render : ms_per_render;
+			warn("span-slow", `${s.name} took ${fmt_ms(took)} ms of the ${meta.trigger === "window" ? "window" : "render"}${site}${per_render > 1 ? `, over ${Math.round(per_render)} calls${together ? ` running together (${fmt_ms(ms_per_render)} ms summed)` : ""}` : ""}.`, { fix: "The profiler cannot see inside it — this is the wait to take to whoever owns that service, or to cache." });
+		}
+		if (s.cache && s.cache.miss_ms / runs >= Math.max(5, window_ms * .05)) warn("cache-misses", `${s.name}: ${Math.round(s.cache.miss / runs)} cache miss${s.cache.miss / runs >= 2 ? "es" : ""} per render cost ${fmt_ms(s.cache.miss_ms / runs)} ms (${s.cache.hit} hit${s.cache.hit === 1 ? "" : "s"} in the window).`, { fix: "A miss on every render is no cache: check the key, the TTL, or whether the cache is per-instance on a host that spins instances up per request." });
+	}
+	const etag = a.functions.find((f) => f.name === "hash" && f.pkg === "@sveltejs/kit");
+	if (etag && etag.self_ms >= a.busy_ms * .03 && etag.self_ms >= 3) {
+		const bytes = meta.run_bytes ?? meta.requests.find((r) => r.internal)?.og?.tail_bytes;
+		info("kit-etag", `Kit hashed the whole HTML for its ETag: ${fmt_ms(pr(etag.self_ms))} ms per render` + (bytes ? ` over ${fmt_kb(bytes)}` : "") + ". The `hash` function is Kit’s (`render_response` calls it on a page that does not stream), not your code, wherever the build put it.", {
+			anchor: `fn:${etag.key}`,
+			fix: "Kit skips the ETag on a streamed page: return a promise from a server load that the page awaits (it streams, and Kit sends no ETag). Otherwise only a smaller document helps — fewer bytes in the seed and props, less markup."
+		});
+	}
+	const og = [...meta.requests].filter((r) => r.og).sort((x, y) => y.og.seed_bytes + y.og.tail_bytes - (x.og.seed_bytes + x.og.tail_bytes))[0]?.og;
+	if (og) {
+		info("ogygia-cost", `ogygia added ${fmt_ms(og.transform_ms)} ms to the render: ${og.islands} island${og.islands === 1 ? "" : "s"}` + (og.holes ? `, ${og.holes} hole${og.holes === 1 ? "" : "s"}` : "") + `, seed ${fmt_kb(og.seed_bytes)}, props ${fmt_kb(og.tail_bytes)}` + (og.remote_seed_bytes ? `, remote seed ${fmt_kb(og.remote_seed_bytes)}` : "") + ".");
+		if (og.seed_bytes > 102400) warn("seed-large", `The page seed is ${fmt_kb(og.seed_bytes)}: an island reads $page, so that much of page.data ships to the browser and is serialized on every render.`, { fix: "Read only the keys the island needs (page.data.x, not page.data) so seed shaping trims it, or pass the values as props." });
+		if (og.tail_bytes > 204800) warn("props-large", `Island props total ${fmt_kb(og.tail_bytes)} across ${og.islands} islands.`, { fix: "Pass each island the slice it renders, not the whole record; a prop that is a page.data node crosses as a reference for free." });
+		ogygia_findings(og, meta, extras, info, warn);
+	}
+	page_weight_findings(meta, extras, info, warn);
+	const cc = (meta.run_cache_control ?? "").toLowerCase();
+	if (meta.trigger === "page" && cc.split(",").some((d) => d.trim() === "no-store")) warn("bfcache-no-store", `The page answers with Cache-Control: ${meta.run_cache_control}: the browser keeps no page marked no-store in its back/forward cache, so every Back and Forward to it is another full render here (and another wait for the visitor).`, { fix: "Drop no-store from pages that hold nothing private, or use `private, no-cache` (the browser keeps the page and checks with the server before reusing it). Keep no-store for pages that must never be shown again after logout." });
+	if (meta.trigger === "page" && meta.prerendered) info("prerendered-page", meta.run_static ? "This page is a file the build wrote (prerendered): the server answered with it before the app saw the request, so no render ran — the times above are the file being served, nothing to make faster on the server. A visit to it cannot be measured either: static HTML carries no profiler tag." : `This page is prerendered (its route exports \`prerender = true\`): production serves the HTML the build wrote, so its server render costs nothing per request — the times above are what the build spends on it, once. A visit to the built file cannot be measured either: static HTML carries no profiler tag.`, { fix: "Look at what the browser does with it instead: the page weight, the islands it wakes, its JS — and the devtools Page tab on a visit, which measures any page." });
+	const els = extras.strip?.elements;
+	if (els && els.total >= DOM_LARGE && !extras.visit?.dom) {
+		const top = els.islands[0];
+		const name = (top && top.n >= els.total * .3 ? island_rows_of(meta).find((r) => r.fp === top.fp) : void 0)?.name || (top ? `the island ${top.fp.slice(0, 8)}` : "");
+		const held = top && top.n >= els.total * .3;
+		const n = (x) => x.toLocaleString("en-US");
+		warn("dom-large", `The HTML makes ${n(els.total)} elements` + (held ? `, ${n(top.n)} of them inside ${name}: an island hydrates over every element of its own, so it pays for all of them as it wakes.` : ": every element costs the browser memory and style and layout work on each change."), { fix: held ? `Render fewer at once in ${name}: page or window a long list (only what is on screen), and keep big static markup outside the island (a lake costs nothing to hydrate).` : "Render fewer at once: page or window long lists (only what is on screen), and flatten markup that nests wrappers for layout alone." });
+	}
+	const unsized = extras.visit?.images_unsized ? [] : extras.strip?.unsized_images ?? [];
+	if (unsized.length) {
+		const file = (u) => {
+			const q = u.indexOf("?");
+			const p = q === -1 ? u : u.slice(0, q);
+			return p.slice(p.lastIndexOf("/") + 1) || u;
+		};
+		const names = [...new Set(unsized.map(file))];
+		const cls = extras.vitals?.cls ?? null;
+		const moved = cls !== null && cls >= .1;
+		(moved ? warn : info)("img-unsized", `${names.length === 1 ? `An image in the HTML (${names[0]}) has` : `${unsized.length >= 8 ? "8 or more" : unsized.length} images in the HTML (${names.slice(0, 4).join(", ")}${names.length > 4 ? "…" : ""}) have`} no width and height: the browser cannot hold their room before the file arrives, so what is below moves when it does${moved ? ` — and the browser measured the page moving (CLS ${cls})` : " (unless CSS gives them a size)"}.`, { fix: "Give each `<img>` its width and height attributes (the file’s own; CSS can still scale it): the browser then holds the room from the first paint. Or give it a CSS aspect-ratio." });
+	}
+	const tail = extras.strip?.tail;
+	const held_open = tail?.keys.length ? {
+		side: "server",
+		keys: tail.keys.map((k) => ({
+			key: k.key,
+			at: k.left_ms
+		})),
+		early_ms: tail.early_ms,
+		early_bytes: tail.early_bytes,
+		late_ms: tail.late_ms,
+		late_bytes: tail.late_bytes,
+		islands: island_rows_of(meta).length
+	} : void 0;
+	if (!extras.visit && held_open) {
+		const f = explain_held_open({
+			vitals: {},
+			visit: null,
+			islands: [],
+			firsts: [],
+			shifts: [],
+			longtasks: [],
+			held_open
+		}, [], (fp) => fp);
+		if (f) warn(f.code, f.message, { fix: f.fix });
+	}
+	if (extras.visit) {
+		const origin = extras.visit.origin || page_origin(extras.assets);
+		const third = origin ? {
+			origin,
+			named: extras.assets?.assets.map((a) => a.url),
+			by_host: cpu_by_host(extras)
+		} : void 0;
+		const hole_by_id = new Map((own_requests(meta).find((r) => r.og?.hole_rows?.length)?.og?.hole_rows ?? []).map((h) => [h.id, h]));
+		const hole_name = (id, p) => {
+			const h = hole_by_id.get(id);
+			if (h) {
+				const copy = p ? h.copies?.find((c) => c.p === p) : void 0;
+				if (copy) return hole_label({
+					...h,
+					props: copy.props
+				});
+				return (h.copies?.length ?? 0) > 1 && h.name ? h.name : hole_label(h);
+			}
+			return (extras.hole_requests ?? []).find((r) => r.id === id && r.name)?.name ?? `the hole ${id}`;
+		};
+		const econ = hole_economics(meta);
+		const hole_server = (id, p) => {
+			const of_id = (extras.hole_requests ?? []).filter((r) => r.id === id);
+			const of_copy = p ? of_id.filter((r) => r.p === p) : [];
+			const own = of_copy.length ? of_copy : of_id;
+			if (own.length) return own.reduce((a, r) => a + r.ms, 0) / own.length;
+			const e = econ.get(id);
+			const n = e ? e.hit + e.miss + e.none : 0;
+			return e && n ? e.ms / n : void 0;
+		};
+		const nav_req = new Map((extras.nav_requests ?? []).map((r) => [r.t, r]));
+		const sized = with_hidden_filled(extras.visit, origin, extras.assets, extras.other_engine_visit);
+		const visit = nav_req.size && sized.navs ? {
+			...sized,
+			navs: sized.navs.map((n) => nav_req.has(n.t) ? {
+				...n,
+				on_server: nav_req.get(n.t)
+			} : n)
+		} : sized;
+		const all_rows = island_rows_of(meta);
+		const own = island_js_unique(all_rows, extras.weights);
+		const visit_rows = own ? all_rows.map((r) => own.get(r.entry) ? {
+			...r,
+			own_bytes: own.get(r.entry)
+		} : r) : all_rows;
+		const in_browser = browser_findings(browser_page_report(visit, visit_rows, extras.client_cpu?.windows, third, hole_name, hole_server, extras.interaction_cpu, !!meta.dev, held_open)).filter((f) => f.code !== "render-blocking" || !extras.assets);
+		const here = screen_of(visit);
+		const engine = browser_of(visit?.ua);
+		const who = engine && !engine.startsWith("Chrome") && !engine.startsWith("Edge") && !engine.startsWith("Opera") ? ` (${engine})` : "";
+		out.push(...in_browser.map((f) => {
+			if (!f.message.startsWith(IN_BROWSER)) return f;
+			const rest = f.message.slice(16);
+			if (here && SCREEN_CODES.has(f.code)) return {
+				...f,
+				message: `In the browser${who}, on a ${here} screen: ${rest}`
+			};
+			return who ? {
+				...f,
+				message: `In the browser${who}: ${rest}`
+			} : f;
+		}));
+		const other = extras.other_screen_visit;
+		const there = other ? screen_of(other) : null;
+		if (other && there) {
+			const ours = new Map(in_browser.filter((f) => SCREEN_CODES.has(f.code)).map((f) => [f.code, new Set(f.fps ?? [])]));
+			const theirs = browser_findings(browser_page_report(other, visit_rows, void 0, third, hole_name, hole_server, void 0, !!meta.dev)).filter((f) => {
+				if (!SCREEN_CODES.has(f.code)) return false;
+				const o = ours.get(f.code);
+				return !o || (f.fps ?? []).some((fp) => !o.has(fp));
+			});
+			if (theirs.length) out.push({
+				severity: "info",
+				code: "other-screen",
+				message: `On a ${there} screen (another visit to this page) the browser saw what this one did not: ${theirs.map((f) => f.message.slice(f.message.startsWith(IN_BROWSER) ? 16 : 0)).join(" ")}`,
+				...theirs.some((f) => f.fix) ? { fix: [...new Set(theirs.map((f) => f.fix).filter((x) => !!x))].slice(0, 2).join(" ") } : {},
+				fps: [...new Set(theirs.flatMap((f) => f.fps ?? []))]
+			});
+		}
+		const eng = extras.other_engine_visit;
+		const eng_name = eng ? browser_of(eng.ua) : null;
+		if (eng && eng_name) {
+			const have = new Set(in_browser.map((f) => f.code));
+			const theirs = browser_findings(browser_page_report(eng, visit_rows, void 0, third, hole_name, hole_server, void 0, !!meta.dev)).filter((f) => !have.has(f.code) && !SCREEN_CODES.has(f.code) && f.code !== "dock-in-paint");
+			if (theirs.length) out.push({
+				severity: "info",
+				code: "other-browser",
+				message: `In ${eng_name} (another visit to this page) the browser saw what this one did not: ${theirs.map((f) => f.message.slice(f.message.startsWith(IN_BROWSER) ? 16 : 0)).join(" ")}`,
+				...theirs.some((f) => f.fix) ? { fix: [...new Set(theirs.map((f) => f.fix).filter((x) => !!x))].slice(0, 2).join(" ") } : {},
+				fps: [...new Set(theirs.flatMap((f) => f.fps ?? []))]
+			});
+		}
+		const WHAT = {
+			"layout-shift": extras.visit.shifts_from === "boxes" ? "layout shifts (a wake that moved the layout is estimated from the island's box)" : "layout shifts",
+			longtask: extras.visit.longtasks_from === "frames" ? "long tasks (its stalls are estimated from the frames it drew late)" : "long tasks",
+			event: "interaction timing",
+			"largest-contentful-paint": "the largest paint",
+			"long-animation-frame": "which script held a frame"
+		};
+		const blind = (extras.visit.unsupported ?? []).map((t) => WHAT[t]).filter(Boolean);
+		if (blind.length) info("browser-limits", `${browser_of(extras.visit.ua) ? `${browser_of(extras.visit.ua)}, the browser that visited,` : "The browser that visited"} does not report ${blind.join(", ")}: findings and score parts that need them are missing from this report, not clean. Visit the page from a Chromium browser to measure them.`);
+	}
+	kit_findings(a, meta, info, warn);
+	accuracy_findings(a, meta, extras, info, warn);
+	for (const g of (a.paths ?? []).slice(0, 3)) (g.ms >= a.busy_ms * .15 && pr(g.ms) >= PATH_WARN_MS ? warn : info)("path-group", `${g.fns.length} hot functions sit on one path under ${g.owner.name}: ${g.fns.slice(0, 4).map((f) => f.name).join(", ")}${g.fns.length > 4 ? ` and ${g.fns.length - 4} more` : ""} — ${fmt_ms(pr(g.ms))} ms together${per_r} (${fmt_pct(g.ms, a.busy_ms)} of busy).`, {
+		anchor: g.owner.category === "component" ? `comp:${g.owner.name}` : `fn:${g.owner.key}`,
+		file: g.owner.url,
+		line: g.owner.line,
+		fix: `Fix ${g.owner.name} once — call it less, cache what it computes, or move it out of the render — rather than each function on its own; the graph under "Paths to fix" shows the chain.`
+	});
+	if (a.gc_ms > a.busy_ms * .15 && a.gc_ms / runs_of(meta) > 5) warn("gc-heavy", `Garbage collection took ${fmt_pct(a.gc_ms, a.busy_ms)} of busy time (${fmt_ms(pr(a.gc_ms))} ms${per_r}) — see the allocators for who creates the garbage.`);
+	if (extras.retained && extras.retained.total_bytes >= 5242880) {
+		const r = extras.retained;
+		const top = r.sites.slice(0, 3).map((s) => `${s.name}${s.caller ? ` via ${s.caller}` : ""}${s.component ? ` in ${s.component}` : ""} (${Math.round(s.bytes / 1048576 * 10) / 10} MB)`).join(", ");
+		const mb = r.total_bytes / 1048576;
+		const limit = meta.lambda ? meta.lambda_mb : meta.heap_limit_mb;
+		const runway = limit ? Math.max(1, Math.floor(limit / mb)) : null;
+		const pkg_of = (file) => {
+			const at = file.lastIndexOf("/node_modules/");
+			if (at === -1) return null;
+			const parts = file.slice(at + 14).split("/");
+			return parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+		};
+		const from_pkg = r.sites.filter((s) => s.url && pkg_of(s.url));
+		const pkg_share = from_pkg.reduce((sum, s) => sum + s.bytes, 0) / r.total_bytes;
+		const pkg = pkg_share >= .5 ? pkg_of(from_pkg[0].url) : null;
+		warn("retained-per-render", `One render leaves ${Math.round(mb * 10) / 10} MB alive after a full collection: ${top}. Every render adds that much; the instance grows until it restarts` + (runway ? ` — at this rate its ${limit} MB ${meta.lambda ? "of memory" : "heap"} runs out after about ${runway} render${runway === 1 ? "" : "s"} of this page, and the process dies.` : ".") + (pkg ? ` ${Math.round(pkg_share * 100)}% of it is held inside ${pkg}.` : ""), {
+			fix: pkg ? `The kept memory is ${pkg}'s: called once per render (or per element), it keeps each call's state. Call it once and reuse it — one instance or one document-wide pass instead of one call per element — and check the package's issues for a dispose or cleanup call; restarting workers every N requests is only a stopgap.` : "Whatever holds these (a module-level cache, a registry, a closure kept by a long-lived object) must release them or be bounded. The sites named are where the kept objects were made; what keeps them is their owner.",
+			...r.sites[0]?.url ? {
+				file: r.sites[0].url,
+				line: r.sites[0].line
+			} : {}
+		});
+	}
+	for (const d of a.deopts.slice(0, 3)) {
+		if (d.self_ms < Math.max(2, a.busy_ms * .01) || d.count < 2) continue;
+		const why = Object.entries(d.reasons).sort((x, y) => y[1] - x[1]).map(([r, n]) => `${r} ×${n}`).join(", ");
+		warn("deopt", `${d.name} was deoptimized ${d.count} times in the window (${why}) and cost ${fmt_ms(pr(d.self_ms))} ms of CPU${per_r}: it runs in slow code most of the time.`, {
+			fix: "A deopt reason names the assumption that broke: \"wrong map\" is objects of different shapes at one site (keep the same properties in the same order), \"not a Smi\" is a number that became a float or a string, a megamorphic call site is many types through one call. Give the function one shape and it stays optimized.",
+			anchor: `fn:${d.key}`,
+			file: d.url,
+			line: d.line
+		});
+	}
+	const sync = sync_io(a).filter((r) => !meta.dev || r.callers.length);
+	const sync_ms = sync.reduce((s, r) => s + r.total_ms, 0);
+	if (sync_ms >= 2) {
+		const top = sync[0];
+		warn("sync-io", `${fmt_ms(pr(sync_ms))} ms of synchronous I/O on the CPU${R > 1 ? " per render" : " during the window"}: ${sync.slice(0, 3).map((s) => `${s.name} ${fmt_ms(pr(s.total_ms))} ms${s.callers[0] ? ` from ${s.callers[0]}` : ""}`).join(", ")}. While it runs no other request on this instance moves.`, {
+			fix: "Use the async form (fs.promises, zlib promises, execFile with a callback), or do it once at start-up and keep the result.",
+			anchor: `fn:${top.key}`
+		});
+	}
+	if (extras.promises) {
+		const all = meta.runs?.length ? extras.promises.count / meta.runs.length : extras.promises.count;
+		const dev_share = meta.dev ? extras.promises.top.reduce((s, t) => s + (dev_tool_caller(t.caller) ? t.share : 0), 0) : 0;
+		const per = all * (1 - Math.min(dev_share, 1));
+		if (per >= 1e4) {
+			const rest = 1 - dev_share || 1;
+			const top = extras.promises.top.filter((t) => !meta.dev || !dev_tool_caller(t.caller)).slice(0, 3).map((t) => `${t.caller} ${Math.round(t.share / rest * 100)}%`).join(", ");
+			const left_out = dev_share >= .05 ? ` (the dev server's own module loading made about ${Math.round(all - per).toLocaleString()} more, left out)` : "";
+			const renderer = extras.promises.top.filter((t) => t.caller.startsWith("#collect_content_async") && t.caller.endsWith("(svelte)")).reduce((s, t) => s + t.share, 0) / (1 - dev_share || 1);
+			if (renderer >= .5) {
+				const many = a.components.filter((c) => (c.calls ?? 0) >= 50).sort((x, y) => (y.calls ?? 0) - (x.calls ?? 0)).slice(0, 3).map((c) => `${c.name} ×${(c.calls ?? 0).toLocaleString()}`);
+				warn("promise-storm", `${Math.round(per).toLocaleString()} promises per render${left_out}, ${Math.round(renderer * 100)}% of them from Svelte's async server renderer (#collect_content_async): it makes one for each component and block it renders, so the count follows how much the page renders, not an await of yours.${many.length ? ` The components rendered most: ${many.join(", ")}.` : ""} Each is an allocation and a microtask, a cost no single function shows.`, { fix: `Render fewer pieces${many.length ? ` — ${many[0].split(" ×")[0]} first` : ""}: inline a small component an \`{#each}\` repeats into the loop's own markup, stop a component that renders itself sooner, or send a page of the list. The renderer goes async for every page when Svelte's \`experimental.async\` is on: an app with no \`await\` in its markup can turn it off and render with none of them.` });
+			} else warn("promise-storm", `${Math.round(per).toLocaleString()} promises per render${left_out}. Each is an allocation and a microtask; at this volume they are a cost no single function shows.${top ? ` Mostly from: ${top}.` : left_out ? " Their makers are spread thin: no one origin of the app’s stands out in the sample — profile again warm (the dev server’s loading crowds a first render)." : ""}`, { fix: "Find the loop that awaits per item (a render per tag, a fetch per row) and do the work in one call, or on a plain array without async at all." });
+		}
+	}
+	{
+		const by = /* @__PURE__ */ new Map();
+		for (const o of extras.io ?? []) {
+			if (!o.left_each_run || !o.caller) continue;
+			const g = by.get(o.caller) ?? {
+				caller: o.caller,
+				n: 0,
+				...o.repeat !== void 0 ? { repeat: o.repeat } : { delay: o.delay },
+				...o.caller_at ? { at: o.caller_at } : {}
+			};
+			g.n++;
+			by.set(o.caller, g);
+		}
+		for (const g of [...by.values()].slice(0, 2)) {
+			const s = (ms) => ms >= 1e3 ? `${Math.round(ms / 100) / 10} s` : `${ms} ms`;
+			warn("render-leftover", `Each render ${g.repeat !== void 0 ? `starts an interval (every ${s(g.repeat)}) that is still running after the render` : `schedules a ${s(g.delay ?? 0)} timer that is still waiting after the response went out`}: ${g.caller}. Every render adds ${g.n === 1 ? "one" : g.n} more — under traffic they pile up, each keeping its request's data in memory${g.repeat !== void 0 ? " and running on the instance’s CPU" : ""}.`, {
+				fix: g.repeat !== void 0 ? "Start it once for the process (at module level, or behind a flag set on first use) and share what it keeps fresh, or clear it when the work it serves is done. A render should leave nothing running." : "Clear the timer when the work it guards finishes, or keep one process-wide timer (a cache sweep) instead of one per request.",
+				...g.at ? {
+					file: g.at.path,
+					line: g.at.line
+				} : {}
+			});
+		}
+	}
+	for (const m of memo_candidates(a, extras.gc_attr?.makers ?? [], 8, runs_of(meta)).slice(0, 2)) info("memo-candidate", `${m.name} runs ${m.calls} times per render at ${m.per_call_ms} ms each (${fmt_ms(m.total_ms)} ms)${m.alloc_per_call ? `, allocating ${Math.round(m.alloc_per_call / 1024)} KB per call` : ""}${m.parent ? `, mostly under ${m.parent}` : ""}. If its result depends only on its argument, a cache keyed on it runs it once per distinct value.`, {
+		anchor: `fn:${m.key}`,
+		file: m.url,
+		line: m.line
+	});
+	const g = extras.gc_attr;
+	if (g && g.summary.total_ms >= 5 && g.makers.length) {
+		const m = g.makers[0];
+		if (m.gc_ms >= 3 && m.share >= .15) {
+			const where = m.component && m.component !== m.name ? ` inside ${m.component}` : "";
+			const via = m.caller && m.caller !== m.name ? ` (called from ${m.caller})` : "";
+			warn("gc-cause", `${fmt_ms(pr(m.gc_ms))} ms of the ${fmt_ms(pr(g.summary.total_ms))} ms of GC${per_r} is the garbage ${m.name}${via} makes${where}: ${Math.round(pr(m.allocated) / 1048576 * 10) / 10} MB of the ${Math.round(pr(g.summary.allocated_mb) * 10) / 10} MB allocated${R > 1 ? " per render" : " in the window"} (${Math.round(m.share * 100)}%)${m.pauses ? `, on the causing side of ${m.pauses} pause${m.pauses === 1 ? "" : "s"}` : `, across the window's ${g.summary.count} pause${g.summary.count === 1 ? "" : "s"}`}.`, {
+				fix: `Allocate less there: reuse the object between calls, avoid a clone or a JSON round trip of a large value, build strings once instead of in a loop. ${g.summary.retained_mb !== void 0 && g.summary.retained_mb > 20 ? `The heap also grew ${g.summary.retained_mb} MB over the window: something keeps what it allocates.` : "Most of it is churn: the heap did not grow with it."}`,
+				...m.url ? {
+					file: m.url,
+					line: m.line
+				} : {}
+			});
+		}
+	}
+	const al = extras.alloc;
+	if (al && al.bursts.length && al.grown_mb >= 20) {
+		const b = al.bursts[0];
+		if (b.mb >= al.grown_mb * .3) {
+			const who = b.running[0];
+			info("alloc-burst", `${b.mb} MB of the ${al.grown_mb} MB the heap grew came in one ${fmt_ms(b.t1 - b.t0)} ms stretch (${b.rate} MB/s)${who ? `, while ${who.label} ran` : ""}${b.gc ? " — and a collection fell inside it, so the allocation was more than the growth shows" : ""}.`, {
+				fix: "Look at the allocators table for that stretch: the makers with a caller there are the ones filling the heap that fast.",
+				...who?.file ? { file: who.file } : {}
+			});
+		}
+	}
+	if (meta.runs_set_aside) {
+		const kept = meta.runs?.length ?? 0;
+		const total = kept + meta.runs_set_aside;
+		(kept < 2 ? warn : info)("runs-set-aside", `${meta.runs_set_aside} of the ${total} renders ran while another visitor asked for this same page, and were left out: their work runs the same lines, so nothing but the clock tells it apart. The report reads the ${kept} render${kept === 1 ? "" : "s"} that ran clean.`, kept < 2 ? { fix: "Record again when the page is quieter (or on an instance out of rotation) for more than one clean render." } : {});
+	}
+	const ct = extras.contention;
+	if (ct && ct.requests.length) {
+		const others = ct.requests.filter((r) => r.kind === "other");
+		const others_n = ct.counts?.other ?? others.length;
+		const holes = ct.counts?.hole ?? ct.requests.filter((r) => r.kind === "hole").length;
+		const win = meta.trigger === "page" ? Math.max(meta.runs?.length ?? 1, 1) : 1;
+		if (others_n && ct.busy_share >= .1) {
+			const top = others.slice(0, 3).map((r) => `${r.method} ${r.path}`).join(", ");
+			const page_path = meta.page?.split("?")[0];
+			const same = page_path ? others.filter((r) => r.path === page_path).length : 0;
+			warn("busy-instance", `${others_n} other request${others_n === 1 ? "" : "s"} ran on this instance during the profiled render${win > 1 ? "s" : ""} (${top}${others_n > 3 ? ", …" : ""}), in flight for ${Math.round(ct.busy_share * 100)}% of the window: up to ${fmt_ms(ct.cpu_max_ms)} ms of its wall time was the event loop serving them, and the render's own numbers carry that wait.${a.other_requests_ms ? ` The samples under other pages' code (${fmt_ms(a.other_requests_ms / win)} ms a render) were set aside, and so were the slow lines in their page files — but a shared helper they called after an await has no frame of theirs left to tell it by, and may still show here: profile again on a quiet instance to be sure.` : ""}${same ? meta.runs_set_aside ? ` ${same} of them asked for this same page; the ${meta.runs_set_aside} render${meta.runs_set_aside === 1 ? "" : "s"} they overlapped ${meta.runs_set_aside === 1 ? "was" : "were"} left out, so this report reads the ${meta.runs?.length ?? 0} that ran clean.` : ` ${same} of them asked for this same page: their work runs through the same lines and cannot be told apart from the profiled render's (every render overlapped one), so this report's CPU reads high — up to ${same + 1}× on the lines they share.` : ""}`, { fix: "Record again on a quiet instance, or read the CPU numbers (they exclude the others) rather than the wall time. Sustained, this is what horizontal scaling or a worker pool is for." });
+		}
+		const selfs = ct.requests.filter((r) => r.kind === "self");
+		const self_n = ct.counts?.self ?? selfs.length;
+		if (self_n) {
+			const paths = ct.counts?.self_paths ?? [...new Set(selfs.map((r) => r.path))];
+			const per = Math.round(self_n / win);
+			const self_ms = (ct.counts?.self_ms ?? selfs.reduce((s, r) => s + r.ms, 0)) / win;
+			const remote_n = ct.counts?.self_remote ?? selfs.filter((r) => r.remote).length;
+			if (remote_n && remote_n === self_n) {
+				const names = [...new Set(paths.map(remote_function_name))];
+				info("self-fetch", `The render read ${names.length === 1 ? `a \`prerender\` remote function's answer (${names[0]})` : `\`prerender\` remote functions' answers (${names.slice(0, 3).join(", ")}${names.length > 3 ? ", …" : ""})`} over HTTP ${per} time${per === 1 ? "" : "s"}: Kit fetches it from the site's own public address on every server render — here this same instance answered, ${fmt_ms(self_ms)} ms of requests while it was rendering. Where the host serves the prerendered answer as a file it is still a trip out and back per render; where it does not (an argument the build did not prerender), the function runs anyway, in a request of its own.`, { fix: "For data a render needs, use a `query` (it runs in the render's own process, no request) or read it in the load; keep `prerender` for answers the browser fetches." });
+			} else info("self-fetch", `The render called its own server ${per} time${per === 1 ? "" : "s"} (${paths.slice(0, 3).join(", ")}${paths.length > 3 ? ", …" : ""}), ${fmt_ms(self_ms)} ms of requests answered by the same event loop that was rendering: the page waited on itself, and every one of those calls paid a full HTTP round trip to reach code in the same process.`, { fix: "Call the function behind the endpoint directly from the load (import it), or use a remote function; keep fetch for servers that are not this one." });
+		}
+		if (holes && !others_n && !self_n) info("holes-in-flight", `${holes} of the page's own hole request${holes === 1 ? "" : "s"} ${holes === 1 ? "was" : "were"} answered while it rendered: the deferred islands cost the instance CPU on the page's own clock.`);
+	}
+	const ln = extras.lineage;
+	if (ln) {
+		const route = own_requests(meta).find((r) => r.route)?.route ?? meta.request?.route;
+		const unread = ln.unread.filter((k) => k.from && !(route && another_routes_file(route, k.from)));
+		if (unread.length) {
+			const names = unread.slice(0, 4).map((k) => `${k.key} (${k.from})`).join(", ");
+			const load_wait = /* @__PURE__ */ new Map();
+			for (const k of unread) if ((k.load_wait_ms ?? 0) > 0 && k.from) load_wait.set(k.from, k.load_wait_ms);
+			const wait = [...load_wait.values()].reduce((s, w) => s + w, 0);
+			const loads = load_wait.size;
+			const rows = unread_rows(extras.drill);
+			const cut = rows.reduce((s, r) => s + r.ms, 0);
+			const exact = rows.length ? ` Exactly what builds only ${unread.length === 1 ? "it" : "them"}: ${rows.slice(0, 4).map((r) => `${r.label} ${fmt_ms(r.ms)} ms (${r.kind === "wait" ? "waiting" : "CPU"}) → ${r.keys.join(", ")}`).join(", ")}${rows.length > 4 ? ", …" : ""} — ${fmt_ms(cut)} ms of one render for nothing.` : wait > 0 ? ` The load${loads > 1 ? "s" : ""} returning ${unread.length === 1 ? "it" : "them"} waited ${fmt_ms(wait)} ms on upstream calls per render in all; the calls that feed only ${unread.length === 1 ? "this key" : "these keys"} are the part to cut.` : "";
+			warn("key-unread", `${unread.length} page.data key${unread.length === 1 ? "" : "s"} no component reads: ${names}${unread.length > 4 ? ", …" : ""}.${exact}`, {
+				fix: "Drop the key from the load, or the call that produces it — nothing on the page uses it. A key read through a spread or a whole-object pass-through would show as unknown, not unread.",
+				file: unread[0].from
+			});
+		}
+		const so = ln.server_only.filter((k) => k.shipped_bytes >= 2048);
+		if (so.length) {
+			const bytes = so.reduce((s, k) => s + k.shipped_bytes, 0);
+			info("seed-server-only", `${fmt_kb(bytes)} of the seed is ${so.length} key${so.length === 1 ? "" : "s"} only the server renders (${so.slice(0, 4).map((k) => k.key).join(", ")}${so.length > 4 ? ", …" : ""}): shipped to the browser, read by no island.`, { fix: "The seed ships the keys islands read; a key here is read by a server component through a name the shaping could not see. Check the island’s closure." });
+		}
+	}
+	for (const v of span_values(extras.spans)) if (v.r !== void 0 && v.r >= .8 && v.n >= 5 && v.ms_per_unit !== void 0 && v.ms_per_unit > 0) {
+		info("value-driven", `${v.span} scales with ${v.attr}: about ${v.ms_per_unit >= .01 ? v.ms_per_unit : v.ms_per_unit.toExponential(1)} ms per unit over ${v.n} spans (${v.attr} ${v.min}–${v.max}, fit r=${v.r}). Halving the ${v.attr} halves the span.`);
+		break;
+	}
+	if (extras.gc && extras.gc.max_ms > 20) warn("gc-pause", `Longest single GC pause: ${fmt_ms(extras.gc.max_ms)} ms (${extras.gc.count} pauses in the window, ${fmt_ms(pr(extras.gc.total_ms))} ms${R > 1 ? " per render" : " total"}). A long pause freezes every request at once.`);
+	if (meta.loop_delay && meta.loop_delay.p99 > 50) warn("loop-stall", `The event loop stalled up to ${fmt_ms(meta.loop_delay.p99)} ms (p99) — long synchronous work blocks every other request.`);
+	const mem_delta = extras.mem.length >= 2 ? extras.mem.at(-1).rss - extras.mem[0].rss : 0;
+	const kept_said = !!extras.retained && extras.retained.total_bytes >= 5242880;
+	if (mem_delta > 50 && !kept_said) warn("mem-growth", `The server's memory grew ${mem_delta} MB while the recording ran. A first recording grows it as caches and the heap reach their working size; one that grows it again each time is keeping something per render.`, { fix: "Record again: if it grows by about as much again, look for what a render adds to a module-level map, array or cache that is never cleared — the memory card lists what one render leaves alive." });
+	const profiler_ms = a.buckets.find((b) => b.key === "profiler overhead")?.self_ms ?? 0;
+	if (profiler_ms > a.busy_ms * .05 && profiler_ms > 5) info("profiler-overhead", `${fmt_ms(profiler_ms)} ms of busy time is the profiler itself — a one-time cost when recording starts. Your app did not pay this outside the recording.`);
+	if (meta.dev) info("dev-mode", "Recorded on the dev server — Vite module loading and transforms are included. Build and run production for exact figures.");
+	if (meta.run_static) {
+		for (let k = out.length - 1; k >= 0; k--) if (RENDER_ONLY.has(out[k].code)) out.splice(k, 1);
+	}
+	const gap = out.find((f) => f.code === "lcp-gap");
+	if (gap && out.some((f) => f.code === "slow-lcp")) {
+		const dash = gap.message.indexOf(" — ");
+		if (dash !== -1) gap.message = `${gap.message.slice(0, dash)}: the server is not the bottleneck. Where the browser's wait went is the largest paint's own card (In the browser: LCP …).`;
+		gap.fix = "The wait is the browser's, not the server's: follow the largest paint's own card (In the browser: LCP …), which names the part that cost most and its fix.";
+	}
+	if (extras.hazards) {
+		const told = /* @__PURE__ */ new Set();
+		const rows = island_rows_of(meta);
+		for (const f of out) if (f.code === "markup-changed" || f.code === "hydration-mismatch") {
+			for (const fp of f.fps ?? []) for (const r of rows) if (r.fp === fp) told.add(r.entry);
+		}
+		if (out.some((f) => f.code === "hydration-mismatch")) {
+			for (const c of extras.client ?? []) if (c.recovered > 0) told.add(c.entry);
+		}
+		const seen = /* @__PURE__ */ new Set();
+		const reads = [];
+		for (const r of rows) {
+			if (r.wake === "none" || seen.has(r.entry) || told.has(r.entry)) continue;
+			seen.add(r.entry);
+			const line = (extras.hazards[r.entry] ?? []).find((h) => h.kind === "browser" && !h.guard);
+			if (line) reads.push({
+				name: island_name(r),
+				line
+			});
+		}
+		const who = reads.map((x) => x.name);
+		if (reads.length) info("island-browser-read", `${who.length <= 3 ? who.join(", ") : `${who.slice(0, 3).join(", ")} and ${who.length - 3} more`} ${reads.length === 1 ? "reads" : "read"} a browser-only value while rendering, so the browser draws ${reads.length === 1 ? "it" : "them"} differently and the markup changes as ${reads.length === 1 ? "it wakes" : "they wake"}: ${hazard_words(reads.map((x) => x.line)).slice(32)}`, {
+			fix: hazard_fix(reads.map((x) => x.line)),
+			file: reads[0].line.file,
+			line: reads[0].line.line
+		});
+	}
+	if (extras.hazards) {
+		const mc = out.find((f) => f.code === "markup-changed");
+		if (mc?.fps?.length) {
+			const rows = island_rows_of(meta);
+			const lines = [...new Set(mc.fps.flatMap((fp) => rows.filter((r) => r.fp === fp).map((r) => r.entry)))].flatMap((e) => extras.hazards?.[e] ?? []);
+			if (lines.length) {
+				mc.message += ` ${hazard_words(lines)}`;
+				mc.fix = `${hazard_fix(lines)} ${mc.fix ?? ""}`.trim();
+				mc.file ??= lines[0].file;
+				mc.line ??= lines[0].line;
+			}
+		}
+	}
+	if (extras.patterns?.length) link_patterns(out, extras.patterns, a);
+	return out;
+}
+/** `lib/hell/ds-ssr.ts` and `src/lib/hell/ds-ssr.ts` name one file: one path ends with the other */
+const same_file = (x, y) => {
+	const a = x.startsWith("file://") ? x.slice(7) : x;
+	const b = y.startsWith("file://") ? y.slice(7) : y;
+	return a === b || a.endsWith("/" + b) || b.endsWith("/" + a);
+};
+/** an identifier no sentence would contain: an inner capital, an underscore or a digit */
+const looks_like_code = (name) => {
+	for (let i = 1; i < name.length; i++) {
+		const c = name.charCodeAt(i);
+		if (c >= 65 && c <= 90 || c === 95 || c >= 48 && c <= 57) return true;
+	}
+	return false;
+};
+/** every `(path:line)` a finding's message names (a caller written `fn (lib/x.ts:46)`) */
+function places_in(message) {
+	const out = [];
+	let i = message.indexOf("(");
+	while (i !== -1) {
+		const close = message.indexOf(")", i);
+		if (close === -1) break;
+		const inner = message.slice(i + 1, close);
+		const colon = inner.lastIndexOf(":");
+		const line = colon > 0 ? Number(inner.slice(colon + 1)) : NaN;
+		if (Number.isInteger(line) && line > 0 && !inner.slice(0, colon).includes(" ")) out.push({
+			file: inner.slice(0, colon),
+			line
+		});
+		i = message.indexOf("(", i + 1);
+	}
+	return out;
+}
+/**
+* A finding that a slow pattern already explains points at it (`pattern`, its index), so the two
+* read as one problem: a finding and a pattern share a code line (a site, a caller line, or the
+* function a site sits in), the row the finding opens is a site's function, or a network finding
+* names the calls a waits-in-a-row site made. Nothing is hidden; the finding gains the link.
+*/
+function link_patterns(findings, patterns, a) {
+	const start_of = /* @__PURE__ */ new Map();
+	for (const f of a.functions) start_of.set(f.key, f.line);
+	for (const c of a.components) start_of.set(c.key, c.line);
+	const places = patterns.map((p) => {
+		const lines = [];
+		const fns = /* @__PURE__ */ new Set();
+		const targets = [];
+		/** a site's function as a finding names a caller: `drainQueue (` */
+		const callers = [];
+		for (const s of p.sites) {
+			lines.push({
+				file: s.path || s.file,
+				line: s.line
+			});
+			if (s.fn_name && !s.fn_name.startsWith("(") && looks_like_code(s.fn_name)) callers.push(s.fn_name + " (");
+			if (s.fn) {
+				fns.add(s.fn);
+				const at = start_of.get(s.fn);
+				if (at) lines.push({
+					file: s.path || s.file,
+					line: at
+				});
+			}
+			for (const v of s.via ?? []) lines.push({
+				file: v.path || v.file,
+				line: v.line
+			});
+			if (s.target) targets.push(s.target.split(" and ")[0]);
+		}
+		return {
+			lines,
+			fns,
+			targets,
+			callers
+		};
+	});
+	const by_code = {
+		"seed-whole": "seed-whole-read",
+		"seed-large": "seed-whole-read",
+		"retained-per-render": "kept-per-render",
+		"slower-each-run": "kept-per-render"
+	};
+	for (const f of findings) {
+		const kind = by_code[f.code];
+		const direct = kind ? patterns.findIndex((p) => p.kind === kind) : -1;
+		if (direct !== -1) {
+			f.pattern = direct;
+			continue;
+		}
+		if (f.severity !== "warn" && f.code !== "memo-candidate") continue;
+		const mine = [...f.file && f.line ? [{
+			file: f.file,
+			line: f.line
+		}] : [], ...places_in(f.message)];
+		const anchor_fn = f.anchor?.startsWith("fn:") ? f.anchor.slice(3) : f.anchor?.startsWith("comp:") ? "C:" + f.anchor.slice(5) : void 0;
+		const hit = places.findIndex((p) => anchor_fn !== void 0 && p.fns.has(anchor_fn) || mine.some((m) => p.lines.some((l) => l.line === m.line && same_file(l.file, m.file))) || p.callers.some((c) => f.message.includes(c)) || p.targets.some((t) => {
+			const bare = t.slice(t.indexOf(" ") + 1);
+			return f.message.includes(bare);
+		}));
+		if (hit !== -1) f.pattern = hit;
+	}
+}
+/** The island rows of the profiled page: the page request that recorded them (detail is on only
+*  while the profiler records, so the internal render carries them). */
+function island_rows_of(meta) {
+	return own_requests(meta).find((r) => r.og?.island_rows?.length)?.og?.island_rows ?? [];
+}
+const HOST_FN_RE = /^_[0-9a-f]{11}$/;
+const ISLAND_ID_RE = /([0-9a-f]{12})/;
+/**
+* THE ISLAND HOST WRAPPERS by name. The compiler wraps every island in a virtual
+* `wrapper/<id>.svelte`, and Svelte names that function after the file: `_b95bfb97fab` (the id
+* minus its first character, made an identifier). The island rows know the id (in the entry URL)
+* and the component: this returns the `rename` hook `analyze()` takes, so the wrapper reads
+* `ProductCard (island host)` in every table, stack and flame. Rows come from every request in
+* the window (a page profile's own render, a trapped page, a header-profiled request).
+*/
+function island_host_renamer(requests) {
+	const by_suffix = /* @__PURE__ */ new Map();
+	for (const r of requests) for (const row of r.og?.island_rows ?? []) {
+		const id = ISLAND_ID_RE.exec(row.entry)?.[1];
+		if (!id) continue;
+		const name = island_name(row);
+		if (name && name !== row.entry) by_suffix.set(id.slice(1), name);
+	}
+	if (!by_suffix.size) return void 0;
+	return (name) => {
+		if (!HOST_FN_RE.test(name)) return void 0;
+		const island = by_suffix.get(name.slice(1));
+		return island ? `${island} (island host)` : void 0;
+	};
+}
+/** What to call a hole: its component and props (`Recommendations {"forProduct":"P1"}`), else its id. */
+function hole_label(h) {
+	if (!h.name) return h.id;
+	return h.props ? `${h.name} ${h.props}` : h.name;
+}
+/** The hole endpoint requests in the window, per hole id: hits / misses / uncached renders. */
+function hole_economics(meta) {
+	const out = /* @__PURE__ */ new Map();
+	for (const r of meta.requests) {
+		if (!r.hole) continue;
+		const e = out.get(r.hole.id) ?? {
+			id: r.hole.id,
+			hit: 0,
+			miss: 0,
+			none: 0,
+			ms: 0,
+			ttl: r.hole.ttl
+		};
+		e[r.hole.cache]++;
+		e.ms += r.ms;
+		out.set(r.hole.id, e);
+	}
+	return out;
+}
+/** The display name of an island: its component's name when the row carries it, else the
+*  entry's basename (`ProductCard` from `.../ProductCard.svelte`; a built facade keeps its file). */
+function island_name(row) {
+	if (typeof row !== "string" && row.name) return row.name;
+	const entry = typeof row === "string" ? row : row.entry;
+	const m = /([^/\\?]+)\.svelte(?:[?#].*)?$/.exec(entry);
+	return m ? m[1] : entry.replace(/^.*[/\\]/, "") || entry;
+}
+/**
+* ONE ROW PER ISLAND: the tail records a row per fingerprint (a list of 48 cards is 48 props
+* sidecars, one each), and the fingerprint is what the browser's beacon joins on — but the table
+* and the findings speak of the island. Rows with the same entry and wake merge: copies and
+* bytes add up, references and hints union, the first devalue culprit stands for all, and
+* `variants` says how many fingerprints went in.
+*/
+function group_islands(rows) {
+	const out = /* @__PURE__ */ new Map();
+	for (const r of rows) {
+		const key = r.entry + "\0" + r.wake;
+		const g = out.get(key);
+		if (!g) {
+			out.set(key, {
+				...r,
+				ref_keys: [...r.ref_keys],
+				hints: [...r.hints],
+				variants: 1
+			});
+			continue;
+		}
+		g.count += r.count;
+		g.variants = (g.variants ?? 1) + 1;
+		g.props_bytes += r.props_bytes;
+		g.canonical_bytes += r.canonical_bytes;
+		g.refs += r.refs;
+		g.json = g.json && r.json;
+		g.culprit ??= r.culprit;
+		g.name ||= r.name;
+		g.interactivity ??= r.interactivity;
+		for (const k of r.ref_keys) if (!g.ref_keys.includes(k)) g.ref_keys.push(k);
+		for (const h of r.hints) if (!g.hints.includes(h)) g.hints.push(h);
+	}
+	for (const g of out.values()) g.ref_keys.sort();
+	return [...out.values()];
+}
+/** Unique bytes of an island's JS closure (its module + preload hints), when the weights are known. */
+/** Code every page with islands loads once, never an island's own to change: the runtimes, Kit,
+*  and devalue (the runtime's decoder for rich props — the `props-devalue` finding is where that is
+*  the island's doing). The heavy-module and barrel notes leave these out. */
+const FRAMEWORK = /* @__PURE__ */ new Set([
+	"svelte runtime",
+	"ogygia runtime",
+	"@sveltejs/kit",
+	"devalue",
+	"esm-env"
+]);
+function island_js_bytes(row, weights) {
+	if (!weights) return null;
+	let total = 0;
+	let any = false;
+	for (const u of /* @__PURE__ */ new Set([row.module_url, ...row.hints])) {
+		const w = u ? weights[u] : void 0;
+		if (w === void 0) continue;
+		any = true;
+		total += w;
+	}
+	return any ? total : null;
+}
+/** an inert island whose lake saves less than this (bytes) is a note, not a warning */
+const LAKE_WARN_BYTES = 10240;
+/**
+* WHAT MAKING SOME ISLANDS LAKES SAVES: the bytes of their closures (each chunk once) that no other
+* waking island on the page loads — a shared chunk (the framework's runtime) another island needs
+* downloads anyway. `loads`: their closures, each chunk once. Null without the build's weights.
+*/
+function lake_saving(them, rows, weights) {
+	if (!weights) return null;
+	const going = new Set(them.map((r) => r.entry));
+	const kept = /* @__PURE__ */ new Set();
+	for (const r of rows) if (r.wake !== "none" && !going.has(r.entry)) {
+		for (const u of [r.module_url, ...r.hints]) if (u) kept.add(u);
+	}
+	const theirs = /* @__PURE__ */ new Set();
+	for (const r of them) for (const u of [r.module_url, ...r.hints]) if (u) theirs.add(u);
+	let loads = 0;
+	let saves = 0;
+	let any = false;
+	for (const u of theirs) {
+		const w = weights[u];
+		if (w === void 0) continue;
+		any = true;
+		loads += w;
+		if (!kept.has(u)) saves += w;
+	}
+	return any ? {
+		loads,
+		saves
+	} : null;
+}
+/**
+* WHAT ONLY EACH ISLAND NEEDS: of an island's closure (its entry and chunks), the bytes no other
+* waking island on the page uses — what dropping (or deferring) that island would really save.
+* `island_js_bytes` counts shared chunks once per island; this counts each once, where it belongs.
+* Keyed by entry (copies of one island are one closure). Null without the build's weights.
+*/
+function island_js_unique(rows, weights) {
+	if (!weights) return null;
+	const waking = rows.filter((r) => r.wake !== "none");
+	const users = /* @__PURE__ */ new Map();
+	for (const r of waking) for (const u of /* @__PURE__ */ new Set([r.module_url, ...r.hints])) if (u) (users.get(u) ?? users.set(u, /* @__PURE__ */ new Set()).get(u)).add(r.entry);
+	const out = /* @__PURE__ */ new Map();
+	for (const r of waking) {
+		if (out.has(r.entry)) continue;
+		let only = 0;
+		for (const u of /* @__PURE__ */ new Set([r.module_url, ...r.hints])) if (u && users.get(u)?.size === 1) only += weights[u] ?? 0;
+		out.set(r.entry, only);
+	}
+	return out;
+}
+/** ogygia-specific findings: the seed explained, devalue culprits, the wake advisor, hole economics,
+*  island JS weight and the browser's own hydration timings. */
+function ogygia_findings(og, meta, extras, info, warn) {
+	const islands = group_islands(island_rows_of(meta));
+	const names = (list, max = 3) => list.length <= max ? list.join(", ") : `${list.slice(0, max).join(", ")} and ${list.length - max} more`;
+	const renders = meta.requests.filter((r) => r.internal && r.og?.island_rows?.length).map((r) => r.og.island_rows);
+	if (renders.length >= 2) {
+		const kept = (rows) => rows.map((r) => ({
+			entry: r.entry,
+			fp: r.fp,
+			...r.canonical !== void 0 ? { props: r.canonical } : {}
+		}));
+		const moved = fp_compare(kept(renders[0]), kept(renders[renders.length - 1]));
+		if (moved.length) {
+			const name_of = (entry) => island_name(renders[0].find((r) => r.entry === entry) ?? entry);
+			const m = moved[0];
+			const whose = moved.length === 1 ? "its" : `${name_of(m.entry)}'s`;
+			const said = m.path ? `${whose} prop \`${m.path}\` was ${m.was}, then ${m.now}` : m.was !== void 0 ? `${whose} props went from …${m.was}… to …${m.now}…` : `${whose} props changed`;
+			info("fp-unstable", `${names(moved.map((x) => name_of(x.entry)))} rendered with a different fingerprint on the profiler's renders of the same page: ${said}${moved.length > 1 ? ` (and ${moved.length - 1} more)` : ""}. If the page's data did not change between them, that value is made fresh on every render.`, { fix: "The router compares fingerprints to keep a live island across a navigation, and the fingerprint is part of the page’s bytes: an island whose props change on every render is patched on every navigation, and a cache keyed on the HTML (a CDN, a post-render cache, a postrender store, an ETag) misses every time. Make the value the same for the same inputs: take it from load data, compute it in the browser (an effect), or leave it out of the props." });
+		}
+	}
+	if (og.seed && og.seed_bytes > 0) {
+		const shipped = og.seed.keys.filter((k) => k.shipped);
+		const top = shipped[0];
+		if (og.seed.whole_by.length) warn("seed-whole", `${names(og.seed.whole_by.map(island_name))} read${og.seed.whole_by.length === 1 ? "s" : ""} page.data whole, so every key ships in the seed (${fmt_kb(og.seed_bytes)}${top ? `, the biggest is ${top.key} at ${fmt_kb(top.bytes)}` : ""}).`, { fix: "Read the keys by name (page.data.catalog, not a spread or a loop over page.data) so seed shaping can drop the rest, or pass the values in as props." });
+		else if (top && top.bytes >= 20480) {
+			const why = top.reason === "read" ? `read by ${names(top.readers.map(island_name))}` : top.reason === "referenced" ? `props of ${names(top.referenced_by.map(island_name))} point into it` : "shipped";
+			info("seed-explainer", `The seed's biggest key is ${top.key} (${fmt_kb(top.bytes)} of ${fmt_kb(og.seed_bytes)}): ${why}.` + (shipped.length > 1 ? ` ${shipped.length} keys ship in all.` : ""), { fix: top.reason === "read" ? "If the island needs only part of it, return that part from load under its own key, or pass it as a prop." : "A referenced key ships once and the props point into it — that is the cheap shape; trim the key itself if it is bigger than the page needs." });
+		}
+	}
+	if (og.seed_bytes > 0 && !og.seed_json && og.seed_culprit) warn("seed-devalue", `The seed (${fmt_kb(og.seed_bytes)}) left the JSON lane because of ${og.seed_culprit} — devalue writes and revives it several times slower than JSON.parse.`, { fix: "Send that value as a plain string or number (a Date as toISOString(), a Map as an object), or keep it out of page.data." });
+	const devalued = islands.filter((r) => !r.json && r.culprit).sort((x, y) => y.props_bytes - x.props_bytes);
+	if (devalued.length) {
+		const d = devalued[0];
+		(d.props_bytes >= 2048 ? warn : info)("props-devalue", `${island_name(d)}'s props (${fmt_kb(d.props_bytes)}${d.count > 1 ? `, ×${d.count}` : ""}) use devalue because of ${d.culprit}` + (devalued.length > 1 ? `; ${devalued.length - 1} more island${devalued.length > 2 ? "s" : ""} likewise.` : "."), { fix: "JSON props parse on the fast lane in the browser: pass the value as a string or number, or derive it inside the island." });
+	}
+	const inert = islands.filter((r) => r.interactivity && r.interactivity.files > 0 && r.wake !== "none" && r.interactivity.handlers + r.interactivity.state + r.interactivity.effects + r.interactivity.binds + r.interactivity.actions + (r.interactivity.remotes ?? 0) + (r.interactivity.awaits ?? 0) + (r.interactivity.shared ?? 0) === 0);
+	if (inert.length) {
+		const lake = lake_saving(inert, islands, extras.weights);
+		const they = inert.length === 1 ? "it loads" : "they load";
+		(lake && lake.loads && lake.saves < LAKE_WARN_BYTES ? info : warn)("wake-inert", `${names(inert.map(island_name))} wake${inert.length === 1 ? "s" : ""} (${names([...new Set(inert.map((r) => r.wake))])}) but the build found no event handlers, $state, $effect, bind:, use:, remote function, await or shared state in ${inert.length === 1 ? "its" : "their"} components` + (!lake || !lake.loads ? "." : lake.saves >= lake.loads ? ` — ${fmt_kb(lake.saves)} of JS loads for markup that never changes.` : lake.saves > 0 ? ` — ${they} ${fmt_kb(lake.loads)} of JS for markup that never changes; ${fmt_kb(lake.saves)} of it is ${inert.length === 1 ? "its" : "theirs"} alone (the rest the page's other islands load too), what a lake saves.` : ` — ${they} ${fmt_kb(lake.loads)} of JS for markup that never changes, all of it shared with the page's other islands: a lake saves ${inert.length === 1 ? "its" : "their"} hydration, not bytes.`), { fix: "Ship them as lakes (wake: 'none'): the server markup stays, the module never downloads." });
+	}
+	const crowds = islands.filter((r) => r.count >= 10 && (r.wake === "load" || r.wake === "idle" || r.wake === "visible"));
+	for (const c of crowds.slice(0, 2)) info("wake-crowd", `${island_name(c)} has ${c.count} copies on the page, each waking on ${c.wake} with its own ${fmt_kb(Math.round(c.props_bytes / Math.max(c.variants ?? 1, 1)))} of props.`, { fix: "One island around the list hydrates once; or wake: 'interaction' so a copy pays only when touched." });
+	if (extras.weights) {
+		const seen = /* @__PURE__ */ new Set();
+		let total = 0;
+		let heaviest = null;
+		for (const r of islands) {
+			if (r.wake === "none") continue;
+			const b = island_js_bytes(r, extras.weights) ?? 0;
+			if (!heaviest || b > heaviest.bytes) heaviest = {
+				row: r,
+				bytes: b
+			};
+			for (const u of [r.module_url, ...r.hints]) {
+				if (!u || seen.has(u)) continue;
+				seen.add(u);
+				total += extras.weights[u] ?? 0;
+			}
+		}
+		const unique = island_js_unique(islands, extras.weights);
+		let mine = null;
+		if (unique) {
+			for (const r of islands) if (r.wake !== "none" && (!mine || (unique.get(r.entry) ?? 0) > mine.bytes)) mine = {
+				row: r,
+				bytes: unique.get(r.entry) ?? 0
+			};
+		}
+		if (total >= 307200 && heaviest) {
+			const pick = mine && mine.bytes >= 20480 ? mine : null;
+			warn("islands-js-heavy", `The page's islands load ${fmt_kb(total)} of JS in all (${seen.size} modules)` + (pick ? `; ${fmt_kb(pick.bytes)} of it is needed by ${island_name(pick.row)} alone` + ((island_js_bytes(pick.row, extras.weights) ?? 0) - pick.bytes >= 1024 ? ` (its whole closure is ${fmt_kb(island_js_bytes(pick.row, extras.weights) ?? 0)}; the rest is shared with other islands)` : "") + " — deferring or dropping it saves that much." : `; ${island_name(heaviest.row)}'s closure is the largest (${fmt_kb(heaviest.bytes)}), but most of it is shared with other islands: no single island's removal saves much.`), { fix: "Open the Islands table: a heavy closure is usually one import (a date or i18n library, a whole component kit) reachable from the island — move it server-side or behind a dynamic import." });
+		}
+	}
+	if (extras.heavy && islands.length) {
+		const found = /* @__PURE__ */ new Map();
+		for (const r of islands) {
+			if (r.wake === "none") continue;
+			let own = 0;
+			const by = /* @__PURE__ */ new Map();
+			for (const u of /* @__PURE__ */ new Set([r.module_url, ...r.hints])) {
+				const h = u ? extras.heavy[u] : void 0;
+				if (!h) continue;
+				own += h.total;
+				for (const m of h.top) if (FRAMEWORK.has(m.name)) own -= m.bytes;
+				else by.set(m.name, (by.get(m.name) ?? 0) + m.bytes);
+			}
+			const top = [...by].sort((a, b) => b[1] - a[1])[0];
+			if (!top || own <= 0) continue;
+			const [name, bytes] = top;
+			if (bytes < 20480 || bytes < own * .4) continue;
+			const prev = found.get(name);
+			if (!prev || bytes / own > prev.bytes / prev.of) found.set(name, {
+				row: r,
+				bytes,
+				of: own
+			});
+		}
+		if (found.size) info("island-heavy-module", [...found].sort((a, b) => b[1].bytes - a[1].bytes).slice(0, 3).map(([name, f]) => `${name.split("/").pop()} is ${Math.round(f.bytes / f.of * 100)}% of ${island_name(f.row)}'s own code (${fmt_kb(f.bytes)} of ${fmt_kb(f.of)}, before minifying)`).join("; ") + ".", { fix: "That one module is where the island’s weight is: split it (one module per piece: an icon, a locale), load it when it is needed, or render it on the server." });
+	}
+	if (extras.barrels && islands.length) {
+		const found = /* @__PURE__ */ new Map();
+		for (const r of islands) {
+			if (r.wake === "none") continue;
+			for (const u of /* @__PURE__ */ new Set([r.module_url, ...r.hints])) for (const b of (u ? extras.barrels[u] : void 0) ?? []) {
+				if (FRAMEWORK.has(b.name)) continue;
+				const prev = found.get(b.name);
+				if (!prev || b.fanout > prev.fanout) found.set(b.name, {
+					row: r,
+					fanout: b.fanout
+				});
+			}
+		}
+		if (found.size) warn("island-barrel", [...found].sort((a, b) => b[1].fanout - a[1].fanout).slice(0, 3).map(([name, f]) => `${island_name(f.row)} ships a barrel whole: ${name}, and the ${f.fanout} modules behind it`).join("; ") + ". A Svelte component is never side-effect free to the bundler, so what the island does not use ships anyway.", { fix: "Import what the island uses from its own file, or turn on ogygia({ barrels }). If it is on, the barrel has side effects of its own (a statement besides its re-exports), or the build log says why it was skipped." });
+	}
+	const econ = hole_economics(meta);
+	const rows = og.hole_rows ?? [];
+	const by_id = new Map(rows.map((h) => [h.id, h]));
+	const label = (id) => {
+		const h = by_id.get(id);
+		return h ? hole_label(h) : id;
+	};
+	for (const e of econ.values()) {
+		const total = e.hit + e.miss + e.none;
+		if (e.ttl > 0 && total >= 2 && e.hit === 0) warn("hole-cache-cold", `The hole ${label(e.id)} has maxAge ${e.ttl}s but its cache never hit in ${total} requests (${fmt_ms(e.ms / total)} ms each).`, { fix: "The cache key carries the props and the session seal: per-visitor props (a user id, a timestamp) make every key unique. Pass only what the hole renders from." });
+		else if (e.ttl > 0 && e.hit > 0) info("hole-cache", `The hole ${label(e.id)}: ${e.hit} of ${total} requests served from the render cache (maxAge ${e.ttl}s).`);
+	}
+	if (rows.filter((h) => h.ttl === 0).length && econ.size) {
+		const slow = [...econ.values()].filter((e) => e.ttl === 0 && e.ms / Math.max(e.hit + e.miss + e.none, 1) >= 20);
+		if (slow.length) info("hole-uncached", `${slow.length} hole${slow.length === 1 ? "" : "s"} render${slow.length === 1 ? "s" : ""} fresh on every visit: ${names(slow.map((e) => `${label(e.id)} at ${fmt_ms(e.ms / Math.max(e.hit + e.miss + e.none, 1))} ms`))}.`, { fix: "Content that is the same for every visitor for a while can take a maxAge (a preset: { render: 'deferred', maxAge: '5m' }): the endpoint then serves the memo." });
+	}
+	const client = extras.client ?? [];
+	if (client.length) {
+		const seen = new Set(client.map((c) => c.entry));
+		for (const r of extras.visit?.regions ?? []) if (r.failed !== void 0 && r.entry) seen.add(r.entry);
+		const path_of_entry = (e) => {
+			try {
+				return new URL(e, "http://x/").pathname;
+			} catch {
+				return e;
+			}
+		};
+		const vh = extras.visit?.viewport?.[1];
+		const below_regions = vh ? (extras.visit?.regions ?? []).filter((g) => g.top >= vh) : [];
+		const below_fps = new Set(below_regions.map((g) => g.fp));
+		const below = /* @__PURE__ */ new Set([...below_regions.filter((g) => g.entry).map((g) => path_of_entry(g.entry)), ...island_rows_of(meta).filter((r) => below_fps.has(r.fp)).map((r) => path_of_entry(r.entry))]);
+		const placed = !!vh && (extras.visit?.regions?.length ?? 0) > 0;
+		const unplaced = placed ? [] : islands.filter((r) => r.wake === "visible" && !seen.has(r.entry));
+		const silent = islands.filter((r) => (r.wake === "load" || r.wake === "idle" || r.wake === "visible" && placed && !below.has(path_of_entry(r.entry))) && !seen.has(r.entry));
+		if (unplaced.length) info("never-hydrated", `${names(unplaced.map((r) => `${island_name(r)} (${r.count > 1 ? `${r.count} copies, ` : ""}wake: visible)`))} never reported waking, while ${client.length} other island${client.length === 1 ? "" : "s"} did. No visit said where ${unplaced.length === 1 ? "it sits" : "they sit"} on the page, so whether a visitor ever scrolled ${unplaced.length === 1 ? "it" : "them"} into view is unknown: a visit from a browser carrying the profiler's key tells.`);
+		if (silent.length) warn("never-hydrated", `${names(silent.map((r) => `${island_name(r)} (${r.count > 1 ? `${r.count} copies, ` : ""}wake: ${r.wake})`))} never reported hydrating in your visits, while ${client.length} other island${client.length === 1 ? "" : "s"} did.`, { fix: "A 'visible' island that never intersects the viewport never wakes: check the page can scroll (a design system's stylesheet can pin the body) and that the island is not hidden. A 'load' island that stays silent threw on wake: the browser console has it." });
+	}
+	const broken = client.filter((c) => c.recovered > 0);
+	if (broken.length) {
+		const fps_of = (entry) => new Set(island_rows_of(meta).filter((r) => r.entry === entry).map((r) => r.fp));
+		const seen_of = (c) => {
+			const fps = fps_of(c.entry);
+			return (extras.visit?.islands ?? []).filter((i) => i.recovered && (fps.has(i.fp) || i.entry === c.entry));
+		};
+		const all_same = broken.filter((c) => {
+			const seen = seen_of(c);
+			return seen.length > 0 && seen.every((i) => !i.changed && !i.healed && i.ssr_bytes !== void 0);
+		});
+		const rewired = all_same.filter((c) => seen_of(c).some((i) => i.markers));
+		if (rewired.length) {
+			const one = rewired.length === 1;
+			const m = seen_of(rewired[0]).find((i) => i.markers).markers;
+			const n = rewired.reduce((s, c) => s + c.recovered, 0);
+			warn("hydration-mismatch", `${names(rewired.map(island_name))} discarded ${one ? "its" : "their"} server-rendered DOM and re-rendered in the browser (${n} time${n === 1 ? "" : "s"} seen): ${one ? "its" : "their"} markup arrived with Svelte's hidden block markers unpaired (${m[0]} opening, ${m[1]} closing), and a render always pairs them. Something rewrote ${one ? "it" : "them"} between the server and the browser; the markup the component drew is the same.`, { fix: "Find the rewrite: a transformPageChunk or HTML middleware after the render, an edge rewriter, or a proxy that strips HTML comments. Keep it out of ogygia-region subtrees (or run it before ogygia’s render), and let comments through." });
+		}
+		const same = all_same.filter((c) => !rewired.includes(c));
+		if (same.length) {
+			const one = same.length === 1;
+			const n = same.reduce((s, c) => s + c.recovered, 0);
+			warn("hydration-mismatch", `${names(same.map(island_name))} discarded ${one ? "its" : "their"} server-rendered DOM and re-rendered in the browser (${n} time${n === 1 ? "" : "s"} seen) — and drew the same markup ${one ? "it" : "they"} threw away: only Svelte's hidden block markers disagreed. ${one ? "Its" : "Their"} code drew no other tree: the island's host and its server render disagree on structure (a wrapper of ogygia's), or a block ({#if}, {#each}) took another branch to the same output.`, { fix: "Report it to ogygia with this page and how the island is placed (keep:, inside a snippet, nested in another island): a host that hydrates in another shape than it renders is ogygia's bug. If a block's two branches draw the same thing, give them one branch." });
+		}
+		const rest = broken.filter((c) => !all_same.includes(c));
+		const total = rest.reduce((s, c) => s + c.recovered, 0);
+		const lines = rest.flatMap((c) => extras.hazards?.[c.entry] ?? []);
+		if (rest.length) warn("hydration-mismatch", `${names(rest.map(island_name))} discarded ${rest.length === 1 ? "its" : "their"} server-rendered DOM and re-rendered in the browser (${total} time${total === 1 ? "" : "s"} seen): the markup the browser found was not what the server sent.` + (lines.length ? ` ${hazard_words(lines)}` : ""), {
+			fix: lines.length ? `${hazard_fix(lines)} If none of them is it, something edits the HTML between the render and the wake: a post-SSR pass, a script that runs before the runtime, a comment-stripping proxy.` : "Something edits the HTML between the render and the wake — a post-SSR pass (a design-system renderer, a DSD injector), a script that runs before the runtime, a comment-stripping proxy. Keep it out of ogygia-region subtrees, or run it before ogygia’s render.",
+			...lines[0] ? {
+				file: lines[0].file,
+				line: lines[0].line
+			} : {}
+		});
+	}
+	if (client.length) {
+		const slow = [...client].sort((x, y) => y.p50_ms - x.p50_ms)[0];
+		const rows = island_rows_of(meta);
+		const copies_of = (entry) => rows.filter((r) => r.entry === entry).reduce((s, r) => s + (r.count || 1), 0);
+		const copies = client.reduce((s, c) => s + copies_of(c.entry), 0);
+		const n_slow = copies_of(slow.entry);
+		const fps = new Set(rows.filter((r) => r.entry === slow.entry).map((r) => r.fp));
+		const mine = (extras.visit?.islands ?? []).filter((i) => fps.has(i.fp) && i.done >= i.t0);
+		const med = (xs) => xs.length ? [...xs].sort((a, b) => a - b)[xs.length >> 1] : 0;
+		const load = mine.length ? med(mine.map((i) => i.loaded - i.t0)) : slow.load_p50_ms;
+		const wait = mine.length ? med(mine.map((i) => i.turn !== void 0 ? i.turn - i.loaded : 0)) : 0;
+		const step = mine.length ? med(mine.map((i) => Math.max(i.done, i.fx ?? 0) - (i.turn ?? i.loaded))) : Math.max(0, slow.p50_ms - slow.load_p50_ms);
+		const whole = load + wait + step || slow.p50_ms;
+		const why = load >= whole * .6 ? "load" : wait >= whole * .5 ? "wait" : "step";
+		let behind = "";
+		let behind_name = "";
+		if (why === "wait" && mine.length) {
+			const one = [...mine].sort((a, b) => (a.turn ?? a.loaded) - a.loaded - ((b.turn ?? b.loaded) - b.loaded))[mine.length >> 1];
+			const w0 = one.loaded;
+			const w1 = one.turn ?? one.loaded;
+			const name_of = new Map(rows.map((r) => [r.fp, island_name(r)]));
+			const by = /* @__PURE__ */ new Map();
+			for (const o of extras.visit?.islands ?? []) {
+				if (o === one || o.turn === void 0) continue;
+				const ran = Math.min(o.done, w1) - Math.max(o.turn, w0);
+				if (ran > 0) by.set(name_of.get(o.fp) ?? o.fp.slice(0, 8), (by.get(name_of.get(o.fp) ?? o.fp.slice(0, 8)) ?? 0) + ran);
+			}
+			const top = [...by].sort((a, b) => b[1] - a[1])[0];
+			if (top && top[1] >= (w1 - w0) * .3) {
+				behind_name = top[0];
+				behind = `, most of it behind ${top[0]} (${fmt_ms(top[1])} ms of hydrating)`;
+			}
+		}
+		const slow_wake = rows.find((r) => r.entry === slow.entry)?.wake;
+		info("client-hydrate", `In the browser, ${copies} island${copies === 1 ? "" : "s"} of ${client.length} component${client.length === 1 ? "" : "s"} reported hydration. The slowest, ${island_name(slow)}${n_slow > 1 ? ` (${n_slow} copies)` : ""}, took ${fmt_ms(slow.p50_ms)} ms from wake to hydrated at the median` + (mine.length ? `: ${fmt_ms(load)} ms loading its modules, ${fmt_ms(wait)} ms waiting its turn behind other islands${behind}, ${fmt_ms(step)} ms hydrating.` : load >= slow.p50_ms * .6 ? `, mostly loading its ${fmt_ms(load)} ms of modules.` : "."), { fix: why === "load" ? "Module load dominates: a smaller closure (see the Islands table) or an earlier preload helps more than faster code." : why === "wait" ? behind ? `It waited for its turn: islands hydrate one per task, and ${behind_name} held the queue. Make that hydrate step short (fewer elements, split the island), or wake it later.` : slow_wake === "visible" ? "It waited for its turn: islands hydrate one per task, and many became visible at once (a fast scroll, a tall screen). Make the copies with nothing to click lakes, or render the list as one island." : "It waited for its turn: islands hydrate one per task, so many waking at once queue behind each other. Wake the ones below the first screen when visible, the rest when idle, and make the ones with nothing to click lakes." : "The hydrate step itself is slow: fewer elements per island, or split the island so the interactive part is small." });
+	}
+}
+/** Kit-shaped findings: the load lanes and the parent() chain, universal loads, and the client
+*  router's serialization of load data. */
+/** ms of devalue work done for Kit's copy of the server load data: each devalue function's own time,
+*  by the share of its call paths that pass through Kit's serializer (`add_node`, data_serializer.js,
+*  or render_response). A function with no recorded paths counts only when it is `uneval` itself. */
+function kit_load_serialize_ms(a) {
+	let ms = 0;
+	for (const f of a.functions) {
+		if (f.pkg !== "devalue") continue;
+		const stacks = f.stacks ?? [];
+		if (!stacks.length) {
+			if (f.name === "uneval") ms += f.self_ms;
+			continue;
+		}
+		let kit = 0;
+		let all = 0;
+		for (const s of stacks) {
+			all += s.ms;
+			if (s.frames.some((fr) => fr.n === "add_node" || fr.n === "render_response" || fr.f.indexOf("data_serializer") !== -1)) kit += s.ms;
+		}
+		if (all > 0) ms += f.self_ms * (kit / all);
+	}
+	return ms;
+}
+function kit_findings(a, meta, info, warn) {
+	const tl = a.timeline;
+	if (tl?.chain) {
+		const c = tl.chain;
+		const u = c.parent_use;
+		const names = u ? u.names.join(", ") : "";
+		const used = !u ? "" : u.first_use === null ? ` Nothing after line ${u.line} reads ${names}: the page waited on the layout for nothing.` : u.awaits_before_use > 0 ? ` It takes ${names} from parent() on line ${u.line} but first reads ${u.names.length === 1 ? "it" : "them"} on line ${u.first_use}; the ${u.awaits_before_use} await${u.awaits_before_use === 1 ? "" : "s"} between never needed the layout.` : "";
+		warn("parent-chain", `${c.page} started only after ${c.layout} finished (${fmt_ms(c.serial_ms)} ms later)` + (c.explicit || u ? " — it awaits parent()." : " — Kit runs a page load and its layout loads together unless the page awaits parent().") + used, {
+			fix: u && u.first_use !== null && u.awaits_before_use > 0 ? `Move \`await parent()\` down to just before line ${u.first_use}, where ${names} is first used: the calls above it then run while the layout's load does.` : "Move the await parent() below the page's own fetches (start them first, await parent() after), or pass what the page needs some other way — the two loads then overlap.",
+			...u ? {
+				file: c.page,
+				line: u.line
+			} : {}
+		});
+	}
+	for (const l of tl?.lanes ?? []) if (l.kind === "universal" && l.wait_ms >= 5) info("universal-load", `${l.file} is a universal load: on this render it waited ${fmt_ms(l.wait_ms)} ms on calls. On a page with the client router it runs again in the browser on every navigation, and its data must be serializable.`, { fix: "If it only needs the server (a database, a secret, a private API), rename it +" + l.level + ".server.ts and the browser never runs it." });
+	const uneval = a.functions.filter((f) => f.pkg === "devalue").sort((x, y) => y.self_ms - x.self_ms);
+	const kit_ms = kit_load_serialize_ms(a);
+	const runs = meta.trigger === "page" ? Math.max(meta.runs?.length ?? 1, 1) : 1;
+	if (uneval.length && kit_ms >= 3 && kit_ms >= a.busy_ms * .03) {
+		const csr_false = meta.requests.some((r) => r.internal && r.og);
+		info("kit-uneval", csr_false ? `Kit serialized this page's server load data: ${fmt_ms(kit_ms / runs)} ms per render (devalue.uneval). On a csr=false page nothing reads that copy — Kit builds it on every request and drops it.` : `Kit serialized the load data for its client router: ${fmt_ms(kit_ms / runs)} ms per render (devalue.uneval). This page has csr on.`, {
+			anchor: `fn:${uneval[0].key}`,
+			fix: csr_false ? "Only less load data helps: return from the server loads (+page.server.ts, +layout.server.ts) only what this page renders. Islands get what they read from ogygia’s own seed, shaped apart from it. The work is Kit’s, not yours." : "Return from the server load only what the page renders: Kit serializes all of it into the HTML for its client router. (csr=false does not make it free — Kit still builds the copy and drops it — so less data is the fix either way.)"
+		});
+	}
+	const busy = a.busy_ms || 1;
+	const list = a.components.find((c) => (c.calls ?? 0) >= 20 && c.parent && c.total_ms >= busy * .1);
+	if (list) {
+		const n = list.calls ?? 0;
+		info("hot-list", `${list.parent} renders ${n} ${list.name} rows per render, ${fmt_ms(list.total_ms / runs)} ms together (${fmt_ms(list.total_ms / runs / Math.max(n, 1))} ms each).`, {
+			anchor: `comp:${list.parent}`,
+			fix: "The list is the cost, not the row: page it, window it, or defer the part below the fold into a hole."
+		});
+	}
+	const split = a.components.find((c) => (c.markup_ms ?? 0) + (c.logic_ms ?? 0) >= busy * .15 && (c.markup_ms ?? 0) + (c.logic_ms ?? 0) >= 5);
+	if (split) {
+		const m = (split.markup_ms ?? 0) / runs;
+		const l = (split.logic_ms ?? 0) / runs;
+		const own = m + l;
+		if (m >= own * .7) info("markup-heavy", `${split.name}'s own time is mostly building markup: ${fmt_ms(m)} of ${fmt_ms(own)} ms is Svelte writing its template per render, ${fmt_ms(l)} ms its script.`, {
+			anchor: `comp:${split.name}`,
+			fix: "Fewer elements and attributes per instance help here; the script is not the problem. Static blocks can move into a lake or a prebaked snippet."
+		});
+		else if (l >= own * .7) info("logic-heavy", `${split.name}'s own time is mostly its script: ${fmt_ms(l)} of ${fmt_ms(own)} ms runs code per render, only ${fmt_ms(m)} ms writes markup.`, {
+			anchor: `comp:${split.name}`,
+			fix: "Open the row: the hot function under it is the one to hoist into load or cache per request."
+		});
+	}
+}
+/** Cold vs warm per file: what the first render paid over a warm one (module load + compile). */
+function cold_rows(a, meta) {
+	if (!meta.cold) return [];
+	const runs = runs_of(meta);
+	const warm = new Map(a.files.map((f) => [f.key, f.self_ms / runs]));
+	return meta.cold.files.map((f) => {
+		const w = warm.get(f.file) ?? 0;
+		return {
+			file: f.file,
+			category: f.category,
+			cold_ms: f.ms,
+			warm_ms: round1(w),
+			extra_ms: round1(f.ms - w)
+		};
+	}).filter((r) => r.extra_ms >= .5).sort((x, y) => y.extra_ms - x.extra_ms);
+}
+/** The spread of a component across runs: median of the rest against the max, and the cold first run. */
+function run_spread(runs_ms) {
+	if (runs_ms.length < 2) return null;
+	const sorted = [...runs_ms].sort((x, y) => x - y);
+	const median = sorted[Math.floor(sorted.length / 2)];
+	const max = sorted[sorted.length - 1];
+	const rest = runs_ms.slice(1);
+	const rest_median = [...rest].sort((x, y) => x - y)[Math.floor(rest.length / 2)];
+	return {
+		min: sorted[0],
+		median,
+		max,
+		max_run: runs_ms.indexOf(max) + 1,
+		/** the median of every run after the first: what "warm" costs */
+		after: rest_median,
+		cold: runs_ms[0] >= 5 && runs_ms[0] >= rest_median * 2.5 && max === runs_ms[0]
+	};
+}
+/** Do the runs climb? The page getting slower render by render — what a page that keeps memory, or
+*  a cache that grows without a bound, does to an instance as it ages. The slope is the median of
+*  every pair's slope (one slow run cannot tilt it), and it counts only when most pairs agree: at
+*  least 3 of 4 later runs slower than an earlier one. A cold first run is left out (that is the
+*  cold start, not a climb). Needs 4 runs; null when the runs do not climb. */
+function run_trend(runs_ms) {
+	let r = runs_ms;
+	if (r.length >= 5 && run_spread([...r])?.cold) r = r.slice(1);
+	const n = r.length;
+	if (n < 4) return null;
+	const slopes = [];
+	let up = 0;
+	let pairs = 0;
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		slopes.push((r[j] - r[i]) / (j - i));
+		if (r[j] > r[i]) up++;
+		pairs++;
+	}
+	slopes.sort((x, y) => x - y);
+	const slope = slopes[Math.floor(slopes.length / 2)];
+	const agree = up / pairs;
+	const base = Math.min(r[0], r[1]);
+	const rise = slope * (n - 1);
+	if (slope <= 0 || agree < .75 || base <= 0 || rise < Math.max(3, base * .05)) return null;
+	return {
+		from: round1(r[0]),
+		to: round1(r[n - 1]),
+		slope_ms: round1(slope),
+		rise_ms: round1(rise),
+		rise_pct: Math.round(rise / base * 100),
+		agree: Math.round(agree * 100) / 100,
+		runs: n
+	};
+}
+/** Findings from the accuracy round: the upstream's own split of a wait, the cold render, a
+*  component whose runs disagree, and the browser's vitals against the server's render. */
+function accuracy_findings(a, meta, extras, info, warn) {
+	const runs = runs_of(meta);
+	const told = extras.net.filter((c) => c.ms >= 0 && c.timings?.length).sort((x, y) => y.ms + (y.body_ms ?? 0) - (x.ms + (x.body_ms ?? 0)))[0];
+	if (told && told.ms >= 20) {
+		const sum = told.timings.reduce((s, t) => s + t.ms, 0);
+		const largest = Math.max(0, ...told.timings.map((t) => t.ms));
+		const nested = sum > told.ms;
+		const theirs = Math.min(told.ms, nested ? largest : sum);
+		const parts = told.timings.filter((t) => t.ms > 0).sort((x, y) => y.ms - x.ms).slice(0, 4).map((t) => `${t.desc ?? t.name} ${fmt_ms(t.ms)} ms`).join(", ");
+		const { host, tpl } = path_template(told.url);
+		info("upstream-split", `${told.method} ${host}${tpl} waited ${fmt_ms(told.ms)} ms; its own Server-Timing says ${parts || "nothing measurable"}` + (theirs > 0 ? ` — ${fmt_ms(theirs)} ms of the wait is on their side${nested ? " (the entries overlap, so the largest is taken as the whole)" : ""}, ${fmt_ms(Math.max(0, told.ms - theirs))} ms is the network and their framework.` : "."), { fix: theirs >= told.ms * .6 ? "The wait is theirs: take the biggest entry to whoever owns that service, or cache the response." : "Most of the wait is outside their measured work: the network path, TLS, or a queue in front of them." });
+	}
+	if (meta.cold && meta.runs?.length) {
+		const warm = [...meta.runs].sort((x, y) => x - y)[Math.floor(meta.runs.length / 2)];
+		const rows = cold_rows(a, meta);
+		const extra = rows.reduce((s, r) => s + r.extra_ms, 0);
+		const parts = (meta.cold.owners ?? []).map((o) => {
+			const w = a.owner_runs_ms?.[o.label];
+			const med = w?.length ? [...w].sort((x, y) => x - y)[Math.floor(w.length / 2)] : 0;
+			return {
+				label: o.label,
+				extra: o.ms - med
+			};
+		}).filter((o) => o.extra >= 5).sort((x, y) => y.extra - x.extra).slice(0, 3);
+		const by_part = parts.length ? `; by part of the render: ${parts.map((o) => `${o.label} +${fmt_ms(o.extra)} ms`).join(", ")}` : "";
+		if (meta.cold.ms >= warm * 1.5 && meta.cold.ms - warm >= 50) {
+			const more = meta.cold.ms - warm;
+			const cpu_more = Math.min(more, Math.max(0, meta.cold.busy_ms - a.busy_ms / runs));
+			const wait_more = more - cpu_more;
+			const calls = meta.cold.calls;
+			const waiting = calls === 0 ? `, and ${fmt_ms(wait_more)} ms more waiting with no outbound call in that render: not the network, but the first loads of the modules and files it reads (a dynamic import, a file read), which CPU samples do not show` : `, and ${fmt_ms(wait_more)} ms more waiting (${calls ? `its ${calls} outbound call${calls === 1 ? "" : "s"} opened new connections` : "its connections were new"}: DNS, TLS, empty pools)`;
+			warn("cold-start", `The first render took ${fmt_ms(meta.cold.ms)} ms against ${fmt_ms(warm)} ms warm: ${fmt_ms(cpu_more)} ms more CPU (module load, compile, first-call caches)` + (rows[0] ? `, ${share_word(rows[0].extra_ms, cpu_more)} ${rows[0].file} (${fmt_ms(rows[0].extra_ms)} ms)` : "") + by_part + (wait_more >= 10 ? waiting : "") + ". On a serverless host every cold instance pays this.", { fix: wait_more > cpu_more && calls !== 0 ? "Most of it is the first calls opening their connections: reuse one HTTP agent or client across requests (module scope, keep-alive on), and keep calls to services that are slow to connect out of the first render where you can." : "Fewer and smaller server modules on the page’s path: lazy-import what the render rarely needs, keep heavy libraries out of hooks and layouts, and prefer a warm instance (provisioned concurrency) where the platform offers one." });
+		} else if (rows.length && extra >= 20) info("cold-start", `The first render paid ${fmt_ms(extra)} ms of module load and compile over a warm one, ${share_word(rows[0].extra_ms, extra)} ${rows[0].file} (${fmt_ms(rows[0].extra_ms)} ms)${by_part}.`);
+	}
+	const inst = meta.instance;
+	if (meta.lambda && inst && inst.first_request_ms >= 100) {
+		const first_render = meta.cold && meta.runs?.length ? meta.cold.ms - [...meta.runs].sort((x, y) => x - y)[Math.floor(meta.runs.length / 2)] : 0;
+		info("cold-instance", `This instance took ${fmt_ms(inst.first_request_ms)} ms from its process starting to its first request: Node's own startup ${fmt_ms(inst.node_ms)} ms, the rest loading the server bundle and its imports and the platform handing the request over. Every new instance on AWS Lambda pays that before its first render` + (first_render >= 20 ? `, and the first render then pays about ${fmt_ms(first_render)} ms more to warm up` : "") + `. This one was ${inst.age_s} s old and had served ${inst.requests_before} request${inst.requests_before === 1 ? "" : "s"} before this recording.`, { fix: "Load less at startup: import heavy SDKs where a page needs them (a dynamic import inside the load or the handler), keep them out of hooks.server and root layouts, and use provisioned concurrency where the first visitor after a quiet spell matters." });
+	}
+	const climb = meta.trigger === "page" && meta.runs ? run_trend(meta.runs) : null;
+	if (climb) {
+		const kept = extras.retained && extras.retained.total_bytes >= 262144 ? extras.retained : void 0;
+		const g = extras.growth;
+		const why = kept ? ` One render leaves ${Math.round(kept.total_bytes / 1048576 * 10) / 10} MB alive after a full collection${g ? g.levels_off ? ", and it levels off, so the climb should stop once that cache is full" : ", and it keeps growing, so the climb will not stop" : ""}: the bigger heap makes every collection, and every lookup in what is kept, cost more.` : " Nothing this report measured was left alive by a render, so look for a list, map or cache the page adds to on every request (a memo keyed by something new each time), or a timer or listener it registers again each render.";
+		warn("slower-each-run", `Each render took about ${fmt_ms(climb.slope_ms)} ms longer than the one before: ${fmt_ms(climb.from)} ms → ${fmt_ms(climb.to)} ms over ${climb.runs} runs (+${climb.rise_pct}%).${why} On a long-lived server this keeps climbing until the instance restarts, and the times in this report sit somewhere along the way.`, {
+			fix: kept ? "Bound or release what a render keeps (the Kept per render pattern names the line), then profile again: the runs should come out flat." : "Profile again with more renders: if the climb holds, find what grows per request; if it flattens, it was a cache warming.",
+			...kept?.sites[0]?.url ? {
+				file: kept.sites[0].url,
+				line: kept.sites[0].line
+			} : {}
+		});
+	}
+	const heap0 = extras.mem[0]?.heap_used;
+	const kept_each = extras.retained?.total_bytes ?? 0;
+	if (meta.trigger === "page" && heap0 !== void 0 && heap0 >= 256 && kept_each >= 8388608 && !extras.growth?.levels_off) {
+		const kept_mb = kept_each / 1048576;
+		const worth = Math.round(heap0 / kept_mb);
+		if (worth >= 6) warn("heap-filled-before", `This profile started with ${Math.round(heap0)} MB of heap in use: about ${worth} renders' worth of what this page keeps alive (${Math.round(kept_mb * 10) / 10} MB each), left by earlier requests. A bigger heap makes every render slower, so the times here are higher than a freshly started server shows, and the next profile will read higher still.`, { fix: "Fix what a render keeps (the Kept per render pattern names the line). Until then, compare numbers from freshly started servers only: restart, then profile once." });
+	}
+	if (runs > 1) {
+		const spread = a.components.map((c) => ({
+			c,
+			s: c.runs_ms ? run_spread(c.runs_ms) : null
+		})).filter((x) => !!x.s && x.s.max >= 5).sort((x, y) => y.s.max - y.s.median - (x.s.max - x.s.median))[0];
+		if (spread && spread.s.cold) info("component-cold-run", `${spread.c.name} took ${fmt_ms(spread.s.max)} ms in the first render and ${fmt_ms(spread.s.after)} ms after: a cache that was cold, or a lazy import — not a slow component.`, {
+			anchor: `comp:${spread.c.name}`,
+			fix: "Warm it at startup, or accept it: only the first request after a deploy pays this."
+		});
+		else if (spread && spread.s.max >= spread.s.median * 3 && spread.s.max - spread.s.median >= 10) warn("component-variance", `${spread.c.name} is ${fmt_ms(spread.s.median)} ms in most renders but ${fmt_ms(spread.s.max)} ms in run ${spread.s.max_run}: something it waits on or caches is not steady.`, {
+			anchor: `comp:${spread.c.name}`,
+			fix: "Open the row: the per-run column shows the spread; a cache with a short TTL, a GC pause, or a shared upstream are the usual causes."
+		});
+	}
+	const marks = extras.client_marks ?? [];
+	if (marks.length) {
+		const slow = [...marks].sort((x, y) => y.p50_ms - x.p50_ms)[0];
+		const failed = marks.filter((m) => m.errors > 0);
+		info("client-mark", `In the browser the app marked ${marks.length} thing${marks.length === 1 ? "" : "s"}: the slowest is ${slow.name} at ${fmt_ms(slow.p50_ms)} ms (p50 of ${slow.n})` + (failed.length ? `; ${failed.map((m) => m.name).join(", ")} failed.` : "."), { fix: slow.p50_ms >= 300 ? `${slow.name} is a wait the visitor feels after the HTML arrived: it is not the server render, take it to whatever ${slow.name} times.` : void 0 });
+	}
+	const v = extras.vitals;
+	if (v && v.lcp !== null) {
+		const server = meta.runs?.length ? [...meta.runs].sort((x, y) => x - y)[Math.floor(meta.runs.length / 2)] : meta.request?.ms ?? 0;
+		const ttfb = v.ttfb ?? 0;
+		if (v.lcp - ttfb >= Math.max(500, ttfb) && server > 0) {
+			const own = extras.visit;
+			const font = lcp_font(own);
+			const after = (own?.paints?.lcp_url ? vital_parts({
+				vitals: {},
+				visit: {
+					nav: own.nav,
+					paints: own.paints,
+					resources: own.resources
+				},
+				islands: [],
+				firsts: [],
+				shifts: [],
+				longtasks: []
+			}, "lcp") : null)?.filter((x) => x.key !== "ttfb") ?? [];
+			const top = after.length ? after.reduce((a, b) => b.ms > a.ms ? b : a) : null;
+			const gap = (own?.paints?.lcp ?? v.lcp) - ttfb;
+			const lcp_file = own?.paints?.lcp_url ? own.paints.lcp_url.slice(own.paints.lcp_url.lastIndexOf("/") + 1).split("?")[0] : "";
+			const part = !font && top && top.ms >= gap / 2 ? top : null;
+			const PART_WORDS = {
+				delay: [`most of it (${fmt_ms(part?.ms ?? 0)} ms) before the browser began fetching the largest paint, ${lcp_file}.`, part?.key === "delay" ? late_found(own?.paints, own?.resources.find((r) => r.url === own?.paints?.lcp_url), own?.islands ?? [], (fp) => {
+					const r = fp ? island_rows_of(meta).find((x) => x.fp === fp) : void 0;
+					return r ? island_name(r) : "its island";
+				}) : ""],
+				load: [`most of it (${fmt_ms(part?.ms ?? 0)} ms) downloading the largest paint, ${lcp_file}.`, "The largest paint is slow to download: make it smaller (a modern format, sized to how it shows, `srcset`) and serve it from close by. The server is not the bottleneck here."],
+				render: [`most of it (${fmt_ms(part?.ms ?? 0)} ms) after the largest paint, ${lcp_file}, had arrived: something held its paint.`, "The largest paint was ready but did not paint: render-blocking styles or scripts, or an island that shows it on waking. Render it with the server HTML."]
+			};
+			const words = part ? PART_WORDS[part.key] : void 0;
+			const rivals = font || part?.key === "load" || part?.key === "delay" ? lcp_rivals(own) : null;
+			warn("lcp-gap", `In the browser LCP is ${fmt_ms(v.lcp)} ms while the server answered in ${fmt_ms(ttfb)} ms (TTFB; the render itself ${fmt_ms(server)} ms): ${fmt_ms(v.lcp - ttfb)} ms of the user's wait is after the HTML arrived — ` + (font ? `the largest paint is text that waited for its font '${font.family}' (${font.file}, in at ${fmt_ms(font.end)} ms), invisible until it came.` : words ? words[0] : "assets, fonts, hydration.") + (rivals ? ` Beside it, ${fmt_bytes(rivals.bytes)} of images far below the first screen downloaded (${rivals.files.join(", ")}).` : ""), { fix: (font ? "Give the font's @font-face `font-display: swap` (or `optional`) and preload the file: the text paints with the HTML, and the server is not the bottleneck here." : words ? words[1] : "Make the hero markup static (a lake), preload its image and font, and keep the islands above the fold small: the server is not the bottleneck here.") + (rivals ? " And give the images below the first screen `loading=\"lazy\"`: they took a share of the network the largest paint needed." : "") });
+		} else if (ttfb > 0 && ttfb >= server * 2 && ttfb - server >= 200) {
+			const own = extras.visit?.nav;
+			const ph = own?.phases;
+			const held = extras.doc_request?.ms;
+			let split = "";
+			let where = null;
+			if (ph && held !== void 0) {
+				const connect = (ph.redirect ?? 0) + (ph.worker ?? 0) + (ph.dns ?? 0) + (ph.connect ?? 0) + (ph.tls ?? 0);
+				const before = Math.max(0, (ph.wait ?? 0) - held);
+				const inside = Math.max(0, held - server);
+				where = connect >= before && connect >= inside ? "connect" : before >= inside ? "before" : "inside";
+				split = ` In the report's own visit (TTFB ${fmt_ms(own.res_start)} ms): ${fmt_ms(connect)} ms redirecting and connecting, ${fmt_ms(before)} ms before the server's handler took the request, and ${fmt_ms(inside)} ms inside the handler beyond the render.`;
+			}
+			warn("ttfb-gap", `TTFB in the browser is ${fmt_ms(ttfb)} ms but this server rendered the page in ${fmt_ms(server)} ms: ${fmt_ms(ttfb - server)} ms sits between the two${where ? "." : " — a cold instance, a proxy, or the network."}${split}`, { fix: where === "connect" ? "The connection is the cost: redirects to drop, or a server far from the visitor (serve it from the edge, keep TLS and HTTP modern)." : where === "before" ? "The request waited before this server took it: a proxy or CDN in front, a cold instance starting, or the network. Look at what fronts the server, and at the cold-start section." : where === "inside" ? meta.dev ? "The server held the request past its render: on the dev server a first request compiles the page (profile a build for its real TTFB), or a hook before the render awaits something." : "The server held the request past its render: a hook before or after the render (auth, a session lookup, a redirect check) awaits something. Profile it with the handle, not only the page." : "Look at the cold-start section and at what fronts the server (a CDN, an auth proxy): the render is not where that time goes." });
+		} else info("browser-vitals", `The browser measured TTFB ${v.ttfb === null ? "—" : fmt_ms(v.ttfb) + " ms"}, LCP ${fmt_ms(v.lcp)} ms${v.cls !== null ? `, CLS ${v.cls}` : ""}${v.inp !== null ? `, INP ${fmt_ms(v.inp)} ms` : ""} over ${v.n} visit${v.n === 1 ? "" : "s"}.` + (dock_skewed(extras.visit) ? " The latest visit loaded with the devtools dock open, and its paints may be the dock’s: read the paints from a visit with the dock closed." : ""));
+	}
+}
+/**
+* The whole profile as one curated JSON object — the agent-facing view. Served
+* at `<base>/report/<id>.json`. Not the raw V8 profile (that is `/raw`): this is
+* already analyzed — self/total per component, network attribution, memory, GC,
+* and the same findings the human report shows.
+*/
+/** One stack frame as agents read it: `name (file:line)`. */
+const frame_text = (fr) => fr.f ? `${fr.n} (${fr.f})` : fr.n;
+/** Gather the ogygia signals a page score reads — the same numbers the findings above compute, so
+*  the score and the findings never disagree. All safe when a signal is absent (no visits, no server
+*  timing). See {@link page_score}. */
+function page_score_of(meta, extras) {
+	const islands = group_islands(island_rows_of(meta));
+	const og = [...meta.requests].filter((r) => r.og).sort((x, y) => y.og.seed_bytes + y.og.tail_bytes - (x.og.seed_bytes + x.og.tail_bytes))[0]?.og;
+	const client = extras.client ?? [];
+	const seen_entry = new Set(client.map((c) => c.entry));
+	const server_ms = meta.runs?.length ? [...meta.runs].sort((x, y) => x - y)[Math.floor(meta.runs.length / 2)] : meta.request?.ms ?? null;
+	const v = extras.vitals;
+	const visit = extras.visit;
+	const pa = extras.assets;
+	const sj = start_js(extras);
+	const assets = pa ? {
+		js: sj.js,
+		js_wire: sj.js_wire,
+		js_files: sj.js_files,
+		lazy_js: Math.max(0, pa.totals.lazy_js - (sj.woke_early?.bytes ?? 0) - (sj.runtime_parts?.bytes ?? 0)),
+		css: pa.totals.css,
+		wire: pa.totals.wire + (sj.runtime?.wire ?? 0) + (sj.runtime_parts?.wire ?? 0),
+		blocking: pa.totals.blocking,
+		blocking_count: pa.totals.blocking_count,
+		top: pa.assets.filter((x) => x.kind === "script" && !x.lazy).slice(0, 4).map((x) => `${asset_name(x.url)} ${fmt_bytes(x.bytes)}${x.contains?.length ? ` (${x.contains.slice(0, 3).join(", ")})` : ""}`).concat(sj.runtime ? [`loaded at runtime ${sj.runtime.island_entries && extras.visit?.holes_answered?.length ? `(islands inside its holes) ${fmt_bytes(sj.runtime.bytes)}` : `by other scripts ${fmt_bytes(sj.runtime.bytes)} (${sj.runtime.by[0].who})`}`] : [])
+	} : null;
+	const inline_script = extras.strip?.by_kind.script ?? pa?.inline.script ?? 0;
+	const data_parts = [
+		["page seed", og?.seed_bytes ?? 0],
+		["island props", og?.tail_bytes ?? 0],
+		["remote seed", og?.remote_seed_bytes ?? 0],
+		["inline script", inline_script]
+	];
+	const data_bytes = data_parts.reduce((s, [, b]) => s + b, 0);
+	const no_longtasks = !!visit?.unsupported?.includes("longtask");
+	const no_shifts = !!visit?.unsupported?.includes("layout-shift");
+	const tbt = no_longtasks ? null : visit?.longtasks?.length ? Math.round(visit.longtasks.reduce((s, t) => s + Math.max(0, t.ms - 50), 0)) : visit ? 0 : null;
+	const unmeasured = {
+		...no_longtasks ? { tbt: "the browser that visited does not report long tasks (Safari, for one): profile the page from a Chromium browser to measure it" } : {},
+		...no_shifts ? { cls: "the browser that visited does not report layout shifts (Safari, for one): profile the page from a Chromium browser to measure it" } : {}
+	};
+	const inputs = {
+		assets,
+		...extras.assets_missing ? { assets_missing: extras.assets_missing } : {},
+		htmlBytes: extras.strip?.total ?? pa?.html.bytes ?? null,
+		...(() => {
+			const img = (visit?.images_oversized ?? []).reduce((s, i) => s + i.bytes * Math.max(0, 1 - i.shown[0] * i.shown[1] * i.dpr * i.dpr / (i.natural[0] * i.natural[1])), 0);
+			const pre = (visit?.preloads_unused ?? []).reduce((s, p) => s + p.bytes, 0);
+			return img + pre >= 10240 ? { wasted: {
+				bytes: Math.round(img + pre),
+				images: Math.round(img),
+				preloads: pre
+			} } : {};
+		})(),
+		hasIslands: islands.length > 0,
+		browserSeen: client.length > 0 || !!visit,
+		recovered: client.reduce((s, c) => s + c.recovered, 0),
+		neverWoke: client.length ? islands.filter((r) => (r.wake === "load" || r.wake === "idle" || r.wake === "visible") && !seen_entry.has(r.entry)).length : 0,
+		changed: visit?.islands?.filter((i) => i.changed && !i.recovered).length ?? 0,
+		dataBytes: data_bytes,
+		dataDetail: data_parts.filter(([, b]) => b > 0).map(([k, b]) => `${k} ${fmt_bytes(b)}`),
+		serverMs: server_ms,
+		vitals: v ? {
+			lcp: v.lcp,
+			cls: v.cls,
+			inp: v.inp,
+			fcp: v.fcp,
+			ttfb: v.ttfb
+		} : visit ? {
+			lcp: visit.paints?.lcp ?? null,
+			fcp: visit.paints?.fcp ?? null,
+			ttfb: visit.nav?.start_hidden ? null : visit.nav?.res_start ?? null,
+			cls: no_shifts ? null : visit.shifts?.length ? Math.round(visit.shifts.reduce((s, x) => s + x.value, 0) * 1e3) / 1e3 : 0,
+			inp: null
+		} : null,
+		tbt,
+		unmeasured
+	};
+	return page_score(inputs);
+}
+function report_json(a, meta, base, extras) {
+	const dur = a.duration_ms || 1;
+	const busy = a.busy_ms || 1;
+	const net = extras.net.filter((c) => c.ms >= 0);
+	const net_total = round1(net.reduce((s, c) => s + c.ms + (c.body_ms ?? 0), 0));
+	const budget = a.buckets.filter((b) => b.self_ms > 0 && b.category !== "idle").map((b) => ({
+		label: b.key,
+		category: b.category,
+		ms: b.self_ms,
+		pct: round1(b.self_ms / dur * 100)
+	}));
+	if (a.idle_ms > 0) budget.push({
+		label: "idle / waiting",
+		category: "idle",
+		ms: a.idle_ms,
+		pct: round1(a.idle_ms / dur * 100)
+	});
+	budget.sort((x, y) => y.ms - x.ms);
+	const alloc_by_name = /* @__PURE__ */ new Map();
+	for (const h of extras.heap ?? []) alloc_by_name.set(h.name, (alloc_by_name.get(h.name) ?? 0) + h.self_bytes);
+	for (const c of extras.heap_components ?? []) alloc_by_name.set(c.name, c.bytes);
+	const verdict = a.idle_ms > dur * .5 ? "waiting" : a.busy_ms / dur * 100 > 60 ? "compute-bound" : "mixed";
+	const hosts = top_hosts(net);
+	return {
+		schema: "ogygia-profiler-report",
+		version: 1,
+		engine: { version: TESTING_ENGINE_VERSION },
+		units: {
+			time: "ms",
+			size: "bytes",
+			memory_suffix_mb: true
+		},
+		id: meta.id,
+		created: meta.created,
+		kind: meta.trigger,
+		node: meta.node,
+		dev: !!meta.dev,
+		sourcemapped: a.sourcemapped,
+		...a.other_requests_ms ? { other_requests_ms: a.other_requests_ms } : {},
+		target: {
+			page: meta.page ?? null,
+			redirected_from: meta.redirected_from ?? null,
+			...meta.redirect_stub ? { redirect_stub: true } : {},
+			runs: meta.runs ?? null,
+			warmup_ms: meta.warmup_ms ?? null,
+			run_status: meta.run_status ?? null,
+			run_bytes: meta.run_bytes ?? null,
+			cache_control: meta.run_cache_control ?? null,
+			prerendered: meta.prerendered ? meta.run_static ? "file" : "route" : null,
+			budget_note: meta.budget_note ?? null,
+			runs_measured: meta.runs_measured ?? null,
+			instance: meta.instance ?? null,
+			lambda: meta.lambda ?? false,
+			request: meta.request ?? null
+		},
+		summary: {
+			window_ms: meta.duration_ms,
+			busy_ms: a.busy_ms,
+			overhead: meta.overhead ? {
+				...meta.overhead,
+				top: a.overhead_functions ?? []
+			} : null,
+			busy_pct: round1(a.busy_ms / dur * 100),
+			idle_ms: a.idle_ms,
+			gc_ms: extras.gc_attr ? extras.gc_attr.summary.total_ms : a.gc_ms,
+			gc_sampled_ms: a.gc_ms,
+			verdict,
+			sample_count: a.sample_count,
+			cpu_percent: meta.cpu_percent ?? null,
+			elu_percent: meta.elu_percent ?? null,
+			loop_delay_ms: meta.loop_delay ?? null,
+			rss_mb: meta.rss_mb ?? null
+		},
+		score: page_score_of(meta, extras),
+		findings: derive_findings(a, meta, extras),
+		budget,
+		timeline: a.timeline ? {
+			window_ms: a.timeline.window_ms,
+			cpu_ms: a.timeline.cpu_ms,
+			wait_ms: a.timeline.wait_ms,
+			unaccounted_ms: a.timeline.gap_ms,
+			phases: a.timeline.phases.map((p) => ({
+				phase: p.phase,
+				label: PHASE_LABEL[p.phase],
+				cpu_ms: p.cpu_ms,
+				wait_ms: p.wait_ms
+			})),
+			steps: chain_steps(a.timeline).map((s) => ({
+				at_ms: s.seg.t0,
+				ms: s.ms,
+				pct: round1(s.pct),
+				kind: s.seg.kind,
+				phase: s.seg.phase,
+				what: s.seg.label,
+				detail: s.seg.detail ?? null,
+				file: s.seg.file || null,
+				calls: s.seg.calls ?? null,
+				within: s.seg.within ?? null
+			})),
+			parallelizable: a.timeline.parallelizable.map((g) => ({
+				calls: g.calls,
+				ms: g.ms,
+				save_ms: g.save_ms
+			})),
+			lanes: (a.timeline.lanes ?? []).map((l) => ({
+				file: l.file,
+				level: l.level,
+				kind: l.kind,
+				t0_ms: l.t0,
+				t1_ms: l.t1,
+				cpu_ms: l.cpu_ms,
+				wait_ms: l.wait_ms,
+				awaited_parent: l.awaited_parent
+			})),
+			chain: a.timeline.chain ?? null,
+			awaits: a.timeline.awaits?.edges ?? []
+		} : null,
+		spans: span_rows(extras.spans),
+		paths: (a.paths ?? []).map((g) => ({
+			owner: {
+				name: g.owner.name,
+				file: g.owner.url,
+				line: g.owner.line,
+				category: g.owner.category,
+				total_ms: g.owner.total_ms,
+				calls: g.owner.calls ?? null
+			},
+			ms: g.ms,
+			pct_busy: round1(g.ms / busy * 100),
+			share_of_owner: g.share,
+			functions: g.fns.map((f) => ({
+				name: f.name,
+				file: f.url,
+				line: f.line,
+				category: f.category,
+				package: f.pkg ?? null,
+				ms: f.ms
+			})),
+			tree: g.tree
+		})),
+		ogygia: (() => {
+			const og = [...meta.requests].filter((r) => r.og).sort((x, y) => y.og.seed_bytes + y.og.tail_bytes - (x.og.seed_bytes + x.og.tail_bytes))[0]?.og ?? null;
+			if (!og) return null;
+			const { island_rows, seed, hole_rows, ...totals } = og;
+			const client = new Map((extras.client ?? []).map((c) => [c.entry, c]));
+			const by_name = new Map(a.components.map((c) => [c.name, c]));
+			let js_only = null;
+			return {
+				...totals,
+				island_rows: group_islands(island_rows ?? []).map((r, _i, grouped) => {
+					js_only ??= island_js_unique(grouped, extras.weights);
+					const comp = by_name.get(island_name(r));
+					const cl = client.get(r.entry);
+					return {
+						name: island_name(r),
+						entry: r.entry,
+						fp: r.fp,
+						fingerprints: r.variants ?? 1,
+						copies: r.count,
+						wake: r.wake,
+						ssr_ms: comp ? round1(comp.total_ms / runs_of(meta)) : null,
+						props_bytes: r.props_bytes,
+						canonical_bytes: r.canonical_bytes,
+						json: r.json,
+						devalue_culprit: r.culprit,
+						seed_refs: r.refs,
+						seed_ref_keys: r.ref_keys,
+						js_bytes: island_js_bytes(r, extras.weights),
+						js_only_bytes: js_only?.get(r.entry) ?? null,
+						modules: [r.module_url, ...r.hints].filter(Boolean),
+						interactivity: r.interactivity,
+						...extras.hazards?.[r.entry]?.length ? { hazards: extras.hazards[r.entry].slice(0, 3) } : {},
+						client: cl ? {
+							hydrations: cl.n,
+							p50_ms: cl.p50_ms,
+							max_ms: cl.max_ms,
+							load_p50_ms: cl.load_p50_ms,
+							recovered: cl.recovered,
+							...cl.reason ? { reason: cl.reason } : {}
+						} : null
+					};
+				}),
+				seed: seed ?? null,
+				hole_rows: (hole_rows ?? []).map((h) => {
+					const e = hole_economics(meta).get(h.id);
+					return {
+						id: h.id,
+						component: h.name || null,
+						props: h.props || null,
+						when: h.when,
+						hydrate: h.hydrate,
+						max_age_s: h.ttl,
+						copies: h.count,
+						requests: e ? {
+							hit: e.hit,
+							miss: e.miss,
+							uncached: e.none,
+							avg_ms: round1(e.ms / Math.max(e.hit + e.miss + e.none, 1))
+						} : null
+					};
+				})
+			};
+		})(),
+		kit: {
+			uneval_ms: round1(a.functions.filter((f) => f.pkg === "devalue" && f.name === "uneval").reduce((s, f) => s + f.self_ms, 0)),
+			etag_ms: round1(a.functions.filter((f) => f.name === "hash" && f.pkg === "@sveltejs/kit").reduce((s, f) => s + f.self_ms, 0))
+		},
+		components: (() => {
+			return [...a.components].sort((x, y) => y.self_ms - x.self_ms).map((c) => {
+				const n = (c.calls ?? 0) || null;
+				return {
+					name: c.name,
+					instances: n,
+					file: c.url,
+					path: c.path ?? null,
+					line: c.line,
+					column: c.col || null,
+					self_ms: c.self_ms,
+					total_ms: c.total_ms,
+					per_call_ms: per_call(c.total_ms / runs_of(meta), n),
+					pct_busy: round1(c.total_ms / busy * 100),
+					alloc_bytes: alloc_by_name.get(c.name) ?? null,
+					markup_ms: c.markup_ms ?? null,
+					logic_ms: c.logic_ms ?? null,
+					parent: c.parent ?? null,
+					runs_ms: c.runs_ms ?? null,
+					hot_lines: c.lines ?? null,
+					source: c.src ?? null,
+					callees: c.callees ?? null,
+					stacks: (c.stacks ?? []).map((s) => ({
+						ms: s.ms,
+						frames: s.frames.map(frame_text)
+					}))
+				};
+			});
+		})(),
+		hot_functions: (() => {
+			return a.functions.slice(0, 80).map((f) => {
+				const n = (f.calls ?? 0) || null;
+				return {
+					name: f.name,
+					label: f.label ?? null,
+					instances: n,
+					file: f.url,
+					path: f.path ?? null,
+					line: f.line,
+					column: f.col || null,
+					category: f.category,
+					package: f.pkg ?? null,
+					self_ms: f.self_ms,
+					total_ms: f.total_ms,
+					per_call_ms: per_call(f.total_ms / runs_of(meta), n),
+					stacks: (f.stacks ?? []).map((s) => ({
+						ms: s.ms,
+						frames: s.frames.map(frame_text)
+					})),
+					hot_lines: f.lines ?? null,
+					source: f.src ?? null,
+					callees: f.callees ?? null
+				};
+			});
+		})(),
+		files: a.files.filter((f) => f.category !== "idle").slice(0, 40).map((f) => ({
+			file: f.key,
+			category: f.category,
+			self_ms: f.self_ms,
+			pct_busy: round1(f.self_ms / busy * 100)
+		})),
+		network: {
+			count: net.length,
+			total_ms: net_total,
+			sequential_ms: sequential_ms(extras.net),
+			errors: extras.net.filter((c) => c.error).length,
+			hosts: hosts.map((h) => ({
+				host: h.host,
+				calls: h.count,
+				total_ms: h.total,
+				p50_ms: h.p50,
+				max_ms: h.max,
+				errors: h.errors
+			})),
+			calls: [...net].sort((x, y) => y.ms + (y.body_ms ?? 0) - (x.ms + (x.body_ms ?? 0))).slice(0, 200).map((c) => ({
+				method: c.method,
+				url: c.url,
+				host: c.host,
+				status: c.status,
+				wait_ms: c.ms,
+				body_ms: c.body_ms ?? null,
+				bytes: c.bytes ?? null,
+				transfer_bytes: c.transfer_bytes ?? null,
+				encoding: c.encoding ?? null,
+				type: c.type ?? null,
+				req_bytes: c.req_bytes ?? null,
+				req_payload: c.req_payload ?? null,
+				route: c.route ?? c.path ?? null,
+				caller: c.caller ?? null,
+				callers: c.callers ?? null,
+				server_timing: c.timings ?? null,
+				trace: c.trace ?? null,
+				headers: c.headers ?? null,
+				error: c.error ?? null
+			}))
+		},
+		cold: meta.cold ? {
+			ms: meta.cold.ms,
+			busy_ms: meta.cold.busy_ms,
+			files: cold_rows(a, meta),
+			...meta.cold.calls !== void 0 ? { calls: meta.cold.calls } : {}
+		} : null,
+		browser: extras.vitals || extras.client_marks || extras.client_cpu || extras.visit ? {
+			...extras.vitals,
+			...extras.client_marks ? { marks: extras.client_marks } : {},
+			...extras.visit ? { visit: {
+				at: extras.visit.at,
+				nav: extras.visit.nav,
+				paints: extras.visit.paints,
+				resources: extras.visit.resources_all ?? extras.visit.resources.length,
+				resource_bytes: extras.visit.resource_totals ? extras.visit.resource_totals.reduce((s, t) => s + t.transfer, 0) : extras.visit.resources.reduce((s, r) => s + (r.transfer ?? 0), 0),
+				...extras.visit.resource_totals ? { resource_totals: extras.visit.resource_totals } : {},
+				longtasks: extras.visit.longtasks.length,
+				islands: extras.visit.islands.map((i) => ({
+					fp: i.fp,
+					t0: i.t0,
+					loaded: i.loaded,
+					done: i.done,
+					...i.changed ? { changed: true } : {}
+				})),
+				firsts: extras.visit.firsts,
+				shifts: extras.visit.shifts.length,
+				cls_by_island: Object.fromEntries(extras.visit.shifts.reduce((m, s) => m.set(s.fp ?? "(outside islands)", (m.get(s.fp ?? "(outside islands)") ?? 0) + s.value), /* @__PURE__ */ new Map()))
+			} } : {},
+			...extras.interaction_cpu ? { interaction_cpu: extras.interaction_cpu } : {},
+			...extras.client_cpu ? { cpu: {
+				at: extras.client_cpu.at,
+				sampled_ms: extras.client_cpu.analysis.duration_ms,
+				busy_ms: extras.client_cpu.analysis.busy_ms,
+				...extras.client_cpu.windows ? {
+					by_island: Object.entries(extras.client_cpu.windows.islands).map(([fp, w]) => ({
+						fp,
+						name: island_rows_of(meta).find((r) => r.fp === fp)?.name ?? null,
+						ms: w.ms,
+						top: w.top
+					})),
+					outside_islands: extras.client_cpu.windows.outside
+				} : {},
+				components: extras.client_cpu.analysis.components.slice(0, 30).map((c) => ({
+					name: c.name,
+					file: c.url,
+					self_ms: c.self_ms,
+					total_ms: c.total_ms,
+					instances: c.calls ?? null
+				})),
+				hot_functions: extras.client_cpu.analysis.functions.slice(0, 30).map((f) => ({
+					name: f.name,
+					file: f.url,
+					line: f.line,
+					category: f.category,
+					package: f.pkg ?? null,
+					self_ms: f.self_ms,
+					total_ms: f.total_ms
+				}))
+			} } : {}
+		} : null,
+		replay: meta.request ? {
+			url: `${base}/replay/${meta.id}`,
+			path: extras.replay?.path ?? meta.request.path,
+			headers: Object.keys(extras.replay?.headers ?? {})
+		} : null,
+		assets: extras.assets ? {
+			totals: extras.assets.totals,
+			html: extras.assets.html,
+			inline: extras.assets.inline,
+			files: extras.assets.assets.slice(0, 40).map((x) => ({
+				url: x.url,
+				kind: x.kind,
+				via: x.via,
+				bytes: x.bytes,
+				wire: x.wire,
+				...x.blocking ? { blocking: true } : {},
+				...x.lazy ? { lazy: true } : {},
+				...x.contains ? { contains: x.contains } : {}
+			})),
+			...extras.assets.missed.length ? { missed: extras.assets.missed.slice(0, 20) } : {},
+			...extras.assets.missed_why?.length ? { missed_why: extras.assets.missed_why } : {},
+			...(() => {
+				const twice = page_duplicates(extras).slice(0, 12);
+				return twice.length ? { twice } : {};
+			})()
+		} : extras.assets_missing ? { missing: extras.assets_missing } : null,
+		strip: extras.strip ? {
+			total: extras.strip.total,
+			by_kind: extras.strip.by_kind,
+			shadow_count: extras.strip.shadow_count,
+			segments: extras.strip.segments,
+			...extras.strip.chunks ? { chunks: extras.strip.chunks } : {},
+			...extras.strip.tail ? { tail: extras.strip.tail } : {}
+		} : null,
+		river: extras.river ?? null,
+		memory: {
+			rss_start_mb: extras.mem[0]?.rss ?? null,
+			rss_end_mb: extras.mem.at(-1)?.rss ?? null,
+			growth_mb: extras.mem.length >= 2 ? extras.mem.at(-1).rss - extras.mem[0].rss : 0,
+			gc: extras.gc ?? null,
+			gc_attribution: extras.gc_attr ? {
+				...extras.gc_attr.summary,
+				pauses: extras.gc_attr.pauses.map((p) => ({
+					t_ms: p.t,
+					ms: p.ms,
+					ms_measured: p.ms_measured,
+					kind: p.kind,
+					forced: p.forced,
+					since_ms: p.since_ms,
+					allocated_bytes: p.allocated,
+					estimated: p.estimated ?? false,
+					why: p.why,
+					running: p.running ?? null,
+					top: p.top.map((x) => ({
+						name: x.name,
+						component: x.component,
+						bytes: x.bytes,
+						share: x.share
+					}))
+				})),
+				makers: extras.gc_attr.makers.slice(0, 40).map((m) => ({
+					name: m.name,
+					file: m.url,
+					line: m.line,
+					category: m.category,
+					component: m.component,
+					via: m.caller ?? null,
+					allocated_bytes: m.allocated,
+					share: m.share,
+					gc_ms: m.gc_ms,
+					pauses: m.pauses
+				})),
+				components: extras.gc_attr.components.slice(0, 40)
+			} : null,
+			allocators: (extras.heap ?? []).map((h) => ({
+				name: h.name,
+				file: h.url,
+				line: h.line,
+				category: h.category,
+				self_bytes: h.self_bytes,
+				total_bytes: h.total_bytes
+			})),
+			by_component: (extras.heap_components ?? []).map((c) => ({
+				name: c.name,
+				bytes: c.bytes
+			})),
+			samples: extras.mem.map((m) => ({
+				t_ms: m.t,
+				rss_mb: m.rss,
+				heap_used_mb: m.heap_used
+			}))
+		},
+		deopts: a.deopts.map((d) => ({
+			name: d.name,
+			file: d.url,
+			line: d.line,
+			category: d.category,
+			self_ms: d.self_ms,
+			count: d.count,
+			reasons: d.reasons
+		})),
+		sync_io: sync_io(a).map((s) => ({
+			name: s.name,
+			module: s.module,
+			self_ms: s.self_ms,
+			total_ms: s.total_ms,
+			calls: s.calls,
+			callers: s.callers
+		})),
+		memo_candidates: memo_candidates(a, extras.gc_attr?.makers ?? [], 8, runs_of(meta)),
+		promises: extras.promises ? {
+			count: extras.promises.count,
+			per_render: meta.runs?.length ? Math.round(extras.promises.count / meta.runs.length) : extras.promises.count,
+			top: extras.promises.top
+		} : null,
+		retained: extras.retained ? {
+			total_bytes: extras.retained.total_bytes,
+			render_ms: extras.retained.render_ms,
+			sites: extras.retained.sites.map((s) => ({
+				name: s.name,
+				file: s.url,
+				line: s.line,
+				via: s.caller ?? null,
+				component: s.component,
+				bytes: s.bytes,
+				share: s.share
+			}))
+		} : null,
+		steps: a.timeline ? render_steps(a.timeline, a.stacks) ?? null : null,
+		stacks: a.stacks ? {
+			window_ms: a.stacks.window_ms,
+			raw_samples: a.stacks.raw,
+			frames: a.stacks.frames.map((f) => ({
+				name: f.n,
+				file: f.f ?? null,
+				category: f.c,
+				parent: f.p
+			})),
+			t_ms: a.stacks.t,
+			d_ms: a.stacks.d,
+			leaf: a.stacks.leaf
+		} : null,
+		alloc: extras.alloc ? {
+			grown_mb: extras.alloc.grown_mb,
+			period_ms: extras.alloc.period_ms,
+			longest_gap_ms: extras.alloc.longest_gap_ms,
+			window: extras.alloc.window ?? null,
+			bursts: extras.alloc.bursts.map((b) => ({
+				t0_ms: b.t0,
+				t1_ms: b.t1,
+				mb: b.mb,
+				mb_per_s: b.rate,
+				gc_inside: b.gc,
+				running: b.running
+			})),
+			samples: extras.alloc.samples.map((s) => ({
+				t_ms: s.t,
+				heap_mb: s.mb
+			}))
+		} : null,
+		contention: extras.contention ? {
+			overlap_ms: extras.contention.overlap_ms,
+			cpu_max_ms: extras.contention.cpu_max_ms,
+			busy_share: extras.contention.busy_share,
+			inflight_at_start: extras.contention.inflight_at_start,
+			per_window: extras.contention.per_window,
+			requests: extras.contention.requests,
+			note: "cpu_max_ms is an upper bound: a request’s CPU is a process-wide delta over its lifetime, so overlapping requests carry some of each other’s"
+		} : null,
+		lineage: extras.lineage ? {
+			keys: extras.lineage.keys.map((k) => ({
+				key: k.key,
+				from: k.from,
+				shipped_bytes: k.shipped_bytes,
+				load_wait_ms: k.load_wait_ms,
+				verdict: k.verdict,
+				readers: k.readers
+			})),
+			components: extras.lineage.components,
+			unread: extras.lineage.unread.map((k) => k.key),
+			server_only: extras.lineage.server_only.map((k) => k.key),
+			notes: extras.lineage.notes
+		} : null,
+		ledger: extras.ledger ?? null,
+		patterns: extras.patterns ? extras.patterns.map((p) => {
+			const r = p.wait ? 1 : runs_of(meta);
+			const r2 = (x) => Math.round(x * 100) / 100;
+			return {
+				...p,
+				save_per_render_ms: r2(p.save_ms / r),
+				cost_per_render_ms: r2(p.cost_ms / r)
+			};
+		}) : null,
+		growth: extras.growth ?? null,
+		drill: extras.drill ?? null,
+		forecast: extras.forecast ?? null,
+		span_values: span_values(extras.spans),
+		waiting: (() => {
+			const m = /* @__PURE__ */ new Map();
+			const add = (caller, kind, ms) => {
+				const k = caller + "|" + kind;
+				const r = m.get(k) ?? {
+					caller,
+					kind,
+					count: 0,
+					wait_ms: 0
+				};
+				r.count++;
+				r.wait_ms = round1(r.wait_ms + ms);
+				m.set(k, r);
+			};
+			for (const c of net) if (c.caller) add(c.caller, "http", c.ms + (c.body_ms ?? 0));
+			for (const o of extras.io ?? []) if (o.caller && !o.open) add(o.caller, io_kind(o.type), o.ms);
+			return [...m.values()].sort((x, y) => y.wait_ms - x.wait_ms).slice(0, 40);
+		})(),
+		user_timings: (extras.measures ?? []).map((m) => ({
+			name: m.name,
+			count: m.count,
+			total_ms: m.total_ms,
+			avg_ms: round1(m.total_ms / m.count),
+			max_ms: m.max_ms
+		})),
+		requests: meta.requests.map((r) => ({
+			method: r.method,
+			path: r.path,
+			route: r.route,
+			status: r.status,
+			ms: r.ms,
+			cpu_ms: r.cpu_ms,
+			wait_ms: round1(Math.max(0, r.ms - r.cpu_ms)),
+			net_ms: r.net_ms,
+			net_count: r.net_count,
+			inflight: r.inflight,
+			internal: !!r.internal,
+			tags: r.tags ?? null,
+			span_count: r.span_count ?? null,
+			span_ms: r.span_ms ?? null,
+			hole: r.hole ?? null
+		})),
+		links: {
+			html: `${base}/report/${meta.id}`,
+			json: `${base}/report/${meta.id}.json`,
+			cpuprofile: `${base}/report/${meta.id}/raw`
+		}
+	};
+}
+function report_dump(a, meta, extras) {
+	return {
+		kind: "ogygia-profiler-dump",
+		version: 1,
+		meta,
+		analysis: a,
+		extras
+	};
+}
+/** Narrowing guard for an uploaded dump before we render it. */
+function is_dump(x) {
+	const d = x;
+	return !!d && typeof d === "object" && d.kind === "ogygia-profiler-dump" && !!d.meta && !!d.analysis && !!d.extras;
+}
+function top_hosts(net) {
+	const by_host = /* @__PURE__ */ new Map();
+	const errors = /* @__PURE__ */ new Map();
+	for (const c of net) {
+		const t = c.ms + (c.body_ms ?? 0);
+		let list = by_host.get(c.host);
+		if (!list) by_host.set(c.host, list = []);
+		list.push(t);
+		if (c.error) errors.set(c.host, (errors.get(c.host) ?? 0) + 1);
+	}
+	return [...by_host.entries()].map(([host, list]) => {
+		const sorted = [...list].sort((a, b) => a - b);
+		return {
+			host,
+			count: list.length,
+			total: Math.round(list.reduce((a, c) => a + c, 0) * 100) / 100,
+			p50: sorted[Math.floor(sorted.length / 2)] ?? 0,
+			max: sorted.at(-1) ?? 0,
+			errors: errors.get(host) ?? 0
+		};
+	}).sort((a, b) => b.total - a.total);
+}
+/** timeline of network calls, offset from window start */
+export { browser_of, cold_rows, derive_findings, dev_tool_caller, fair_shares, group_islands, hazard_fix, hazard_words, hole_economics, hole_label, hot_line_of, inline_threshold_tune, is_dump, island_host_renamer, island_js_bytes, island_js_unique, island_name, island_rows_of, kit_load_serialize_ms, lake_saving, link_patterns, mostly_waited, n_plus_one, own_requests, page_duplicates, page_origin, page_score_of, path_template, remote_function_name, report_dump, report_json, run_spread, run_trend, span_rows, start_js, with_hidden_filled };