@ogygia/devtools 0.0.0 → 0.11.1

package/dist/profiler/drill.js

@@ -0,0 +1,553 @@
+import { PHASE_LABEL, load_lane_of } from "./timeline.js";
+// src/profiler/drill.ts
+/** `lib/x.ts:42` or `lib/x.ts:42:7` → the file and the line; undefined when `at` names no line */
+function at_line(at) {
+	const parts = at.split(":");
+	const num = (s) => !!s && s.length > 0 && [...s].every((c) => c >= "0" && c <= "9");
+	let n = parts.length;
+	if (n >= 3 && num(parts[n - 1]) && num(parts[n - 2])) n--;
+	if (n < 2 || !num(parts[n - 1])) return void 0;
+	return {
+		file: parts.slice(0, n - 1).join(":"),
+		line: Number(parts[n - 1])
+	};
+}
+const r2 = (n) => Math.round(n * 100) / 100;
+/** children kept per level; the rest fold into one row */
+const KEEP = 6;
+/** a child under this share of its parent folds too */
+const FOLD_SHARE = .02;
+/** more rows past KEEP while the fold would hide over this share of the parent */
+const KEEP_MAX = 12;
+const FOLD_MAX_HIDDEN = .1;
+/** `GET host/api/product/P12` → `GET host/api/product/:id`: one row per endpoint, not per id */
+function call_group(label) {
+	const sp = label.indexOf(" ");
+	if (sp === -1) return label;
+	const method = label.slice(0, sp);
+	const rest = label.slice(sp + 1);
+	const q = rest.indexOf("?");
+	const path = (q === -1 ? rest : rest.slice(0, q)).split("/");
+	for (let i = 1; i < path.length; i++) {
+		const s = path[i];
+		let digits = 0;
+		for (let k = 0; k < s.length; k++) if (s.charCodeAt(k) >= 48 && s.charCodeAt(k) <= 57) digits++;
+		const version = s.length >= 2 && s[0] === "v" && digits === s.length - 1;
+		if (s && !version && (digits === s.length || digits >= 2 && digits / s.length >= .2 || digits > 0 && digits / s.length >= .5 || s.length >= 24)) path[i] = ":id";
+	}
+	return `${method} ${path.join("/")}`;
+}
+/** a library owner (`render2 (@acme/ui)`) reads as its package; Node's own as `node core` */
+function owner_group(s) {
+	const open = s.label.lastIndexOf(" (");
+	if (s.category === "dependency" && open !== -1 && s.label.endsWith(")")) return s.label.slice(open + 2, -1);
+	if (s.category === "node") return "node core";
+	return s.label;
+}
+/** `GET host/path`: an HTTP call (a timer, a file read or a span has no method word) */
+function is_http(label) {
+	const sp = label.indexOf(" ");
+	if (sp < 3 || sp > 7) return false;
+	for (let i = 0; i < sp; i++) {
+		const c = label.charCodeAt(i);
+		if (c < 65 || c > 90) return false;
+	}
+	return true;
+}
+/** the first pending resource with the line that queued it: `Immediate from x.ts:52` → `x.ts:52` */
+function pending_place(pending) {
+	for (const p of pending ?? []) {
+		const at = p.indexOf(" from ");
+		if (at !== -1) return p.slice(at + 6);
+	}
+}
+/** a package row's function: `render2 (@acme/ui)` → `render2`, `node core: writev` → `writev` */
+function sub_fn(label) {
+	if (label.startsWith("node core: ")) return label.slice(11);
+	const open = label.lastIndexOf(" (");
+	return open !== -1 && label.endsWith(")") ? label.slice(0, open) : label;
+}
+/** a place in the framework, a package or the server bundle: never "your line" */
+function foreign_place(caller) {
+	return caller.includes("node_modules/") || caller.includes("output/server/") || caller.includes("@sveltejs/") || caller.includes("node:") || caller.includes(".svelte-kit/");
+}
+/** the line of yours at the top of a call's path — the outermost of your frames before the
+*  framework's (`svc` ← `currentUser` ← `load:70` → `load:70`): where your code asked for it */
+function outer_of(caller, callers) {
+	if (!callers || callers[0] !== caller) return void 0;
+	let top;
+	for (let i = 1; i < callers.length && !foreign_place(callers[i]); i++) {
+		if (callers[i].includes("hooks.server.")) break;
+		top = callers[i];
+	}
+	return top && top !== caller ? top : void 0;
+}
+function fold(nodes, parent_ms) {
+	nodes.sort((a, b) => b.ms - a.ms);
+	const keep = [];
+	let rest_ms = 0;
+	let rest_n = 0;
+	let left = nodes.reduce((s, n) => s + n.ms, 0);
+	for (const n of nodes) if ((keep.length < KEEP || keep.length < KEEP_MAX && left > parent_ms * FOLD_MAX_HIDDEN) && n.ms >= parent_ms * FOLD_SHARE) {
+		keep.push(n);
+		left -= n.ms;
+	} else {
+		rest_ms += n.ms;
+		rest_n++;
+	}
+	if (rest_n) keep.push({
+		label: `${rest_n} more`,
+		ms: r2(rest_ms),
+		kind: "more",
+		children: nodes.filter((n) => !keep.includes(n))
+	});
+	return keep;
+}
+/** `src/lib/ds.ts:17` → its folders and file, and the line */
+function split_place(at) {
+	const colon = at.lastIndexOf(":");
+	return {
+		parts: (colon === -1 ? at : at.slice(0, colon)).split("/").filter(Boolean),
+		line: colon === -1 ? "" : at.slice(colon + 1)
+	};
+}
+/** the same file when the shorter path is the tail of the longer one: a report spells one file
+*  `src/lib/…`, `lib/…` or absolute */
+function same_file(a, b) {
+	const n = Math.min(a.length, b.length);
+	for (let i = 1; i <= n; i++) if (a[a.length - i] !== b[b.length - i]) return false;
+	return n > 0;
+}
+/** Tag every row with the patterns found on its line (a site's own line, or a caller line it names),
+*  and a row with lines under it with theirs too. */
+function tag_why(root, patterns) {
+	const at_line = /* @__PURE__ */ new Map();
+	const add = (file, line, kind) => {
+		const { parts } = split_place(file);
+		const k = `${parts[parts.length - 1]}:${line}`;
+		(at_line.get(k) ?? at_line.set(k, []).get(k)).push({
+			parts,
+			kind
+		});
+	};
+	for (const p of patterns) for (const s of p.sites) {
+		add(s.path || s.file, s.line, p.kind);
+		for (const v of s.via ?? []) add(v.path || v.file, v.line, p.kind);
+	}
+	if (!at_line.size) return;
+	const kinds_at = (at) => {
+		const { parts, line } = split_place(at);
+		return (at_line.get(`${parts[parts.length - 1]}:${line}`) ?? []).filter((e) => same_file(e.parts, parts)).map((e) => e.kind);
+	};
+	const walk = (n) => {
+		const kinds = new Set(n.at && n.kind !== "lane" ? kinds_at(n.at) : []);
+		for (const c of n.children ?? []) for (const k of walk(c)) kinds.add(k);
+		if (kinds.size && n.kind !== "render" && n.kind !== "phase") n.why = [...kinds];
+		return kinds;
+	};
+	walk(root);
+}
+/**
+* WHAT A ROW WAS FOR: the page-data keys its lines feed. A wait or a computation whose line (its
+* own, or one of the lines under it) is among a key's source lines in its load (lineage +
+* `key_sources`) fills that key. When every key it fills is read by nothing, the row's whole time
+* bought nothing.
+*/
+function tag_fills(root, keys) {
+	const sourced = keys.filter((k) => k.from && k.lines?.length).map((k) => ({
+		...k,
+		parts: split_place(k.from).parts,
+		set: new Set(k.lines),
+		named: new Set(k.names ?? [])
+	}));
+	if (!sourced.length) return;
+	const fills_at = (at) => {
+		const { parts, line } = split_place(at);
+		const n = Number(line);
+		return sourced.filter((k) => k.set.has(n) && same_file(k.parts, parts));
+	};
+	const walk = (n, lane) => {
+		const lines = [];
+		const lines_under = (m) => (m.children ?? []).flatMap((c) => c.kind === "line" ? [c] : c.kind === "more" ? lines_under(c) : []);
+		const collect = (m) => {
+			const under = lines_under(m);
+			if (m.at && (m.kind === "line" || m.kind === "cpu") && !under.length) lines.push(m.at);
+			for (const c of under) collect(c);
+		};
+		collect(n);
+		if (n.kind === "wait" || n.kind === "cpu") {
+			const found = /* @__PURE__ */ new Map();
+			let unexplained = false;
+			for (const at of lines) {
+				const ks = fills_at(at);
+				if (!ks.length) unexplained = true;
+				for (const k of ks) found.set(k.key, (found.get(k.key) ?? false) || k.verdict !== "unread");
+			}
+			if (unexplained) found.clear();
+			if (!found.size && n.kind === "cpu" && lane) {
+				for (const k of sourced) if (k.named.has(n.label) && same_file(k.parts, lane)) found.set(k.key, (found.get(k.key) ?? false) || k.verdict !== "unread");
+			}
+			if (found.size) n.fills = [...found].map(([key, read]) => ({
+				key,
+				read
+			}));
+		}
+		if (n.kind === "line" && n.at && !n.fills) {
+			const found = /* @__PURE__ */ new Map();
+			for (const k of fills_at(n.at)) found.set(k.key, (found.get(k.key) ?? false) || k.verdict !== "unread");
+			if (found.size) n.fills = [...found].map(([key, read]) => ({
+				key,
+				read
+			}));
+		}
+		const here = n.kind === "lane" && n.at ? split_place(n.at + ":0").parts : lane;
+		for (const c of n.children ?? []) walk(c, here);
+	};
+	walk(root);
+}
+/** THE WORK FOR NOTHING: the rows of one render whose every key is unread (the topmost such row on
+*  each path, so nothing counts twice), biggest first */
+function unread_rows(root) {
+	const out = [];
+	const walk = (n) => {
+		if (n.fills?.length && n.fills.every((f) => !f.read)) {
+			out.push({
+				label: n.label,
+				ms: n.ms,
+				kind: n.kind,
+				keys: n.fills.map((f) => f.key),
+				...n.at ? { at: n.at } : {}
+			});
+			return;
+		}
+		for (const c of n.children ?? []) walk(c);
+	};
+	if (root) walk(root);
+	return out.sort((a, b) => b.ms - a.ms);
+}
+/** `/abs/app/src/lib/x.ts` → `src/lib/x.ts`, `…/node_modules/pkg/a.js` → `pkg/a.js` */
+function short_path(p) {
+	const nm = p.lastIndexOf("node_modules/");
+	if (nm !== -1) return p.slice(nm + 13);
+	const src = p.lastIndexOf("/src/");
+	return src !== -1 ? p.slice(src + 1) : p;
+}
+function build_drill(tl, ledger = [], patterns = [], gc_makers = [], renders_of = /* @__PURE__ */ new Map(), owner_runs = {}, cold_owners = /* @__PURE__ */ new Map(), wait_runs = {}) {
+	const root = build_tree(tl, ledger, gc_makers);
+	if (!root) return root;
+	if (Object.keys(owner_runs).length || Object.keys(wait_runs).length) {
+		const rows = /* @__PURE__ */ new Map();
+		const collect = (n, parent_kind) => {
+			if ((n.kind === "cpu" || n.kind === "wait") && (parent_kind === "phase" || parent_kind === "lane" || parent_kind === "more")) {
+				const k = n.kind + "\0" + n.label;
+				(rows.get(k) ?? rows.set(k, []).get(k)).push(n);
+			}
+			for (const c of n.children ?? []) collect(c, n.kind);
+		};
+		collect(root, "render");
+		for (const [k, list] of rows) {
+			const label = k.slice(k.indexOf("\0") + 1);
+			if (list[0].kind === "wait") {
+				const w = wait_runs[label];
+				if (list.length === 1 && w && w.length >= 2) list[0].runs = [r2(Math.min(...w)), r2(Math.max(...w))];
+				continue;
+			}
+			const per = owner_runs[label];
+			if (list.length !== 1 || !per || per.length < 2) continue;
+			list[0].runs = [Math.min(...per), Math.max(...per)];
+			const cold = cold_owners.get(label);
+			if (cold !== void 0 && cold >= list[0].runs[1] * 1.5 && cold - list[0].runs[1] >= 5) list[0].cold = r2(cold);
+		}
+	}
+	if (patterns.length) tag_why(root, patterns);
+	const per_item = new Set(patterns.filter((p) => p.kind === "render-per-item").flatMap((p) => p.sites.map((s) => s.fn_name ?? "")));
+	const walk = (n) => {
+		if (n.kind === "cpu") {
+			const count = renders_of.get(n.label);
+			if (count && count > 1) n.calls = count;
+			if (per_item.has(n.label) && !n.why?.includes("render-per-item")) n.why = [...n.why ?? [], "render-per-item"];
+		}
+		for (const c of n.children ?? []) walk(c);
+	};
+	walk(root);
+	return root;
+}
+function build_tree(tl, ledger, gc_makers) {
+	const gc_lines = (() => {
+		const by = /* @__PURE__ */ new Map();
+		const hot_line = (path, line) => {
+			const rows = ledger.filter((l) => l.path === path && l.fn && (l.fn.endsWith(`${path}:${line}`) || l.line === line));
+			return (rows.find((l) => l.mem_in_fn) ?? rows.sort((a, b) => b.cpu_ms - a.cpu_ms)[0])?.line ?? line;
+		};
+		for (const m of gc_makers) {
+			if (m.gc_ms <= 0) continue;
+			const at = m.at ? `${short_path(m.at.path)}:${hot_line(m.at.path, m.at.line)}` : m.url ? `${short_path(m.url)}:${m.line}` : m.name;
+			by.set(at, (by.get(at) ?? 0) + m.gc_ms);
+		}
+		const total = [...by.values()].reduce((s, v) => s + v, 0);
+		return total > 0 ? [...by].map(([at, ms]) => ({
+			at,
+			share: ms / total
+		})) : [];
+	})();
+	const segs = tl.segments.filter((s) => s.t1 > s.t0 && s.category !== "profiler");
+	if (!segs.length) return void 0;
+	const phases = /* @__PURE__ */ new Map();
+	const lane_of = (texts) => {
+		for (const t of texts) {
+			const l = t ? load_lane_of(t) : null;
+			if (l) return l.file;
+		}
+	};
+	/** A CALL'S OWN CLOCK, once per call (a call spans several segments): until its headers, then its
+	*  body; of the headers wait, what the other side's Server-Timing claims. Their entries often
+	*  nest (`render 30` holding `db 21`), so past the wait itself the largest is their whole. */
+	const add_split = (g, c) => {
+		if (!is_http(c.label)) return;
+		const id = c.label + "\0" + (c.caller ?? "") + "\0" + c.ms;
+		if ((g.split_seen ??= /* @__PURE__ */ new Set()).has(id)) return;
+		g.split_seen.add(id);
+		const body = Math.min(c.body_ms ?? 0, c.ms);
+		const headers = c.ms - body;
+		const sp = g.split ??= {
+			network_ms: 0,
+			body_ms: 0,
+			calls: 0
+		};
+		sp.calls++;
+		sp.body_ms += body;
+		const t = c.timings?.filter((x) => x.ms > 0) ?? [];
+		if (t.length) {
+			const sum = t.reduce((s, x) => s + x.ms, 0);
+			const largest = Math.max(...t.map((x) => x.ms));
+			const theirs = Math.min(headers, sum > headers ? largest : sum);
+			sp.theirs_ms = (sp.theirs_ms ?? 0) + theirs;
+			sp.told = (sp.told ?? 0) + 1;
+			sp.network_ms += headers - theirs;
+			for (const x of t) (g.told_by ??= /* @__PURE__ */ new Map()).set(x.desc ?? x.name, (g.told_by.get(x.desc ?? x.name) ?? 0) + x.ms);
+		} else sp.network_ms += headers;
+	};
+	for (const s of segs) {
+		const len = s.t1 - s.t0;
+		const ph = phases.get(s.phase) ?? phases.set(s.phase, /* @__PURE__ */ new Map()).get(s.phase);
+		const in_load = s.phase === "load";
+		if (s.kind === "wait" && s.calls?.length) {
+			const each = len / s.calls.length;
+			const keyed = s.calls.map((c) => {
+				const lane = in_load ? lane_of([...c.callers ?? [], c.caller]) : void 0;
+				return {
+					c,
+					lane,
+					key: "w\0" + call_group(c.label) + "\0" + (lane ?? "")
+				};
+			});
+			const alone = keyed.every((k) => k.key === keyed[0].key);
+			for (const { c, lane, key } of keyed) {
+				const g = ph.get(key) ?? ph.set(key, {
+					node: {
+						label: call_group(c.label),
+						ms: 0,
+						kind: "wait",
+						calls: 0,
+						alone: 0
+					},
+					callers: /* @__PURE__ */ new Map(),
+					...lane ? { lane } : {}
+				}).get(key);
+				g.node.ms += each;
+				if (alone) g.node.alone += each;
+				add_split(g, c);
+				if (c.caller) {
+					g.callers.set(c.caller, (g.callers.get(c.caller) ?? 0) + each);
+					const outer = outer_of(c.caller, c.callers);
+					if (outer) {
+						const m = (g.outers ??= /* @__PURE__ */ new Map()).get(c.caller) ?? g.outers.set(c.caller, /* @__PURE__ */ new Map()).get(c.caller);
+						m.set(outer, (m.get(outer) ?? 0) + each);
+					}
+				}
+			}
+			continue;
+		}
+		const label = s.kind === "cpu" ? owner_group(s) : s.label;
+		const file = s.kind === "gap" ? pending_place(s.pending) : s.file;
+		const lane = in_load ? s.lane ?? lane_of([file]) : void 0;
+		const key = s.kind[0] + "\0" + label + "\0" + (lane ?? "");
+		const g = ph.get(key) ?? ph.set(key, {
+			node: {
+				label,
+				ms: 0,
+				kind: s.kind
+			},
+			...file ? { file } : {},
+			callers: /* @__PURE__ */ new Map(),
+			lib: s.kind === "cpu" && s.category === "dependency",
+			...lane ? { lane } : {}
+		}).get(key);
+		g.node.ms += len;
+		if (label !== s.label) {
+			const fn = sub_fn(s.label);
+			const f = (g.fns ??= /* @__PURE__ */ new Map()).get(fn) ?? g.fns.set(fn, {
+				ms: 0,
+				...s.file ? { file: s.file } : {}
+			}).get(fn);
+			f.ms += len;
+		}
+	}
+	const seen = /* @__PURE__ */ new Map();
+	for (const s of segs) for (const c of s.calls ?? []) {
+		const lane = s.phase === "load" ? lane_of([...c.callers ?? [], c.caller]) : void 0;
+		const k = s.phase + "\0" + call_group(c.label) + "\0" + (lane ?? "");
+		(seen.get(k) ?? seen.set(k, /* @__PURE__ */ new Set()).get(k)).add(c.label + "\0" + (c.caller ?? "") + "\0" + c.ms);
+	}
+	/** the ledger rows of one function. A function's ledger key is `name /abs/path`, an arrow's
+	*  `(anonymous) /abs/path:line`, a component's `C:Name` */
+	const rows_of = (f) => {
+		const own = split_place(f.file);
+		const anon = f.name.startsWith("(");
+		return ledger.filter((l) => {
+			if (!l.fn || l.cpu_ms <= 0) return false;
+			if (l.fn === "C:" + f.name) return true;
+			const sp = anon ? l.fn.indexOf(") ") + 1 : l.fn.lastIndexOf(" ");
+			if (sp <= 0 || l.fn.slice(0, sp) !== f.name) return false;
+			const def = anon ? split_place(l.fn.slice(sp + 1)) : {
+				parts: split_place(l.fn.slice(sp + 1) + ":").parts,
+				line: own.line
+			};
+			return def.line === own.line && same_file(def.parts, own.parts);
+		});
+	};
+	/** a function's time as its lines' shares: split by its ledger rows, else its own start line */
+	const shares_of = (f, weight, into) => {
+		const rows = rows_of(f);
+		const total = rows.reduce((s, l) => s + l.cpu_ms, 0);
+		if (total > 0) for (const l of rows) into.set(`${l.file}:${l.line}`, (into.get(`${l.file}:${l.line}`) ?? 0) + weight * l.cpu_ms / total);
+		else into.set(f.file, (into.get(f.file) ?? 0) + weight);
+	};
+	const lines_of = (fn) => {
+		const into = /* @__PURE__ */ new Map();
+		const inner = tl.inner?.[fn];
+		const inner_total = inner?.reduce((s, f) => s + f.ms, 0) ?? 0;
+		if (inner && inner_total > 0) for (const f of inner) shares_of(f, f.ms / inner_total, into);
+		else {
+			const rows = ledger.filter((l) => l.fn && (l.fn.split(" ")[0] === fn || l.fn === "C:" + fn) && l.cpu_ms > 0);
+			const total = rows.reduce((s, l) => s + l.cpu_ms, 0);
+			for (const l of rows) into.set(`${l.file}:${l.line}`, (into.get(`${l.file}:${l.line}`) ?? 0) + l.cpu_ms / total);
+		}
+		return [...into].map(([at, share]) => ({
+			at,
+			share
+		}));
+	};
+	const callers_of_pkg = (pkg) => {
+		const rows = ledger.map((l) => ({
+			l,
+			ms: (l.libs ?? []).filter((x) => x.pkg === pkg).reduce((s, x) => s + x.ms, 0)
+		})).filter((r) => r.ms > 0);
+		const total = rows.reduce((s, r) => s + r.ms, 0);
+		return total > 0 ? rows.map((r) => ({
+			at: `${r.l.file}:${r.l.line}`,
+			share: r.ms / total
+		})) : [];
+	};
+	/** `fetchStock (routes/x.ts:25)` → `routes/x.ts:25`: the place, without the function name */
+	const place = (caller) => {
+		const open = caller.lastIndexOf("(");
+		return open !== -1 && caller.endsWith(")") ? caller.slice(open + 1, -1) : caller;
+	};
+	const phase_nodes = [];
+	for (const [phase, groups] of phases) {
+		const kids = [];
+		const lane_kids = /* @__PURE__ */ new Map();
+		for (const [key, g] of groups) {
+			const n = g.node;
+			n.ms = r2(n.ms);
+			if (n.alone !== void 0) n.alone = r2(n.alone);
+			if (n.kind === "wait") {
+				n.calls = seen.get(phase + "\0" + n.label + "\0" + (g.lane ?? ""))?.size ?? 0;
+				if (g.split) {
+					const sp = g.split;
+					const top = g.told_by ? [...g.told_by].sort((x, y) => y[1] - x[1]).slice(0, 3).map(([name, ms]) => ({
+						name,
+						ms: r2(ms)
+					})) : void 0;
+					n.split = {
+						calls: sp.calls,
+						...sp.theirs_ms !== void 0 ? {
+							theirs_ms: r2(sp.theirs_ms),
+							told: sp.told
+						} : {},
+						network_ms: r2(sp.network_ms),
+						body_ms: r2(sp.body_ms),
+						...top?.length ? { top } : {}
+					};
+				}
+				const callers = [...g.callers].map(([caller, ms]) => {
+					const line = {
+						label: caller,
+						ms: r2(ms),
+						kind: "line",
+						at: place(caller)
+					};
+					const outers = g.outers?.get(caller);
+					const covered = outers ? [...outers.values()].reduce((s, v) => s + v, 0) : 0;
+					if (outers?.size && covered >= ms * .99) line.children = fold([...outers].map(([o, oms]) => ({
+						label: o,
+						ms: r2(oms),
+						kind: "line",
+						at: place(o)
+					})), line.ms);
+					return line;
+				});
+				if (callers.length) n.children = fold(callers, n.ms);
+			} else if (n.kind === "cpu") {
+				if (g.file) n.at = g.file;
+				const pkg_lines = g.lib ? callers_of_pkg(n.label) : [];
+				const gc = n.label === "garbage collection" ? gc_lines : [];
+				const lines = gc.length ? gc : pkg_lines.length ? pkg_lines : key.startsWith("c\0") && !g.lib ? lines_of(n.label) : [];
+				if (pkg_lines.length) delete n.at;
+				if (lines.length > 1) n.children = fold(lines.map((l) => ({
+					label: l.at,
+					ms: r2(n.ms * l.share),
+					kind: "line",
+					at: l.at
+				})), n.ms);
+				else {
+					if (lines.length === 1) n.at = lines[0].at;
+					if (g.fns && g.fns.size > 1) n.children = fold([...g.fns].map(([fn, f]) => ({
+						label: fn,
+						ms: r2(f.ms),
+						kind: "cpu",
+						...f.file ? { at: f.file } : {}
+					})), n.ms);
+				}
+			} else if (n.kind === "gap" && g.file) n.at = g.file;
+			if (g.lane) (lane_kids.get(g.lane) ?? lane_kids.set(g.lane, []).get(g.lane)).push(n);
+			else kids.push(n);
+		}
+		for (const [lane, rows] of lane_kids) {
+			const ms = r2(rows.reduce((s, k) => s + k.ms, 0));
+			kids.push({
+				label: lane,
+				ms,
+				kind: "lane",
+				at: lane,
+				children: fold(rows, ms)
+			});
+		}
+		const ms = r2(kids.reduce((s, k) => s + k.ms, 0));
+		phase_nodes.push({
+			label: PHASE_LABEL[phase] ?? phase,
+			ms,
+			kind: "phase",
+			children: fold(kids, ms)
+		});
+	}
+	const total = r2(phase_nodes.reduce((s, p) => s + p.ms, 0));
+	return {
+		label: "render",
+		ms: total,
+		kind: "render",
+		children: fold(phase_nodes, total)
+	};
+}
+export { at_line, build_drill, call_group, tag_fills, unread_rows };

package/dist/profiler/embedded-maps.d.ts

@@ -0,0 +1,37 @@
+/**
+ * THE MAPS THE BUILD WROTE INTO THE CODE (vite/profiler-maps.ts), read back: the module map and
+ * every server chunk's sourcemap, by chunk file relative to the server output. Loaded once, on the
+ * first resolve, from `virtual:ogygia/profiler-maps` — a dynamic import, so it ships with whatever
+ * the adapter ships and costs a request nothing. Null outside a profiler-on server build.
+ */
+export interface EmbeddedMaps {
+  modules: Record<string, [number, number, string][]>;
+  maps: Record<string, string>;
+  /** a build without maps: the app's source files by module id (`src/lib/x.ts`) */
+  sources?: Record<string, string>;
+  /** ...and the text of the chunks they are in, by chunk file */
+  chunks?: Record<string, string>;
+}
+export declare function load_embedded_maps(): Promise<EmbeddedMaps | null>;
+/** the maps once loaded (synchronous readers: the module map lookup), else null */
+export declare const embedded_maps: () => EmbeddedMaps | null;
+/** a script's key in the payload: its path under the server output (`chunks/format.js`), whether it
+ *  runs from Kit's output itself (a host that copies it, like Vercel's) or is named as a map source
+ *  by an adapter that re-bundled it (adapter-node: `…/.svelte-kit/output/server/chunks/x.js`) */
+export declare function embedded_key(path: string): string | undefined;
+/** the build's map of a chunk, by its path: the text the build wrote, or undefined */
+export declare function embedded_map_of(path: string): string | undefined;
+/** a built chunk's text the build carried (a build without maps, for a host that re-bundled it) */
+export declare function embedded_chunk(path: string): string | undefined;
+/**
+ * AN APP SOURCE FILE'S TEXT FROM THE MAPS (`sourcesContent`): the only copy on a deployed host, where
+ * `src/` is not there. What the source-reading checks (a load read line by line, a component's
+ * `{#each}`, a late island's data) read when the file is not on disk. `file` is src-relative or has
+ * a leading `src/`; undefined when no map carries it.
+ */
+export declare function embedded_source(file: string): string | undefined;
+/** every app source file the maps carry, src-relative */
+export declare function embedded_files(): string[];
+/** the module at a chunk line, from the embedded module map (a host that dropped the file beside the
+ *  chunks) */
+export declare function embedded_module_at(path: string, line: number): string | undefined;