@ogygia/devtools 0.0.0 → 0.11.1

package/dist/profiler/timeline.js

@@ -0,0 +1,690 @@
+// src/profiler/timeline.ts
+const PHASE_LABEL = {
+	hooks: "hooks",
+	load: "load functions",
+	remote: "remote functions",
+	render: "component render",
+	ogygia: "ogygia transform",
+	kit: "Kit routing + response",
+	other: "other"
+};
+const round2 = (n) => Math.round(n * 100) / 100;
+const KIT_LOAD_RE = /\/runtime\/server\/page\/load_data\.js/;
+/** Kit remote functions (`query` / `command` / `form` / `prerender` from a `.remote.ts`): the app's
+*  remote file itself, or Kit's remote runtime that runs it. A remote awaited during SSR — an
+*  island's top-level `await getX()`, a `load` calling one — is on the critical path like a load. */
+const KIT_REMOTE_RE = /\/runtime\/(?:app\/server\/remote|server\/remote)\//;
+const APP_REMOTE_FILE_RE = /\.remote\.[jt]s(?:\.js)?$/;
+const KIT_RENDER_RE = /\/runtime\/server\/page\/render\.js/;
+const KIT_RUNTIME_RE = /@sveltejs\/kit\/src\/runtime\/server\//;
+const APP_LOAD_FILE_RE = /(?:^|[/\\])(?:\+(?:page|layout)(?:\.server)?\.[jt]s|_(?:page|layout)(?:\.server)?\.[jt]s\.js)$/;
+const APP_HOOKS_FILE_RE = /(?:^|[/\\])hooks\.server\.[jt]s(?:\.js)?$/;
+/** A load file inside a resolved caller (`load (routes/x/+page.server.ts:44)`) or a frame url. */
+const LOAD_FILE_IN_TEXT_RE = /((?:[^\s()]*[/\\])?[+_](page|layout|error)(\.server)?\.[jt]s(?:\.js)?)(?::\d+)?/;
+const SRC_REL_RE = /[/\\]src[/\\](.*)$/;
+/** The lane a load frame / caller belongs to: `{ file, level, kind }`, or null. */
+function load_lane_of(text) {
+	const m = LOAD_FILE_IN_TEXT_RE.exec(text);
+	if (!m) return null;
+	let file = m[1].replace(/\\/g, "/");
+	const rel = SRC_REL_RE.exec(file);
+	file = rel ? rel[1] : file.split("/").filter(Boolean).slice(-3).join("/");
+	file = file.replace(/(^|\/)_(page|layout|error)((?:\.server)?\.[jt]s)\.js$/, (_, pre, l, ext) => `${pre}+${l}${ext}`);
+	return {
+		file,
+		level: m[2],
+		kind: m[3] ? "server" : "universal"
+	};
+}
+const OGYGIA_SERVER_RE = /\/(?:ogygia|@ogygia\/core|packages\/core)\/(?:src|dist)\/(?!profiler\/)/;
+/** The Kit phase of ONE frame, or null when the frame says nothing about it. */
+function phase_of_frame(f, hooks) {
+	if (f.name === "inject_client_seeds") return "ogygia";
+	const url = f.url;
+	if (!url) return null;
+	const stem = hooks?.get(f.name);
+	if (stem && is_in_file(url, stem)) return "hooks";
+	if (OGYGIA_SERVER_RE.test(url)) return "ogygia";
+	if (APP_REMOTE_FILE_RE.test(url) || KIT_REMOTE_RE.test(url)) return "remote";
+	if (f.category === "component" || f.category === "svelte" || KIT_RENDER_RE.test(url)) return "render";
+	if (KIT_LOAD_RE.test(url) || APP_LOAD_FILE_RE.test(url)) return "load";
+	if (APP_HOOKS_FILE_RE.test(url)) return "hooks";
+	if (KIT_RUNTIME_RE.test(url)) return "kit";
+	return null;
+}
+/** Walk a stack leaf → root; the first frame that names a phase wins (the deepest decision). */
+function phase_of_stack(frames, hooks) {
+	for (const f of frames) {
+		const p = phase_of_frame(f, hooks);
+		if (p) return p;
+	}
+	if (hooks?.size) for (const f of frames) {
+		if (!f.url) continue;
+		for (const stem of hooks.values()) if (is_in_file(f.url, stem)) return "hooks";
+	}
+	return "other";
+}
+/** does `url` name a file whose stem is `stem` (`…/ds-ssr.ts`, `…/ds-ssr.js`, `ds-ssr.ts`)? */
+function is_in_file(url, stem) {
+	const at = url.lastIndexOf(stem + ".");
+	if (at === -1) return false;
+	const before = url.charCodeAt(at - 1);
+	return at === 0 || before === 47 || before === 92;
+}
+/** The frame a CPU segment is charged to: the deepest component, else the deepest named app
+*  function, else the deepest dependency, else the runtime bucket the leaf is in. */
+function owner_of_stack(frames) {
+	const named = (f) => f.name && f.name !== "(anonymous)" && !f.name.startsWith("(");
+	const file_of = (f) => f.url ? `${short(f.url)}:${f.line}` : "";
+	const leaf = frames.find((f) => named(f) && f.category !== "v8" && f.category !== "gc");
+	const pick = (f, label) => ({
+		label,
+		file: file_of(f),
+		category: f.category,
+		detail: leaf && leaf !== f ? leaf.name + (leaf.pkg ? ` (${leaf.pkg})` : "") : void 0
+	});
+	let comp;
+	let app;
+	let dep;
+	for (const f of frames) {
+		if (!comp && f.category === "component") comp = f;
+		if (!app && f.category === "app" && named(f)) app = f;
+		if (!dep && f.category === "dependency" && named(f)) dep = f;
+	}
+	if (comp) return pick(comp, comp.name);
+	if (app) return pick(app, app.name);
+	if (dep) return pick(dep, dep.pkg ? `${dep.name} (${dep.pkg})` : dep.name);
+	const anon = frames.find((f) => f.category === "app" && f.url);
+	if (anon) return pick(anon, anon.line <= 1 ? `module load (${short(anon.url)})` : `fn @ ${short(anon.url)}:${anon.line}`);
+	const anon_dep = frames.find((f) => f.category === "dependency" && f.pkg);
+	if (anon_dep) return pick(anon_dep, `${anon_dep.line <= 1 ? "module load" : "(anonymous)"} (${anon_dep.pkg})`);
+	const top = frames[0];
+	if (!top) return {
+		label: "unknown",
+		file: "",
+		category: "unknown"
+	};
+	if (top.category === "gc") return {
+		label: "garbage collection",
+		file: "",
+		category: "gc"
+	};
+	if (top.category === "svelte") return pick(top, "svelte internals");
+	if (top.category === "node") return pick(top, `node core: ${top.name || "(native)"}`);
+	if (top.category === "profiler") return pick(top, "profiler overhead");
+	return pick(top, top.name || "v8");
+}
+function short(url) {
+	const nm = url.lastIndexOf("node_modules/");
+	if (nm !== -1) return url.slice(nm + 13);
+	const parts = url.split("/");
+	return parts.length > 4 ? parts.slice(-4).join("/") : url;
+}
+/**
+* Build the timeline. `frame_of` resolves a profile node to its frame facts, `parent_of` the
+* tree; both come from `analyze`'s own tables so the timeline agrees with every other view.
+*/
+function build_timeline(profile, frame_of, parent_of, input) {
+	const { start: w0, end: w1 } = input.window;
+	const window_ms = Math.max(w1 - w0, .01);
+	const stack_memo = /* @__PURE__ */ new Map();
+	const describe = (id) => {
+		const hit = stack_memo.get(id);
+		if (hit) return hit;
+		const frames = [];
+		let cur = id;
+		while (cur !== void 0 && frames.length < 64) {
+			frames.push(frame_of(cur));
+			cur = parent_of(cur);
+		}
+		const leaf = frames[0];
+		const idle = !!leaf && (leaf.category === "idle" || leaf.name === "(root)" || leaf.name === "(program)");
+		let lane = null;
+		let in_parent = false;
+		/** packages app code calls into on this stack, and the outermost package when no app code is on it */
+		const entered = [];
+		let root_pkg;
+		let has_app = false;
+		let inner;
+		for (let k = 0; k < frames.length; k++) {
+			const f = frames[k];
+			if (!lane && f.url && APP_LOAD_FILE_RE.test(f.url)) lane = load_lane_of(f.url);
+			if (f.name === "parent" && KIT_LOAD_RE.test(f.url)) in_parent = true;
+			if (f.category === "app" || f.category === "component") {
+				if (!has_app) inner = f;
+				has_app = true;
+				const child = frames[k - 1];
+				if (child?.category === "dependency" && child.pkg && !entered.includes(child.pkg)) entered.push(child.pkg);
+			} else if (f.category === "dependency" && f.pkg) root_pkg = f.pkg;
+		}
+		const d = {
+			owner: owner_of_stack(frames),
+			phase: phase_of_stack(frames, input.hooks),
+			idle,
+			lane,
+			in_parent,
+			entered,
+			orphan_pkg: has_app ? void 0 : root_pkg,
+			inner
+		};
+		stack_memo.set(id, d);
+		return d;
+	};
+	const cpu = [];
+	const lanes = /* @__PURE__ */ new Map();
+	/** a lane's wait intervals, unioned at the end (parallel calls overlap) */
+	const lane_waits = /* @__PURE__ */ new Map();
+	const lane_row = (l) => {
+		let r = lanes.get(l.file);
+		if (!r) lanes.set(l.file, r = {
+			...l,
+			t0: Infinity,
+			t1: -Infinity,
+			cpu_ms: 0,
+			wait_ms: 0,
+			awaited_parent: false
+		});
+		return r;
+	};
+	const samples = profile.samples ?? [];
+	const deltas = profile.timeDeltas ?? [];
+	let t_us = profile.startTime;
+	/** package → the phase of the code that last called into it. A library that goes on working after
+	*  an await (its own promise chain, a timer loop) has no app frame under it; that work belongs to
+	*  whoever last called in — the same rule the functions table uses for a library's async work */
+	const entry_phase = /* @__PURE__ */ new Map();
+	/** owner label → `name\0file:line` of the deepest app function → ms */
+	const inner_ms = /* @__PURE__ */ new Map();
+	for (let i = 0; i < samples.length; i++) {
+		const d = deltas[i] ?? 0;
+		t_us += d;
+		const t = input.perf_start + (t_us - profile.startTime) / 1e3;
+		if (t > w1 || d <= 0) continue;
+		const described = describe(samples[i]);
+		if (described.idle) continue;
+		for (const pkg of described.entered) entry_phase.set(pkg, described.phase);
+		if (t < w0) continue;
+		const inherited = described.phase === "other" && described.orphan_pkg ? entry_phase.get(described.orphan_pkg) : void 0;
+		const info = inherited ? {
+			...described,
+			phase: inherited
+		} : described;
+		const s0 = Math.max(t - d / 1e3, w0) - w0;
+		const s1 = t - w0;
+		const o = info.owner;
+		if (info.inner && (o.category === "app" || o.category === "component")) {
+			const m = inner_ms.get(o.label) ?? inner_ms.set(o.label, /* @__PURE__ */ new Map()).get(o.label);
+			const k = `${info.inner.name}\0${short(info.inner.url)}:${info.inner.line}`;
+			m.set(k, (m.get(k) ?? 0) + s1 - s0);
+		}
+		if (info.lane) {
+			const row = lane_row(info.lane);
+			row.t0 = Math.min(row.t0, s0);
+			row.t1 = Math.max(row.t1, s1);
+			if (info.owner.category !== "profiler") row.cpu_ms += s1 - s0;
+			if (info.in_parent) row.awaited_parent = true;
+		}
+		const last = cpu[cpu.length - 1];
+		if (last && last.owner.label === info.owner.label && last.phase === info.phase && last.lane === info.lane?.file && s0 - last.t1 <= d / 1e3 * 2) last.t1 = s1;
+		else cpu.push({
+			t0: s0,
+			t1: s1,
+			owner: info.owner,
+			phase: info.phase,
+			...info.lane ? { lane: info.lane.file } : {}
+		});
+	}
+	const waits = [];
+	for (const c of input.calls) {
+		if (c.ms < 0) continue;
+		const a = Math.max(c.start, w0) - w0;
+		const b = Math.min(c.start + c.ms, w1) - w0;
+		if (b - a < .05) continue;
+		waits.push({
+			t0: a,
+			t1: b,
+			call: c
+		});
+		if (c.caller) {
+			const l = load_lane_of(c.caller);
+			if (l) {
+				const row = lane_row(l);
+				row.t0 = Math.min(row.t0, a);
+				row.t1 = Math.max(row.t1, b);
+				(lane_waits.get(l.file) ?? lane_waits.set(l.file, []).get(l.file)).push([a, b]);
+			}
+		}
+	}
+	const bounds = /* @__PURE__ */ new Set([0, window_ms]);
+	for (const c of cpu) {
+		bounds.add(c.t0);
+		bounds.add(c.t1);
+	}
+	for (const w of waits) {
+		bounds.add(w.t0);
+		bounds.add(w.t1);
+	}
+	for (const p of input.pending ?? []) {
+		const a = p.start - w0;
+		const b = p.end - w0;
+		if (a > 0 && a < window_ms) bounds.add(a);
+		if (b > 0 && b < window_ms) bounds.add(b);
+	}
+	const ticks = [...bounds].sort((a, b) => a - b);
+	const segments = [];
+	let last_phase = "other";
+	let ci = 0;
+	for (let i = 0; i + 1 < ticks.length; i++) {
+		const a = ticks[i];
+		const b = ticks[i + 1];
+		if (b - a <= 0) continue;
+		const mid = (a + b) / 2;
+		while (ci < cpu.length && cpu[ci].t1 <= a) ci++;
+		const cpu_here = ci < cpu.length && cpu[ci].t0 <= mid && mid < cpu[ci].t1 ? cpu[ci] : null;
+		const all_active = waits.filter((w) => w.t0 <= mid && mid < w.t1);
+		const on_cpu = cpu_here && !(cpu_here.owner.category === "profiler" && all_active.length) ? cpu_here : null;
+		const open_spans = all_active.filter((w) => w.call.kind === "span");
+		const inner = open_spans.length ? open_spans.reduce((m, w) => w.call.ms < m.call.ms ? w : m, open_spans[0]) : null;
+		let seg;
+		if (on_cpu) {
+			last_phase = on_cpu.phase;
+			seg = {
+				t0: a,
+				t1: b,
+				kind: "cpu",
+				label: on_cpu.owner.label,
+				detail: on_cpu.owner.detail,
+				file: on_cpu.owner.file,
+				category: on_cpu.owner.category,
+				phase: on_cpu.phase,
+				...on_cpu.lane ? { lane: on_cpu.lane } : {},
+				...inner ? { within: inner.call.label } : {}
+			};
+		} else {
+			const active = all_active.filter((w) => w.call.kind !== "span");
+			if (active.length) {
+				const calls = active.map((w) => ({
+					label: w.call.label,
+					ms: round2(w.call.ms),
+					caller: w.call.caller,
+					...w.call.callers && w.call.callers.length > 1 ? { callers: w.call.callers } : {},
+					...w.call.timings ? { timings: w.call.timings } : {},
+					...w.call.body_ms ? { body_ms: w.call.body_ms } : {}
+				}));
+				const owner = active.reduce((m, w) => w.call.ms > m.call.ms ? w : m, active[0]);
+				seg = {
+					t0: a,
+					t1: b,
+					kind: "wait",
+					label: calls.length === 1 ? calls[0].label : `${calls.length} calls in parallel`,
+					category: "idle",
+					phase: owner.call.phase ?? inner?.call.phase ?? last_phase,
+					calls,
+					...inner ? { within: inner.call.label } : {}
+				};
+			} else if (inner) seg = {
+				t0: a,
+				t1: b,
+				kind: "wait",
+				label: `in ${inner.call.label}`,
+				category: "idle",
+				phase: inner.call.phase ?? last_phase,
+				calls: [{
+					label: inner.call.label,
+					ms: round2(inner.call.ms),
+					caller: inner.call.caller
+				}],
+				within: inner.call.label
+			};
+			else {
+				const pend = (input.pending ?? []).filter((p) => p.start - w0 <= mid && p.end - w0 >= mid).map((p) => p.label);
+				const uniq = [...new Set(pend)];
+				seg = {
+					t0: a,
+					t1: b,
+					kind: "gap",
+					label: uniq.length ? `nothing recorded — pending: ${uniq[0]}${uniq.length > 1 ? ` (+${uniq.length - 1})` : ""}` : "nothing recorded",
+					category: "unknown",
+					phase: last_phase,
+					...uniq.length ? { pending: uniq.slice(0, 6) } : {}
+				};
+			}
+		}
+		const prev = segments[segments.length - 1];
+		if (prev && prev.kind === seg.kind && prev.label === seg.label && prev.phase === seg.phase && prev.detail === seg.detail && prev.within === seg.within && prev.lane === seg.lane && (prev.pending?.join() ?? "") === (seg.pending?.join() ?? "") && call_id(prev) === call_id(seg)) prev.t1 = b;
+		else segments.push(seg);
+	}
+	for (const s of segments) {
+		s.t0 = round2(s.t0);
+		s.t1 = round2(s.t1);
+	}
+	for (let i = segments.length - 1; i >= 0; i--) if (segments[i].t1 <= segments[i].t0 && segments.length > 1) segments.splice(i, 1);
+	let cpu_ms = 0, wait_ms = 0, gap_ms = 0;
+	const phase_map = /* @__PURE__ */ new Map();
+	const phase_row = (p) => {
+		let r = phase_map.get(p);
+		if (!r) phase_map.set(p, r = {
+			phase: p,
+			cpu_ms: 0,
+			wait_ms: 0
+		});
+		return r;
+	};
+	/** phase → owner label → CPU ms: who a phase's CPU was */
+	const phase_owners = /* @__PURE__ */ new Map();
+	let overhead_ms = 0;
+	for (const s of segments) {
+		const len = s.t1 - s.t0;
+		if (s.kind === "cpu" && s.category === "profiler") overhead_ms += len;
+		else if (s.kind === "cpu") {
+			cpu_ms += len;
+			phase_row(s.phase).cpu_ms += len;
+			let m = phase_owners.get(s.phase);
+			if (!m) phase_owners.set(s.phase, m = /* @__PURE__ */ new Map());
+			const open = s.label.lastIndexOf(" (");
+			const who = s.category === "dependency" && open !== -1 && s.label.endsWith(")") ? s.label.slice(open + 2, -1) : s.category === "node" ? "node core" : s.label;
+			m.set(who, (m.get(who) ?? 0) + len);
+		} else if (s.kind === "wait") {
+			wait_ms += len;
+			phase_row(s.phase).wait_ms += len;
+		} else gap_ms += len;
+	}
+	const phases = [...phase_map.values()].map((r) => {
+		const top = [...phase_owners.get(r.phase) ?? []].filter(([, ms]) => ms >= r.cpu_ms * .1 && ms >= .5).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([label, ms]) => ({
+			label,
+			ms: round2(ms)
+		}));
+		return {
+			phase: r.phase,
+			cpu_ms: round2(r.cpu_ms),
+			wait_ms: round2(r.wait_ms),
+			...top.length ? { top } : {}
+		};
+	}).sort((x, y) => y.cpu_ms + y.wait_ms - (x.cpu_ms + x.wait_ms));
+	const timeline = {
+		window_ms: round2(window_ms),
+		cpu_ms: round2(cpu_ms),
+		wait_ms: round2(wait_ms),
+		gap_ms: round2(gap_ms),
+		overhead_ms: round2(overhead_ms),
+		segments,
+		phases,
+		parallelizable: []
+	};
+	timeline.parallelizable = find_parallelizable(timeline);
+	timeline.awaits = await_graph(input, w0, w1);
+	const inner = {};
+	for (const [owner, m] of inner_ms) {
+		const list = [...m].map(([k, ms]) => {
+			const z = k.indexOf("\0");
+			return {
+				name: k.slice(0, z),
+				file: k.slice(z + 1),
+				ms: round2(ms)
+			};
+		}).filter((f) => f.ms > 0).sort((a, b) => b.ms - a.ms).slice(0, 12);
+		if (list.some((f) => f.name !== owner)) inner[owner] = list;
+	}
+	if (Object.keys(inner).length) timeline.inner = inner;
+	for (const [file, list] of lane_waits) {
+		list.sort((x, y) => x[0] - y[0]);
+		let total = 0;
+		let cur = null;
+		for (const [a, b] of list) if (cur && a <= cur[1]) cur[1] = Math.max(cur[1], b);
+		else {
+			if (cur) total += cur[1] - cur[0];
+			cur = [a, b];
+		}
+		if (cur) total += cur[1] - cur[0];
+		lanes.get(file).wait_ms = total;
+	}
+	const lane_list = [...lanes.values()].filter((l) => Number.isFinite(l.t0)).map((l) => ({
+		...l,
+		t0: round2(l.t0),
+		t1: round2(l.t1),
+		cpu_ms: round2(l.cpu_ms),
+		wait_ms: round2(l.wait_ms)
+	})).sort((x, y) => x.t0 - y.t0);
+	if (lane_list.length) {
+		timeline.lanes = lane_list;
+		const page = lane_list.find((l) => l.level === "page");
+		const layout = lane_list.filter((l) => l.level === "layout" && l.kind === page?.kind && l.t1 - l.t0 >= 2 && (l.wait_ms > 0 || l.cpu_ms >= 2)).sort((x, y) => y.t1 - x.t1)[0];
+		if (page && layout && (page.awaited_parent || page.t0 >= layout.t1 - .25)) timeline.chain = {
+			layout: layout.file,
+			page: page.file,
+			serial_ms: round2(Math.max(0, Math.min(layout.t1, page.t0) - layout.t0)),
+			explicit: page.awaited_parent
+		};
+	}
+	return timeline;
+}
+/**
+* THE CAUSALITY GRAPH: every call (net + I/O primitives, not spans) as a box on the render's
+* clock, laid into lanes so overlapping calls sit on different rows, and an edge from a call to
+* the one that started right after it finished while nothing else was in flight — that start
+* waited for that end, and `at` is the line that did the waiting. Edges are what the
+* "awaits in a row" callouts are made of; the graph shows them with the exact await site.
+*/
+function await_graph(input, w0, w1) {
+	const calls = input.calls.filter((c) => c.kind !== "span" && c.ms >= 0 && c.start <= w1 && c.start + c.ms >= w0).map((c) => ({
+		c,
+		t0: round2(Math.max(c.start, w0) - w0),
+		t1: round2(Math.min(c.start + c.ms, w1) - w0)
+	})).sort((x, y) => x.t0 - y.t0 || x.t1 - y.t1).slice(0, 200);
+	const lane_end = [];
+	const nodes = calls.map(({ c, t0, t1 }) => {
+		let lane = lane_end.findIndex((e) => e <= t0);
+		if (lane === -1) lane = lane_end.push(0) - 1;
+		lane_end[lane] = t1;
+		return {
+			label: c.label,
+			t0,
+			t1,
+			lane,
+			kind: c.kind,
+			...c.caller ? { caller: c.caller } : {}
+		};
+	});
+	const edges = [];
+	for (let i = 0; i < calls.length; i++) {
+		const cur = calls[i];
+		let prev = null;
+		for (let j = 0; j < i; j++) {
+			const p = calls[j];
+			if (p.t1 <= cur.t0 + .05 && cur.t0 - p.t1 <= 5 && (!prev || p.t1 > prev.t1)) prev = p;
+		}
+		if (!prev) continue;
+		if (calls.some((o, j) => j !== i && o !== prev && o.t0 < cur.t0 - .05 && o.t1 > cur.t0 + .05)) continue;
+		edges.push({
+			from: prev.c.label,
+			to: cur.c.label,
+			gap_ms: round2(Math.max(0, cur.t0 - prev.t1)),
+			...cur.c.caller ? { at: cur.c.caller } : {},
+			...cur.c.callers && cur.c.callers.length > 1 ? { callers: cur.c.callers } : {}
+		});
+	}
+	return {
+		nodes,
+		edges
+	};
+}
+/** A wait's call, told apart from another call of the same label by its whole duration (the label
+*  groups by route — `GET /api?name=a` and `?name=b` read the same). A segment that is not one
+*  call's wait is its label. */
+function call_id(s) {
+	return s.kind === "wait" && s.calls?.length === 1 ? `${s.label}\0${s.calls[0].ms}` : s.label;
+}
+/**
+* Awaits in a row: consecutive single-call waits on DIFFERENT calls with little CPU between them —
+* 5 ms, or 5% of the chain's longest wait when that is more. Read off the COALESCED view
+* (`coalesce`), where a wait chopped by microtask slivers is one block again — on the raw segments
+* the same call reappearing after a sliver broke every chain. `at` indexes that view (the same one
+* the UI draws).
+*
+* (The allowance scales: between a 1 s timer and a 700 ms call, the CPU of the server answering the
+* page's own call to itself, or a collection, ran 3 to 9 ms run by run — the fixed 5 ms broke the
+* chain in some runs and not others, and a 2.2 s finding came and went between two profiles of the
+* same code. Next to waits that long, tens of ms of CPU are still nothing between.)
+*/
+function find_parallelizable(t) {
+	const view = coalesce(t);
+	const parallelizable = [];
+	let group = null;
+	const limit = () => group ? Math.max(5, Math.max(...group.lens) * .05) : 5;
+	const flush = () => {
+		if (group && group.at.length >= 2) {
+			const sum = group.lens.reduce((a, c) => a + c, 0);
+			const max = Math.max(...group.lens);
+			if (sum - max >= 1) parallelizable.push({
+				calls: group.labels,
+				ms: round2(sum),
+				save_ms: round2(sum - max),
+				at: group.at
+			});
+		}
+		group = null;
+	};
+	let cpu_between = 0;
+	for (let i = 0; i < view.length; i++) {
+		const s = view[i];
+		if (s.kind === "wait" && s.calls && s.calls.length === 1) {
+			const label = s.calls[0].label;
+			const id = call_id(s);
+			if (group && group.ids[group.ids.length - 1] === id && cpu_between <= limit()) {
+				group.lens[group.lens.length - 1] += s.t1 - s.t0;
+				cpu_between = 0;
+				continue;
+			}
+			if (group && (cpu_between > limit() || group.ids.includes(id))) flush();
+			if (!group) group = {
+				at: [],
+				labels: [],
+				ids: [],
+				lens: []
+			};
+			group.at.push(i);
+			group.labels.push(label);
+			group.ids.push(id);
+			group.lens.push(s.t1 - s.t0);
+			cpu_between = 0;
+		} else if (s.kind === "cpu") {
+			cpu_between += s.t1 - s.t0;
+			if (cpu_between > limit()) flush();
+		} else if (s.kind === "wait") flush();
+	}
+	flush();
+	return parallelizable;
+}
+function coalesce(t, min_ms = Math.max(t.window_ms * .012, 1)) {
+	const out = [];
+	let small = [];
+	const len = (s) => s.t1 - s.t0;
+	const same = (a, b) => a.kind === b.kind && a.label === b.label && a.within === b.within && call_id(a) === call_id(b);
+	const fold = (list) => {
+		const by = /* @__PURE__ */ new Map();
+		const kind_ms = {
+			cpu: 0,
+			wait: 0,
+			gap: 0
+		};
+		for (const s of list) {
+			const k = s.kind + "\0" + s.label;
+			const e = by.get(k) ?? {
+				label: s.label,
+				kind: s.kind,
+				ms: 0,
+				seg: s
+			};
+			e.ms += len(s);
+			by.set(k, e);
+			kind_ms[s.kind] += len(s);
+		}
+		const inside = [...by.values()].sort((a, b) => b.ms - a.ms);
+		const kind = Object.entries(kind_ms).sort((a, b) => b[1] - a[1])[0][0];
+		const top = inside.find((i) => i.kind === kind) ?? inside[0];
+		const phases = /* @__PURE__ */ new Map();
+		for (const s of list) phases.set(s.phase, (phases.get(s.phase) ?? 0) + len(s));
+		const phase = [...phases.entries()].sort((a, b) => b[1] - a[1])[0][0];
+		const withins = /* @__PURE__ */ new Map();
+		for (const s of list) withins.set(s.within, (withins.get(s.within) ?? 0) + len(s));
+		const within = [...withins.entries()].sort((a, b) => b[1] - a[1])[0][0];
+		const others = inside.filter((i) => i.kind === kind).length - 1;
+		return {
+			t0: list[0].t0,
+			t1: list[list.length - 1].t1,
+			kind,
+			label: list.length === 1 ? top.label : `mostly ${top.label}${others > 0 ? ` (+${others} more)` : ""}`,
+			detail: list.length === 1 ? top.seg.detail : void 0,
+			file: top.seg.file,
+			category: top.seg.category,
+			phase,
+			calls: kind === "wait" ? top.seg.calls : void 0,
+			within,
+			parts: list.length,
+			inside: list.length === 1 ? void 0 : inside.map(({ label, kind, ms }) => ({
+				label,
+				kind,
+				ms: Math.round(ms * 100) / 100
+			}))
+		};
+	};
+	const flush_small = () => {
+		if (!small.length) return;
+		const total = small.reduce((s, x) => s + len(x), 0);
+		const last = out[out.length - 1];
+		if (last && total < min_ms && small.every((s) => s.kind !== "wait" || same(s, last))) {
+			last.t1 = small[small.length - 1].t1;
+			last.parts += small.length;
+		} else out.push(fold(small));
+		small = [];
+	};
+	for (const s of t.segments) if (len(s) >= min_ms) {
+		const last = out[out.length - 1];
+		if (last && same(s, last) && small.every((x) => len(x) < min_ms)) {
+			last.t1 = s.t1;
+			last.parts += small.length + 1;
+			small = [];
+			continue;
+		}
+		const total = small.reduce((a, x) => a + len(x), 0);
+		if (small.length && !last && total < min_ms) {
+			out.push({
+				...s,
+				t0: small[0].t0,
+				parts: small.length + 1
+			});
+			small = [];
+			continue;
+		}
+		flush_small();
+		out.push({
+			...s,
+			parts: 1
+		});
+	} else small.push(s);
+	flush_small();
+	return out;
+}
+/** A net call's timeline label: `GET host/path` (query dropped, long paths cut). */
+function label_call(method, url) {
+	try {
+		const u = new URL(url);
+		const p = u.pathname.length > 40 ? u.pathname.slice(0, 37) + "…" : u.pathname;
+		return `${method} ${u.host}${p}`;
+	} catch {
+		return `${method} ${url.length > 48 ? url.slice(0, 45) + "…" : url}`;
+	}
+}
+/** The steps worth listing: every coalesced segment at or above `min_pct` of the window, in time
+*  order (`i` indexes the coalesced list). */
+function chain_steps(t, min_pct = 2, max = 14) {
+	const rows = coalesce(t).map((seg, i) => ({
+		i,
+		seg,
+		ms: round2(seg.t1 - seg.t0),
+		pct: (seg.t1 - seg.t0) / t.window_ms * 100
+	})).filter((r) => r.pct >= min_pct);
+	if (rows.length <= max) return rows;
+	return rows.sort((a, b) => b.ms - a.ms).slice(0, max).sort((a, b) => a.i - b.i);
+}
+export { PHASE_LABEL, await_graph, build_timeline, chain_steps, coalesce, find_parallelizable, label_call, load_lane_of, owner_of_stack, phase_of_frame, phase_of_stack };