@ogygia/devtools 0.0.0-stage → 0.11.0

package/dist/profiler/compare.js

@@ -0,0 +1,733 @@
+import { own_requests } from "./own-requests.js";
+import { at_line } from "./drill.js";
+import { saving_of } from "./saving.js";
+import { PHASE_LABEL } from "./timeline.js";
+import { vitals_moved } from "@ogygia/core/insights";
+// src/profiler/compare.ts
+/** The render's own noise decides: both reports' runs, the median moved no more than their spread
+*  (or 3 %). Then the CPU rows' moves are attribution, not change. */
+function render_same_of(a, b) {
+	const ra = a.runs ?? [];
+	const rb = b.runs ?? [];
+	if (ra.length < 2 || rb.length < 2) return {};
+	const spread = (r) => Math.max(...r) - Math.min(...r);
+	const ma = median(ra);
+	const mb = median(rb);
+	const noise = Math.max(spread(ra), spread(rb), .03 * Math.max(ma, mb));
+	return Math.abs(mb - ma) <= noise ? { render_same: {
+		a_ms: round2(ma),
+		b_ms: round2(mb),
+		noise_ms: round2(noise)
+	} } : {};
+}
+/** With the render unchanged, a CPU row's fixed / new / better / worse is where V8 charged the time. */
+function mark_shifted(cmp) {
+	if (!cmp.render_same) return cmp;
+	for (const p of cmp.patterns) if (p.status !== "same" && !p.wait && p.kind !== "kept-per-render" && p.kind !== "seed-whole-read") p.status = "shifted";
+	for (const l of cmp.lines) if (l.status !== "same" && Math.abs(l.b_kept - l.a_kept) < 131072) l.status = "shifted";
+	for (const r of cmp.drill ?? []) if ((r.kind === "cpu" || r.kind === "line") && !r.waiting) r.status = "shifted";
+	if (cmp.drill) cmp.drill.sort((x, y) => Number(x.status === "shifted") - Number(y.status === "shifted") || Math.abs(y.d_ms) - Math.abs(x.d_ms));
+	return cmp;
+}
+const renders_of = (m) => m.trigger === "page" ? Math.max(1, m.runs?.length ?? 1) : 1;
+/** The two ledgers side by side. Keyed by file + the code on the line: code that changed reads as
+*  one line gone and another new (the fix), code that did not keeps its row though its number moved. */
+function line_deltas(a = [], b = [], ra = 1, rb = 1) {
+	const key = (l) => l.file + "\0" + (l.code ?? `#${l.line}`);
+	const cost = (l, r) => ({
+		ms: round2((l.cpu_ms + l.lib_ms) / r),
+		bytes: Math.round(l.alloc_bytes / r),
+		kept: l.retained_bytes
+	});
+	const out = /* @__PURE__ */ new Map();
+	for (const l of a) {
+		const c = cost(l, ra);
+		out.set(key(l), {
+			file: l.file,
+			line: l.line,
+			code: l.code ?? "",
+			a_ms: c.ms,
+			b_ms: 0,
+			d_ms: -c.ms,
+			a_bytes: c.bytes,
+			b_bytes: 0,
+			a_kept: c.kept,
+			b_kept: 0,
+			status: "fixed"
+		});
+	}
+	for (const l of b) {
+		const c = cost(l, rb);
+		const r = out.get(key(l));
+		if (!r) {
+			out.set(key(l), {
+				file: l.file,
+				line: l.line,
+				code: l.code ?? "",
+				a_ms: 0,
+				b_ms: c.ms,
+				d_ms: c.ms,
+				a_bytes: 0,
+				b_bytes: c.bytes,
+				a_kept: 0,
+				b_kept: c.kept,
+				status: "new"
+			});
+			continue;
+		}
+		Object.assign(r, {
+			line: l.line,
+			b_ms: c.ms,
+			d_ms: round2(c.ms - r.a_ms),
+			b_bytes: c.bytes,
+			b_kept: c.kept
+		});
+		const t = Math.abs(r.d_ms) >= Math.max(.2 * r.a_ms, 1);
+		const m = Math.abs(c.bytes - r.a_bytes) >= .5 * Math.max(r.a_bytes, 1) && Math.abs(c.bytes - r.a_bytes) >= 262144;
+		const k = Math.abs(c.kept - r.a_kept) >= .5 * Math.max(r.a_kept, 1) && Math.abs(c.kept - r.a_kept) >= 131072;
+		const worse = r.d_ms > 0 || c.bytes > r.a_bytes || c.kept > r.a_kept;
+		r.status = !(t || m || k) ? "same" : worse && !(r.d_ms < 0 && t) ? "worse" : "better";
+	}
+	const rank = {
+		fixed: 0,
+		new: 1,
+		worse: 2,
+		better: 3,
+		shifted: 4,
+		same: 5
+	};
+	const costly = (ms, bytes, kept) => ms >= 1 || bytes >= 1048576 || kept >= 262144;
+	return [...out.values()].filter((r) => (r.status !== "fixed" || costly(r.a_ms, r.a_bytes, r.a_kept)) && (r.status !== "new" || costly(r.b_ms, r.b_bytes, r.b_kept))).sort((x, y) => rank[x.status] - rank[y.status] || Math.abs(y.d_ms) - Math.abs(x.d_ms)).slice(0, 40);
+}
+function island_files_diff(a, b, weight) {
+	const before = new Map(a.map((r) => [r.entry, r.module_url]));
+	const moved = [];
+	let kept = 0;
+	const seen = /* @__PURE__ */ new Set();
+	for (const r of b) {
+		if (seen.has(r.entry)) continue;
+		seen.add(r.entry);
+		const was = before.get(r.entry);
+		if (was === void 0 || was === r.entry || r.module_url === r.entry) continue;
+		if (was === r.module_url) kept++;
+		else moved.push({
+			name: r.name,
+			bytes: weight?.(r.module_url) ?? null
+		});
+	}
+	if (!moved.length && !kept) return null;
+	return {
+		moved,
+		kept,
+		bytes: moved.reduce((s, m) => s + (m.bytes ?? 0), 0),
+		all_moved: moved.length >= 3 && kept === 0
+	};
+}
+/** memory kept per render that slows the renders after it on the same server */
+const ORDER_KEPT_BYTES = 8388608;
+/** One server for both (its start, from each report's time and the server's age then, within the
+*  length of a profile; and it had served more requests by the later one), and the earlier report
+*  saw each render keep 8 MB+ alive: the later one inherited the fuller heap. */
+function order_of(a, b) {
+	const ia = a.meta.instance;
+	const ib = b.meta.instance;
+	if (!ia || !ib) return void 0;
+	const start = (m, age_s) => m.created - age_s * 1e3;
+	if (Math.abs(start(a.meta, ia.age_s) - start(b.meta, ib.age_s)) > 3e4) return void 0;
+	const [first, second, earlier] = a.meta.created <= b.meta.created ? [
+		a,
+		b,
+		"a"
+	] : [
+		b,
+		a,
+		"b"
+	];
+	const between = (second.meta.instance.requests_before ?? 0) - (first.meta.instance.requests_before ?? 0);
+	if (between <= 0) return void 0;
+	const kept = first.patterns?.find((p) => p.kind === "kept-per-render")?.kept_bytes ?? 0;
+	if (kept < ORDER_KEPT_BYTES) return void 0;
+	return {
+		earlier,
+		kept_mb: Math.round(kept / 1048576 * 10) / 10,
+		requests_between: between
+	};
+}
+/** a move worth naming: 2 ms and a fifth of the row (one render per side, so small moves are noise) */
+const drill_moved = (a, b) => Math.abs(b - a) >= Math.max(2, .2 * Math.max(a, b));
+/**
+* THE DRILL-DOWNS SIDE BY SIDE: every row of one render's tree matched by its place (phase › load
+* file › who › line), and the rows that moved — only the DEEPEST of a chain: a row whose moved
+* children carry most (70 %) of its move is left out, so the list names the cause (the call, the
+* line), not every level above it. Both trees are one render, so no per-render division.
+*/
+function drill_deltas(a, b) {
+	if (!a || !b) return [];
+	const rows = /* @__PURE__ */ new Map();
+	const walk = (n, path, side, parent) => {
+		const k = path.join("\0");
+		const r = rows.get(k) ?? rows.set(k, {
+			path,
+			kind: n.kind,
+			...n.at ? { at: n.at } : {},
+			a: 0,
+			b: 0,
+			kids: [],
+			...parent ? { parent } : {},
+			folded: {
+				a: 0,
+				b: 0
+			}
+		}).get(k);
+		r[side] += n.ms;
+		if (n.runs) r[side === "a" ? "runs_a" : "runs_b"] = n.runs;
+		if (n.code) r[side === "a" ? "code_a" : "code_b"] = n.code;
+		if (n.kind === "wait" || n.kind === "gap" || (parent ? rows.get(parent)?.waiting : false)) r.waiting = true;
+		if (n.at) r.at = n.at;
+		for (const c of n.children ?? []) {
+			if (c.kind === "more") {
+				if (!c.children?.length) r.folded[side] = c.ms;
+				for (const f of c.children ?? []) {
+					const fk = walk(f, [...path, f.label], side, k);
+					if (!r.kids.includes(fk)) r.kids.push(fk);
+				}
+				continue;
+			}
+			const ck = walk(c, [...path, c.label], side, k);
+			if (!r.kids.includes(ck)) r.kids.push(ck);
+		}
+		return k;
+	};
+	const top = {
+		path: [],
+		kind: "render",
+		a: 0,
+		b: 0,
+		kids: [],
+		folded: {
+			a: 0,
+			b: 0
+		}
+	};
+	rows.set("", top);
+	for (const [side, root] of [["a", a], ["b", b]]) for (const c of root.children ?? []) if (c.kind !== "more") walk(c, [c.label], side, "");
+	else if (!c.children?.length) top.folded[side] = c.ms;
+	else for (const f of c.children) walk(f, [f.label], side, "");
+	rows.delete("");
+	const into = /* @__PURE__ */ new Map();
+	const lines = [...rows.entries()].filter(([, r]) => r.kind === "line").sort(([, x], [, y]) => x.path.length - y.path.length);
+	const same_parent = (x, y) => (into.get(x.parent ?? "") ?? x.parent) === y.parent;
+	const paired = /* @__PURE__ */ new Set();
+	for (const [fk, f] of lines) {
+		if (f.a < .05 || f.b >= .05) continue;
+		const fl = f.at ? at_line(f.at) : void 0;
+		if (!fl) continue;
+		let best;
+		let best_d = Infinity;
+		for (const [nk, n] of lines) {
+			if (n.a >= .05 || n.b < .05 || paired.has(nk) || !same_parent(f, n)) continue;
+			const nl = n.at ? at_line(n.at) : void 0;
+			if (!nl || nl.file !== fl.file) continue;
+			const dist = Math.abs(nl.line - fl.line);
+			if (dist > 40 || dist >= best_d) continue;
+			if (f.code_a && n.code_b ? f.code_a !== n.code_b : Math.abs(n.b - f.a) > Math.max(2, .2 * f.a)) continue;
+			best = nk;
+			best_d = dist;
+		}
+		if (!best) continue;
+		const n = rows.get(best);
+		paired.add(best);
+		into.set(fk, best);
+		n.a = f.a;
+		if (f.runs_a) n.runs_a = f.runs_a;
+	}
+	for (const [k, r] of rows) {
+		if (into.has(k)) continue;
+		for (const side of ["a", "b"]) {
+			if (r[side] >= .05) continue;
+			const fold = (r.parent === void 0 ? top : rows.get(r.parent))?.folded[side] ?? 0;
+			if (fold <= 0) continue;
+			r[side] = Math.min(fold, side === "a" ? r.b : r.a);
+			r.upto = side;
+		}
+	}
+	const moved = (r) => {
+		if (r.runs_a && r.runs_b) {
+			const [a0, a1] = r.runs_a;
+			const [b0, b1] = r.runs_b;
+			return (a1 < b0 || b1 < a0) && Math.abs(r.b - r.a) >= 2;
+		}
+		return drill_moved(r.a, r.b);
+	};
+	const out = [];
+	for (const [k, r] of rows) {
+		if (into.has(k) || !moved(r)) continue;
+		const d = r.b - r.a;
+		const kids = r.kids.filter((c) => !into.has(c)).map((c) => rows.get(c)).filter((c) => Math.sign(c.b - c.a) === Math.sign(d));
+		const carried = kids.filter((c) => moved(c)).reduce((s, c) => s + (c.b - c.a), 0);
+		if (Math.abs(carried) >= .7 * Math.abs(d)) continue;
+		const noise = kids.filter((c) => c.runs_a && c.runs_b && !moved(c)).reduce((s, c) => s + (c.b - c.a), 0);
+		if (Math.abs(noise) >= .7 * Math.abs(d)) continue;
+		out.push({
+			path: r.path,
+			kind: r.kind,
+			...r.at ? { at: r.at } : {},
+			a_ms: round2(r.a),
+			b_ms: round2(r.b),
+			d_ms: round2(d),
+			...r.upto ? { upto: r.upto } : {},
+			...r.waiting ? { waiting: true } : {},
+			status: r.a < .05 ? "new" : r.b < .05 ? "fixed" : d < 0 ? "better" : "worse"
+		});
+	}
+	return out.sort((x, y) => Math.abs(y.d_ms) - Math.abs(x.d_ms)).slice(0, 20);
+}
+/** what makes two reports' patterns the same one: its kind, and for a library call the library */
+const pattern_key = (p) => p.kind + "\0" + (p.kind === "library-per-item" ? p.sites[0]?.libs?.[0] ?? "" : "");
+function pattern_deltas(a = [], b = [], ra = 1, rb = 1) {
+	const out = /* @__PURE__ */ new Map();
+	const cost = (p, r) => round2(p.wait ? p.cost_ms : p.cost_ms / r);
+	const save = (p, r) => round2(p.wait ? p.save_ms : p.save_ms / r);
+	for (const p of a) {
+		const c = cost(p, ra);
+		out.set(pattern_key(p), {
+			title: p.title,
+			kind: p.kind,
+			a_ms: c,
+			b_ms: 0,
+			d_ms: -c,
+			a_save: save(p, ra),
+			b_save: 0,
+			a_sites: p.sites.length,
+			b_sites: 0,
+			status: "fixed",
+			...p.wait ? { wait: true } : {}
+		});
+	}
+	for (const p of b) {
+		const r = out.get(pattern_key(p));
+		const c = cost(p, rb);
+		if (!r) {
+			out.set(pattern_key(p), {
+				title: p.title,
+				kind: p.kind,
+				a_ms: 0,
+				b_ms: c,
+				d_ms: c,
+				a_save: 0,
+				b_save: save(p, rb),
+				a_sites: 0,
+				b_sites: p.sites.length,
+				status: "new",
+				...p.wait ? { wait: true } : {}
+			});
+			continue;
+		}
+		r.title = p.title;
+		r.b_ms = c;
+		r.d_ms = round2(c - r.a_ms);
+		r.b_save = save(p, rb);
+		r.b_sites = p.sites.length;
+		r.status = !(Math.abs(r.d_ms) >= Math.max(.2 * r.a_ms, 2)) ? "same" : r.d_ms < 0 ? "better" : "worse";
+	}
+	const rank = {
+		fixed: 0,
+		new: 1,
+		worse: 2,
+		better: 3,
+		shifted: 4,
+		same: 5
+	};
+	for (const r of out.values()) if ((r.status === "fixed" || r.status === "new") && Math.max(r.a_ms, r.b_ms) < 3 && !r.wait) r.status = "same";
+	return [...out.values()].sort((x, y) => rank[x.status] - rank[y.status] || Math.abs(y.d_ms) - Math.abs(x.d_ms));
+}
+/** what the fixed and improved patterns promised, without the older report's forecast: not added up
+*  blindly — a whole-page cache's "saving" IS the render (it tracks any change), and wait patterns
+*  cover the SAME calls (one call made faster shrinks "same answer", "waits in a row" and "one slow
+*  call" at once), so the waits promise their largest move, CPU patterns their sum */
+function summed_promise(patterns) {
+	let cpu = 0;
+	let wait = 0;
+	for (const p of patterns) {
+		if (p.status !== "fixed" && p.status !== "better") continue;
+		if (p.kind === "same-document" || p.kind === "almost-same-document") continue;
+		const d = Math.max(0, p.a_save - p.b_save);
+		if (p.wait) wait = Math.max(wait, d);
+		else cpu += d;
+	}
+	return cpu + wait;
+}
+/** a title without its "(3 places)": the count changes when a fix shrinks a pattern */
+const bare_title = (t) => {
+	const i = t.lastIndexOf(" (");
+	return i !== -1 && (t.endsWith(" places)") || t.endsWith(" place)")) ? t.slice(0, i) : t;
+};
+/**
+* WHAT THE CHANGE PROMISED, COUNTED THE FORECAST'S WAY: the older report's forecast parts that got
+* done — a part whose fix (or one it covers) went away counts whole, one that shrank by its share,
+* work for unread data when the newer report no longer has it — added with the same overlap rules
+* and caps as the forecast itself. The forecast was held to account against fixed pages; this is
+* the same arithmetic for the fix you actually made.
+*/
+/**
+* HOW MUCH OF EACH OLDER PATTERN IS STILL THERE, BY ITS OWN SITES: the share of its cost on sites
+* whose code the newer report still flags with the same kind (matched by the code, not the line
+* number an edit above moves). "Waits in a row" in both reports can be two different sets of calls —
+* the chains fixed, a new one between the batches — and its title alone would say it only shrank.
+*/
+function still_there(a, b) {
+	const out = /* @__PURE__ */ new Map();
+	const code_of = (s) => (s.code ?? "").trim();
+	const cost = (s) => s.wait_ms ?? s.cpu_ms ?? 0;
+	for (const p of a ?? []) {
+		const left = new Set((b ?? []).filter((q) => q.kind === p.kind).flatMap((q) => q.sites.map(code_of)));
+		const coded = p.sites.filter((s) => code_of(s));
+		const total = coded.reduce((t, s) => t + cost(s), 0);
+		if (!(total > 0)) continue;
+		const kept = coded.filter((s) => left.has(code_of(s))).reduce((t, s) => t + cost(s), 0);
+		out.set(bare_title(p.title), kept / total);
+	}
+	return out;
+}
+function promised_by(fa, fb, patterns, left, b_clean = false) {
+	const find = (title) => patterns.find((p) => bare_title(p.title) === bare_title(title));
+	const still_unread = /* @__PURE__ */ new Set();
+	const is_unread = (t) => t.startsWith("Delete work for data nothing reads");
+	for (const p of [...fb?.parts ?? [], ...fb?.answers?.parts ?? []]) {
+		if (p.kind === "unread-work") still_unread.add(p.title);
+		for (const w of p.with ?? []) if (is_unread(w)) still_unread.add(w);
+	}
+	const b_known = !!fb || b_clean;
+	const done = [];
+	for (const part of fa.parts) {
+		if (part.kind === "unread-work") {
+			if (b_known && !still_unread.has(part.title)) done.push(part);
+			continue;
+		}
+		let share = 0;
+		for (const t of [part.title, ...part.with ?? []]) {
+			const d = find(t);
+			if (!d) continue;
+			let frac = 0;
+			if (d.status === "fixed") frac = 1;
+			else if (d.status === "better" && d.a_save > 0) {
+				const l = left?.get(bare_title(t));
+				frac = Math.max(Math.min(1, Math.max(0, (d.a_save - d.b_save) / d.a_save)), l === void 0 ? 0 : 1 - l);
+			}
+			if (frac <= 0) continue;
+			share = Math.max(share, t === part.title || part.ms <= 0 ? frac : Math.min(1, frac * d.a_save / part.ms));
+		}
+		if (share > 0) done.push({
+			ms: part.ms * share,
+			wait: part.wait,
+			kind: part.kind
+		});
+	}
+	return fa.now_ms - saving_of(done, fa.caps ?? {}, fa.now_ms).after;
+}
+/** The patterns a change fixed or shrank, their expected saving summed, against the median render's
+*  measured change. A saving well under the prediction usually moved somewhere (another line got
+*  slower) or drowned in run-to-run noise; well over it, the fix removed more than the pattern saw. */
+function fix_check_of(patterns, a, b, fa, fb, left) {
+	if (a.trigger !== "page" || b.trigger !== "page" || !a.runs?.length || !b.runs?.length) return void 0;
+	const predicted = fa?.parts.length ? promised_by(fa, fb, patterns, left, !fb && (b.run_status ?? 200) === 200) : summed_promise(patterns);
+	if (predicted < 2) return void 0;
+	const measured = median(a.runs) - median(b.runs);
+	const verdict = measured >= predicted * .6 && measured <= predicted * 1.6 ? "as-expected" : measured < predicted * .6 ? "less" : "more";
+	return {
+		predicted_ms: round2(predicted),
+		measured_ms: round2(measured),
+		verdict
+	};
+}
+const round2 = (n) => Math.round(n * 100) / 100;
+/** finding codes about the recording's conditions, not the page's code (compare leaves them out) */
+const RUN_STATE_CODES = /* @__PURE__ */ new Set([
+	"cold-start",
+	"cold-instance",
+	"profiler-overhead",
+	"heap-filled-before",
+	"heap-near-limit",
+	"budget",
+	"dev-mode",
+	"low-confidence",
+	"busy-instance",
+	"runs-set-aside",
+	"summary",
+	"phases"
+]);
+/** warnings that fire when one number of the recording passes a cut (report.ts): the number, and the cut */
+const NEAR_CUT = { "loop-stall": {
+	value: (m) => m.loop_delay?.p99,
+	at: 50
+} };
+const median = (xs) => xs.length ? [...xs].sort((x, y) => x - y)[Math.floor(xs.length / 2)] : 0;
+function label_of(m) {
+	if (m.trigger === "page") return `page ${m.page} ×${m.runs?.length ?? 0}`;
+	if (m.trigger === "request") return `request ${m.request?.path ?? ""}`;
+	if (m.trigger === "trap") return `caught ${m.request?.path ?? ""}`;
+	return `${Math.round(m.duration_ms / 1e3)}s window`;
+}
+function delta_rows(a, b, by) {
+	const map = /* @__PURE__ */ new Map();
+	for (const f of a) map.set(f[by], {
+		key: f[by],
+		name: f.name,
+		file: f.url,
+		line: f.line,
+		a_self: f.self_ms,
+		b_self: 0,
+		d_self: -f.self_ms,
+		a_total: f.total_ms,
+		b_total: 0,
+		d_total: -f.total_ms,
+		a_calls: f.calls ?? null,
+		b_calls: null,
+		only: "a"
+	});
+	for (const f of b) {
+		const row = map.get(f[by]);
+		if (row) {
+			row.file = f.url;
+			row.line = f.line;
+			row.b_self = f.self_ms;
+			row.b_total = f.total_ms;
+			row.b_calls = f.calls ?? null;
+			row.d_self = round2(f.self_ms - row.a_self);
+			row.d_total = round2(f.total_ms - row.a_total);
+			delete row.only;
+		} else map.set(f[by], {
+			key: f[by],
+			name: f.name,
+			file: f.url,
+			line: f.line,
+			a_self: 0,
+			b_self: f.self_ms,
+			d_self: f.self_ms,
+			a_total: 0,
+			b_total: f.total_ms,
+			d_total: f.total_ms,
+			a_calls: null,
+			b_calls: f.calls ?? null,
+			only: "b"
+		});
+	}
+	return [...map.values()].sort((x, y) => Math.abs(y.d_self) - Math.abs(x.d_self) || Math.abs(y.d_total) - Math.abs(x.d_total));
+}
+function compare_reports(a, b) {
+	const drill = drill_deltas(a.drill, b.drill);
+	const order = order_of(a, b);
+	const A = a.analysis;
+	const B = b.analysis;
+	const ra = renders_of(a.meta);
+	const rb = renders_of(b.meta);
+	const per = (list, r) => r === 1 ? [...list] : list.map((f) => ({
+		...f,
+		self_ms: round2(f.self_ms / r),
+		total_ms: round2(f.total_ms / r)
+	}));
+	const gc_makers = /* @__PURE__ */ new Map();
+	const mb = (n) => round2(n / 1048576);
+	for (const m of a.gc?.makers ?? []) {
+		const al = mb(m.allocated / ra);
+		const g = round2(m.gc_ms / ra);
+		gc_makers.set(`${m.name}|${m.caller ?? ""}`, {
+			name: m.name,
+			caller: m.caller ?? null,
+			component: m.component,
+			a_mb: al,
+			b_mb: 0,
+			d_mb: -al,
+			a_gc_ms: g,
+			b_gc_ms: 0,
+			d_gc_ms: -g,
+			only: "a"
+		});
+	}
+	for (const m of b.gc?.makers ?? []) {
+		const k = `${m.name}|${m.caller ?? ""}`;
+		const r = gc_makers.get(k);
+		const al = mb(m.allocated / rb);
+		const g = round2(m.gc_ms / rb);
+		if (r) {
+			r.b_mb = al;
+			r.d_mb = round2(r.b_mb - r.a_mb);
+			r.b_gc_ms = g;
+			r.d_gc_ms = round2(g - r.a_gc_ms);
+			delete r.only;
+		} else gc_makers.set(k, {
+			name: m.name,
+			caller: m.caller ?? null,
+			component: m.component,
+			a_mb: 0,
+			b_mb: al,
+			d_mb: al,
+			a_gc_ms: 0,
+			b_gc_ms: g,
+			d_gc_ms: g,
+			only: "b"
+		});
+	}
+	const row = (label, x, y, unit) => ({
+		label,
+		a: round2(x),
+		b: round2(y),
+		d: round2(y - x),
+		unit
+	});
+	const summary = [];
+	if (a.meta.trigger === "page" && b.meta.trigger === "page") summary.push(row("render (median run)", median(a.meta.runs ?? []), median(b.meta.runs ?? []), "ms"));
+	else if (a.meta.trigger === "request" && b.meta.trigger === "request") summary.push(row("request", a.meta.request?.ms ?? 0, b.meta.request?.ms ?? 0, "ms"));
+	summary.push(row("CPU busy (per render)", A.busy_ms / ra, B.busy_ms / rb, "ms"));
+	summary.push(row("garbage collection (per render)", (a.gc?.summary.total_ms ?? A.gc_ms) / ra, (b.gc?.summary.total_ms ?? B.gc_ms) / rb, "ms"));
+	if (a.gc || b.gc) summary.push(row("allocated (per render)", (a.gc?.summary.allocated_mb ?? 0) / ra, (b.gc?.summary.allocated_mb ?? 0) / rb, "MB"));
+	if (A.timeline && B.timeline) summary.push(row("waiting (I/O)", A.timeline.wait_ms, B.timeline.wait_ms, "ms"));
+	const net_ms = (m) => {
+		const own = m.requests.filter((r) => r.internal || m.trigger !== "page");
+		return own.length ? Math.max(...own.map((r) => r.net_ms)) : 0;
+	};
+	const net_n = (m) => {
+		const own = m.requests.filter((r) => r.internal || m.trigger !== "page");
+		return own.length ? Math.max(...own.map((r) => r.net_count)) : 0;
+	};
+	summary.push(row("outbound calls", net_n(a.meta), net_n(b.meta), "n"));
+	summary.push(row("outbound time", net_ms(a.meta), net_ms(b.meta), "ms"));
+	const og = (m) => own_requests(m).find((r) => r.og)?.og;
+	const oa = og(a.meta);
+	const ob = og(b.meta);
+	if (oa || ob) {
+		summary.push(row("ogygia transform", oa?.transform_ms ?? 0, ob?.transform_ms ?? 0, "ms"));
+		summary.push(row("page seed", (oa?.seed_bytes ?? 0) / 1024, (ob?.seed_bytes ?? 0) / 1024, "KB"));
+		summary.push(row("island props", (oa?.tail_bytes ?? 0) / 1024, (ob?.tail_bytes ?? 0) / 1024, "KB"));
+	}
+	summary.push(row("components seen", A.components.length, B.components.length, "n"));
+	const phase_map = /* @__PURE__ */ new Map();
+	for (const p of A.timeline?.phases ?? []) phase_map.set(p.phase, {
+		a: p.cpu_ms + p.wait_ms,
+		b: 0
+	});
+	for (const p of B.timeline?.phases ?? []) {
+		const r = phase_map.get(p.phase) ?? {
+			a: 0,
+			b: 0
+		};
+		r.b = p.cpu_ms + p.wait_ms;
+		phase_map.set(p.phase, r);
+	}
+	const phases = [...phase_map.entries()].map(([phase, r]) => ({
+		phase,
+		label: PHASE_LABEL[phase],
+		a: round2(r.a),
+		b: round2(r.b),
+		d: round2(r.b - r.a)
+	})).sort((x, y) => Math.abs(y.d) - Math.abs(x.d));
+	const code_of = (f) => {
+		const colon = f.indexOf(":");
+		return colon === -1 ? f : f.slice(0, colon);
+	};
+	const a_codes = new Set(a.findings.map(code_of));
+	const b_codes = new Set(b.findings.map(code_of));
+	const near_cut = (code) => {
+		const cut = NEAR_CUT[code];
+		if (!cut) return false;
+		const x = cut.value(a.meta);
+		const y = cut.value(b.meta);
+		return x !== void 0 && y !== void 0 && Math.abs(x - cut.at) <= cut.at * .3 && Math.abs(y - cut.at) <= cut.at * .3;
+	};
+	const of_the_code = (f) => !RUN_STATE_CODES.has(code_of(f)) && !near_cut(code_of(f));
+	const paths = /* @__PURE__ */ new Map();
+	for (const g of A.paths ?? []) {
+		const ms = round2(g.ms / ra);
+		paths.set(g.owner.name, {
+			owner: g.owner.name,
+			file: g.owner.url,
+			line: g.owner.line,
+			a_ms: ms,
+			b_ms: 0,
+			d_ms: -ms,
+			a_fns: g.fns.map((f) => f.name),
+			b_fns: [],
+			only: "a"
+		});
+	}
+	for (const g0 of B.paths ?? []) {
+		const g = {
+			...g0,
+			ms: round2(g0.ms / rb)
+		};
+		const row = paths.get(g.owner.name);
+		if (row) {
+			row.b_ms = g.ms;
+			row.d_ms = round2(g.ms - row.a_ms);
+			row.b_fns = g.fns.map((f) => f.name);
+			row.file = g.owner.url;
+			row.line = g.owner.line;
+			delete row.only;
+		} else paths.set(g.owner.name, {
+			owner: g.owner.name,
+			file: g.owner.url,
+			line: g.owner.line,
+			a_ms: 0,
+			b_ms: g.ms,
+			d_ms: g.ms,
+			a_fns: [],
+			b_fns: g.fns.map((f) => f.name),
+			only: "b"
+		});
+	}
+	const patterns = pattern_deltas(a.patterns, b.patterns, ra, rb);
+	const checked = fix_check_of(patterns, a.meta, b.meta, a.forecast, b.forecast, still_there(a.patterns, b.patterns));
+	const fix_check = checked && order?.earlier === "a" ? {
+		...checked,
+		skewed: true
+	} : checked;
+	return mark_shifted({
+		a: {
+			id: a.meta.id,
+			label: label_of(a.meta),
+			created: a.meta.created
+		},
+		b: {
+			id: b.meta.id,
+			label: label_of(b.meta),
+			created: b.meta.created
+		},
+		summary,
+		phases,
+		components: delta_rows(per(A.components, ra), per(B.components, rb), "name"),
+		functions: delta_rows(per(A.functions.slice(0, 120), ra), per(B.functions.slice(0, 120), rb), "key").slice(0, 60),
+		findings: {
+			added: [...new Set(b.findings.filter((f) => of_the_code(f) && !a_codes.has(code_of(f))))],
+			gone: [...new Set(a.findings.filter((f) => of_the_code(f) && !b_codes.has(code_of(f))))]
+		},
+		paths: [...paths.values()].sort((x, y) => Math.abs(y.d_ms) - Math.abs(x.d_ms)),
+		gc_makers: [...gc_makers.values()].filter((m) => Math.abs(m.d_mb) >= .5 || Math.abs(m.d_gc_ms) >= .5).sort((x, y) => Math.abs(y.d_gc_ms) - Math.abs(x.d_gc_ms) || Math.abs(y.d_mb) - Math.abs(x.d_mb)),
+		patterns,
+		...fix_check ? { fix_check } : {},
+		lines: line_deltas(a.ledger, b.ledger, renders_of(a.meta), renders_of(b.meta)),
+		...drill.length ? { drill } : {},
+		...order ? { order } : {},
+		...render_same_of(a.meta, b.meta)
+	});
+}
+/** Page-mode reports grouped by page, oldest first, with each run's median — the history line. */
+function page_history(metas, score_of) {
+	const by_page = /* @__PURE__ */ new Map();
+	for (const m of metas) {
+		if (m.trigger !== "page" || !m.page || !m.runs?.length) continue;
+		const list = by_page.get(m.page) ?? [];
+		const score = score_of?.(m.id);
+		list.push({
+			id: m.id,
+			created: m.created,
+			median: round2(median(m.runs)),
+			...score !== void 0 ? { score } : {}
+		});
+		by_page.set(m.page, list);
+	}
+	return [...by_page.entries()].map(([page, points]) => ({
+		page,
+		points: points.sort((x, y) => x.created - y.created)
+	})).filter((h) => h.points.length >= 1).sort((x, y) => y.points.at(-1).created - x.points.at(-1).created);
+}
+export { compare_reports, drill_deltas, fix_check_of, island_files_diff, line_deltas, mark_shifted, order_of, page_history, pattern_deltas, still_there, vitals_moved };