@ogygia/devtools 0.0.0-stage → 0.11.0

package/dist/profiler/analyze.js

@@ -0,0 +1,1941 @@
+import { build_timeline, owner_of_stack } from "./timeline.js";
+import { handle_parts } from "./source-scan.js";
+import { another_routes_file, route_dirs, route_file_of } from "./route-files.js";
+import { app_relative } from "./app-path.js";
+// src/profiler/analyze.ts
+/**
+* Analysis of a raw V8 .cpuprofile into readable aggregates.
+*
+* Framework-blind: understands Svelte/SvelteKit/Vite conventions when it sees
+* them (a `.svelte` URL, a `node_modules` segment) but works on any Node
+* server profile. No imports from the rest of ogygia — this file plus
+* report.ts/index.ts can be dropped into any SvelteKit project.
+*/
+/** script id → its url, learned from every CPU profile: V8's heap sampler leaves `url` empty for a
+*  script made from a string (the dev server's modules: `new AsyncFunction(code)` with a
+*  `//# sourceURL`), where the CPU profiler names it. Ids hold for the life of the process */
+const script_urls = /* @__PURE__ */ new Map();
+function learn_script_urls(profile) {
+	for (const n of profile?.nodes ?? []) {
+		const f = n.callFrame;
+		if (f.scriptId && f.url && !script_urls.has(f.scriptId)) script_urls.set(f.scriptId, f.url);
+	}
+}
+/** a frame with its url filled from its script id when the profile left it empty */
+function with_script_url(f) {
+	if (f.url || !f.scriptId) return f;
+	const url = script_urls.get(f.scriptId);
+	return url ? {
+		...f,
+		url
+	} : f;
+}
+const MAX_INDEX_SAMPLES = 2e4;
+/**
+* The stack index of one window (see `StackIndex`). `frame_of` gives a node's resolved frame,
+* `parent_of` its parent node; only nodes on a sampled stack inside the window enter the table.
+*/
+function build_stack_index(profile, frame_of, parent_of, perf_start, window) {
+	const samples = profile.samples ?? [];
+	const deltas = profile.timeDeltas ?? [];
+	if (!samples.length || !deltas.length) return void 0;
+	const frames = [];
+	const index_of = /* @__PURE__ */ new Map();
+	const ref = (id) => {
+		const hit = index_of.get(id);
+		if (hit !== void 0) return hit;
+		const f = frame_of(id);
+		const name = f.name;
+		if (f.category === "idle" || name === "(root)" || name === "(program)") {
+			index_of.set(id, -1);
+			return -1;
+		}
+		const pid = parent_of(id);
+		const p = pid === void 0 ? -1 : ref(pid);
+		const i = frames.length;
+		const url = short_path(f.url);
+		frames.push({
+			n: name,
+			...url ? { f: f.line > 0 ? `${url}:${f.line}` : url } : {},
+			c: f.category,
+			p
+		});
+		index_of.set(id, i);
+		return i;
+	};
+	const t = [];
+	const d = [];
+	const leaf = [];
+	let raw = 0;
+	let t_us = profile.startTime;
+	const w0 = window.start;
+	const w1 = window.end;
+	let last_leaf = NaN;
+	for (let i = 0; i < samples.length; i++) {
+		const delta = deltas[i] ?? 0;
+		t_us += delta;
+		if (delta <= 0) continue;
+		const at = perf_start + (t_us - profile.startTime) / 1e3;
+		if (at < w0) continue;
+		if (at > w1) break;
+		raw++;
+		const l = ref(samples[i]);
+		const ms = delta / 1e3;
+		if (l === last_leaf && t.length) {
+			d[d.length - 1] += ms;
+			continue;
+		}
+		last_leaf = l;
+		t.push(Math.max(0, at - w0 - ms));
+		d.push(ms);
+		leaf.push(l);
+	}
+	if (!t.length) return void 0;
+	if (t.length > MAX_INDEX_SAMPLES) {
+		const k = Math.ceil(t.length / MAX_INDEX_SAMPLES);
+		const t2 = [];
+		const d2 = [];
+		const l2 = [];
+		for (let i = 0; i < t.length; i += k) {
+			let sum = 0;
+			for (let j = i; j < Math.min(i + k, t.length); j++) sum += d[j];
+			t2.push(t[i]);
+			d2.push(sum);
+			l2.push(leaf[i]);
+		}
+		return {
+			frames,
+			t: t2.map(round2),
+			d: d2.map(round3),
+			leaf: l2,
+			raw,
+			window_ms: round2(w1 - w0)
+		};
+	}
+	return {
+		frames,
+		t: t.map(round2),
+		d: d.map(round3),
+		leaf,
+		raw,
+		window_ms: round2(w1 - w0)
+	};
+}
+const round3 = (n) => Math.round(n * 1e3) / 1e3;
+const component_name_re = /^[A-Z][A-Za-z0-9_$]*$/;
+const ROUTE_FILE_FN_RE = /^_(page|layout|error)$/;
+const SVELTE_BASENAME_RE = /([^/\\]+)\.svelte$/;
+/** A rune module SOURCE (`state.svelte.ts`) compiles no component. Only the `.ts` spelling is
+*  excluded outright: Kit names a route's BUILT entry chunk `_page.svelte.js`, and that is the
+*  bundled component — a `.svelte.js` rune module's class stays a candidate and falls to app
+*  code through the structural confirmation (nothing under it calls Svelte's server internals). */
+const SVELTE_MODULE_EXT_RE = /\.svelte\.ts$/;
+/** A bundler's collision suffix (`Header$1`, `Header$2`): two components with one basename in
+*  one chunk. Stripped for naming and matching — the frame is still the `Header` component. */
+const BUNDLER_SUFFIX_RE = /\$\d+$/;
+/** ogygia's own files: the `ogygia` package and the `@ogygia/core` it re-exports (a checkout's
+*  `packages/core`), source or build */
+const OGYGIA_OWN_RE = /\/(?:ogygia|@ogygia\/core|packages\/core)\/(?:src|dist)\//;
+/** ogygia's own wrapper components. The app's Vite compiles them into the app's chunks (a
+*  `.svelte` from a dependency is compiled by the consumer), so in a production profile they sit
+*  at a chunk URL with the component's name and no `.svelte` path to vouch for them — and every
+*  island page renders `Region` once per island, so it would top the Components table. */
+const OGYGIA_WRAPPERS = /* @__PURE__ */ new Set([
+	"Region",
+	"SlotBoundary",
+	"LakeBoundary",
+	"OgygiaBoundary",
+	"NestedProvider",
+	"LiveHost",
+	"KeepHost",
+	"Blocks",
+	"RawHtml",
+	"Provide",
+	"ClientBindingStub"
+]);
+const NON_IDENT_G = /[^a-zA-Z0-9_$]/g;
+/** A frame name with the bundler's `$N` collision suffix removed. */
+function strip_bundler_suffix(name) {
+	return name.replace(BUNDLER_SUFFIX_RE, "");
+}
+/** SvelteKit endpoint/handler exports — capitalized, but not components. */
+const handler_names = /* @__PURE__ */ new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS",
+	"fallback"
+]);
+/** Svelte derives the SSR function name from the filename: Header.svelte →
+* Header, +page.svelte → _page. Helper closures inside a component keep the
+* file's url but not a component-shaped name. A component-SHAPED name is only
+* a candidate: `analyze` confirms it structurally (see `confirm_components`). */
+const is_component_name = (name) => !handler_names.has(name) && (component_name_re.test(strip_bundler_suffix(name)) || ROUTE_FILE_FN_RE.test(name));
+function component_name_from_file(url) {
+	const m = SVELTE_BASENAME_RE.exec(url);
+	if (!m) return void 0;
+	const base = m[1];
+	if (base.startsWith("+")) {
+		const kind = base.slice(1);
+		return kind === "page" || kind === "layout" || kind === "error" ? `_${kind}` : void 0;
+	}
+	let name = base.replace(NON_IDENT_G, "_");
+	if (/^\d/.test(name)) name = "_" + name;
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function clean_url(url) {
+	if (url.startsWith("file://")) try {
+		return decodeURIComponent(url.slice(7));
+	} catch {
+		return url.slice(7);
+	}
+	return url;
+}
+const SCHEME_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+const WIN_ABS_RE = /^[A-Za-z]:[\\/]/;
+/**
+* A sourcemap's `sources` are relative to the MAP FILE (`../../src/lib/Foo.svelte` from
+* `.svelte-kit/output/server/chunks/x.js.map`). Joined onto the chunk's own directory they become
+* the real path — absolute when V8 reported the chunk absolutely (a `vite preview`, adapter-node),
+* which is what lets a row open in an editor. Pure string work (no `node:path`): this module runs
+* anywhere. An absolute source, a URL, or a chunk with no directory passes through unchanged.
+*/
+function join_source(chunk, source) {
+	if (!source || source.startsWith("/") || WIN_ABS_RE.test(source) || SCHEME_RE.test(source)) return source;
+	const dir = clean_url(chunk).replace(/\\/g, "/");
+	const slash = dir.lastIndexOf("/");
+	if (slash === -1) return source;
+	const out = dir.slice(0, slash).split("/");
+	for (const seg of source.split("/")) {
+		if (seg === "" || seg === ".") continue;
+		if (seg === "..") {
+			if (out.length > 1 || out.length === 1 && out[0] !== "") out.pop();
+			continue;
+		}
+		out.push(seg);
+	}
+	return out.join("/");
+}
+/** ogygia under the name its users know: `@ogygia/core` is what the `ogygia` package re-exports */
+const ogygia_named = (pkg) => pkg === "@ogygia/core" ? "ogygia" : pkg;
+function package_of(url) {
+	const i = url.lastIndexOf("node_modules/");
+	if (i === -1) return void 0;
+	const parts = url.slice(i + 13).split("/");
+	if (parts[0] === ".vite" && parts[2]) return ogygia_named(prebundled_package(parts[2]));
+	if (parts[0]?.startsWith("@") && parts[1]) return ogygia_named(`${parts[0]}/${parts[1]}`);
+	return parts[0] || void 0;
+}
+/** `svelte_internal_server.js` → `svelte`, `@acme_ui_components.js` → `@acme/ui` */
+function prebundled_package(file) {
+	let base = file.split("?")[0];
+	if (base.endsWith(".mjs")) base = base.slice(0, -4);
+	else if (base.endsWith(".js")) base = base.slice(0, -3);
+	const bits = base.split("_");
+	if (base.startsWith("@")) return bits[1] ? `${bits[0]}/${bits[1]}` : void 0;
+	return bits[0] || void 0;
+}
+function categorize(frame) {
+	const name = frame.functionName;
+	const url = clean_url(frame.url);
+	if (!url) {
+		if (name === "(garbage collector)") return { category: "gc" };
+		if (name === "(idle)") return { category: "idle" };
+		if (name === "(root)" || name === "(program)" || name.startsWith("(")) return { category: "v8" };
+	}
+	if (url.startsWith("node:inspector")) return { category: "profiler" };
+	if (url.startsWith("node:internal/async_hooks")) return { category: "profiler" };
+	if (url.startsWith("node:")) return { category: "node" };
+	if (url.startsWith("wasm://")) return { category: "node" };
+	if (url.includes("/ogygia/src/profiler/") || url.includes("/ogygia/dist/profiler/") || url.includes("/devtools/src/profiler/") || url.includes("/devtools/dist/profiler/")) return { category: "profiler" };
+	const pkg = package_of(url);
+	if (pkg === "svelte") return {
+		category: "svelte",
+		pkg
+	};
+	if (pkg) return {
+		category: "dependency",
+		pkg
+	};
+	if (OGYGIA_OWN_RE.test(url)) return {
+		category: "dependency",
+		pkg: "ogygia"
+	};
+	if (url.endsWith(".svelte")) {
+		const own = component_name_from_file(url);
+		const stripped = strip_bundler_suffix(name);
+		return { category: own !== void 0 && (stripped === own || ROUTE_FILE_FN_RE.test(stripped)) ? "component" : "app" };
+	}
+	if (url) {
+		if (!SVELTE_MODULE_EXT_RE.test(url) && is_component_name(name)) return OGYGIA_WRAPPERS.has(strip_bundler_suffix(name)) ? {
+			category: "dependency",
+			pkg: "ogygia"
+		} : { category: "component" };
+		return { category: "app" };
+	}
+	if (name && !name.startsWith("(")) return { category: "node" };
+	return { category: "unknown" };
+}
+const b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** char code → its base64 digit, -1 for a character outside the alphabet */
+const B64_DIGIT = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
+for (let i = 0; i < 64; i++) B64_DIGIT[b64.charCodeAt(i)] = i;
+/** the fields of one packed segment, in order */
+const SEG = 5;
+/** Decode one VLQ-encoded sourcemap `mappings` string, packed. */
+function decode_packed(mappings) {
+	let segs = new Int32Array(Math.max(64, (mappings.length >> 2) * SEG));
+	let n = 0;
+	const starts = [0];
+	let col = 0, src = 0, src_line = 0, src_col = 0, name_idx = 0;
+	let i = 0;
+	const len = mappings.length;
+	const seg = [
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	outer: while (i < len) {
+		const ch = mappings.charCodeAt(i);
+		if (ch === 59) {
+			starts.push(n);
+			col = 0;
+			i++;
+			continue;
+		}
+		if (ch === 44) {
+			i++;
+			continue;
+		}
+		let count = 0;
+		while (i < len) {
+			let value = 0, shift = 0, digit;
+			do {
+				const c = mappings.charCodeAt(i);
+				digit = c < 128 ? B64_DIGIT[c] : -1;
+				if (digit < 0) break outer;
+				i++;
+				value += (digit & 31) << shift;
+				shift += 5;
+			} while (digit & 32);
+			if (count < SEG) seg[count] = value & 1 ? -(value >>> 1) : value >>> 1;
+			count++;
+			const next = i < len ? mappings.charCodeAt(i) : 0;
+			if (next === 44 || next === 59 || i >= len) break;
+		}
+		col += seg[0];
+		if (count >= 4) {
+			src += seg[1];
+			src_line += seg[2];
+			src_col += seg[3];
+			if (count >= 5) name_idx += seg[4];
+			if ((n + 1) * SEG > segs.length) {
+				const grown = new Int32Array(segs.length * 2);
+				grown.set(segs);
+				segs = grown;
+			}
+			const at = n * SEG;
+			segs[at] = col;
+			segs[at + 1] = src;
+			segs[at + 2] = src_line;
+			segs[at + 3] = count >= 5 ? name_idx : -1;
+			segs[at + 4] = src_col;
+			n++;
+		}
+	}
+	starts.push(n);
+	return {
+		segs: segs.slice(0, n * SEG),
+		starts: Int32Array.from(starts)
+	};
+}
+/** Decode one VLQ-encoded sourcemap `mappings` string into per-line column maps (the readable
+*  form of {@link decode_packed}) */
+function decode_mappings(mappings) {
+	const { segs, starts } = decode_packed(mappings);
+	const lines = [];
+	for (let l = 0; l + 1 < starts.length; l++) {
+		const cols = [];
+		for (let s = starts[l]; s < starts[l + 1]; s++) {
+			const at = s * SEG;
+			cols.push([
+				segs[at],
+				segs[at + 1],
+				segs[at + 2],
+				segs[at + 3],
+				segs[at + 4]
+			]);
+		}
+		lines.push({ cols });
+	}
+	return lines;
+}
+/**
+* Resolves generated positions back to source via `.map` files sitting next to
+* the chunks. `read` abstracts fs so this module stays platform-free. Holds a
+* cache and a `hit` flag, so it is a class rather than a closure.
+*/
+/** words that sit where a name would but are not one (`if (`, `return (`, `= function`, `=> {`) */
+const RESERVED_NAME_RE = /^(?:if|for|while|switch|return|catch|await|typeof|function|new|else|do|in|of|throw|yield|void|delete|case|with|async)$/;
+var SourceMapResolver = class {
+	/** whether any lookup succeeded */
+	hit = false;
+	/** whether any line of a chunk WITHOUT a map was matched to its source by text */
+	text_hit = false;
+	#read;
+	#cache = /* @__PURE__ */ new Map();
+	#src_cache = /* @__PURE__ */ new Map();
+	/** the ORIGINAL source text a map carries (`sourcesContent`), keyed by the same resolved path
+	*  `resolve()` returns — the code exactly as it was when the bundle was built, and the only copy
+	*  on a deployed host, where the source files are not on disk */
+	#embedded = /* @__PURE__ */ new Map();
+	/** A CHUNK WITH NO MAP (a build that turned sourcemaps off): the module at a chunk line
+	*  (1-based), from the build's module map. `text`: the app's own script module, whose lines are
+	*  found by their text (`#by_text`); else a package's or the framework's module, named by its
+	*  path with no line (what it IS decides how it is filed: Kit's `fetch` wrapper is not the app's
+	*  caller). Undefined = leave the line as the chunk's */
+	#module_at;
+	/** every script may have a map, not only built `.js` (the dev server) */
+	#any_ext;
+	constructor(read, module_at, opts = {}) {
+		this.#read = read;
+		this.#module_at = module_at;
+		this.#any_ext = !!opts.any_ext;
+	}
+	/** The lines of an original source file: the map's embedded copy first (exact, and present on a
+	*  deployed host), else the file on this machine. `null` when neither exists. */
+	#lines_of(source) {
+		let lines = this.#src_cache.get(source);
+		if (lines === void 0) {
+			const text = this.#embedded.get(source) ?? this.#read(source);
+			lines = text === void 0 ? null : text.split("\n");
+			this.#src_cache.set(source, lines);
+		}
+		return lines;
+	}
+	/** every original source a loaded map carries a copy of */
+	embedded_sources() {
+		return this.#embedded.keys();
+	}
+	/** Lines `from`..`to` (1-based, inclusive) of an original source, untrimmed — the source view.
+	*  Undefined when the source is not available (no embedded copy, not on this machine). */
+	source_lines(source, from, to) {
+		const all = this.#lines_of(source);
+		if (!all) return void 0;
+		const a = Math.max(1, from);
+		const b = Math.min(all.length, to);
+		if (b < a) return void 0;
+		return {
+			start: a,
+			lines: all.slice(a - 1, b)
+		};
+	}
+	/** The original source LINE at a mapped position, trimmed and cut: what an anonymous callback
+	*  IS (`tags.map(async (tag) => {`), for a label a name cannot give. Undefined when the source
+	*  is not available. */
+	line_at_source(source, line, max = 56) {
+		const row = this.#lines_of(source)?.[line - 1]?.trim();
+		if (!row) return void 0;
+		return row.length > max ? row.slice(0, max - 1) + "…" : row;
+	}
+	/** The function name written in the ORIGINAL source at a mapped position (1-based line and
+	*  column), for a frame whose map carries no name there: `function foo(`, a method `foo(` /
+	*  `#foo(` / `async foo(`, or an arrow assigned to `foo` (`const foo = () =>`, `foo: () =>`).
+	*  Undefined for a true anonymous callback. Reads the source through the same `read`. */
+	name_at_source(source, line, column) {
+		const row = this.#lines_of(source)?.[line - 1];
+		if (row === void 0) return void 0;
+		const col = Math.max(0, Math.min(column - 1, row.length));
+		const after = row.slice(col);
+		const before = row.slice(0, col);
+		const tries = [
+			[/^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/, after],
+			[/^(?:static\s+)?(?:async\s+)?(?:(?:get|set)\s+)?(#?[A-Za-z_$][\w$]*)\s*\(/, after],
+			[/(?:const|let|var|,)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?$/, before],
+			[/(#?[A-Za-z_$][\w$]*)\s*[:=]\s*(?:async\s*)?$/, before],
+			[/(?:static\s+)?(?:async\s+)?(#?[A-Za-z_$][\w$]*)\s*\(\s*$/, before]
+		];
+		for (const [re, text] of tries) {
+			const name = re.exec(text)?.[1];
+			if (name && !RESERVED_NAME_RE.test(name)) return name;
+		}
+	}
+	/** map a generated (url, line0, col0) to the original file/line/column (1-based), plus the
+	* original identifier at that position when the map carries `names` — that's
+	* what turns a bundled `(anonymous)` back into a real name */
+	/** generated file → its lines, for the text match below */
+	#gen_lines = /* @__PURE__ */ new Map();
+	/**
+	* A MAP WITH NO MAPPINGS: one source named, not one segment. A plugin that returns code without a
+	* map breaks the chain and the bundler writes an empty map (SvelteKit's remote-function step
+	* appends its registration and does exactly this: every `.remote.ts` call site read as its
+	* built chunk). Most lines survive a build word for word, so the generated line's text is found
+	* in the one source; a line that changed (types stripped, two lines joined) takes the nearest
+	* matching line above it. Only inside that source's `//#region <file>` when the bundler marked
+	* one: the imports and the appended code around it are not the source's lines. Undefined when
+	* nothing matches.
+	*/
+	#by_text(path, source, line) {
+		let gen = this.#gen_lines.get(path);
+		if (gen === void 0) {
+			const text = this.#read(path);
+			gen = text === void 0 ? null : text.split("\n");
+			this.#gen_lines.set(path, gen);
+		}
+		const src = this.#lines_of(source);
+		if (!gen || !src) return void 0;
+		for (let i = line; i >= 0; i--) {
+			const t = gen[i]?.trim() ?? "";
+			if (t.startsWith("//#endregion") && i < line) return void 0;
+			if (t.startsWith("//#region ")) {
+				const file = t.slice(10).trim();
+				if (!source.endsWith(file)) return void 0;
+				break;
+			}
+		}
+		const norm = (s) => {
+			let out = "";
+			let quote = "";
+			for (let i = 0; i < s.length; i++) {
+				const ch = s[i];
+				if (quote) {
+					if (ch === "\\") {
+						out += ch + (s[i + 1] ?? "");
+						i++;
+						continue;
+					}
+					if (ch === quote) quote = "";
+				} else if (ch === "\"" || ch === "'" || ch === "`") quote = ch;
+				else if (ch === "/" && s[i + 1] === "/") break;
+				if (ch === " " || ch === "	") continue;
+				out += ch === "\"" || ch === "`" ? "'" : ch;
+			}
+			if (out.startsWith("export")) out = out.slice(6);
+			for (const kw of [
+				"const",
+				"let",
+				"var"
+			]) if (out.startsWith(kw)) return out.slice(kw.length);
+			return out;
+		};
+		const normed = src.map(norm);
+		const decl = declared_function(gen[line] ?? "");
+		if (decl) {
+			const at = normed.findIndex((s) => s.includes(`function${decl}(`) || s.includes(`function${decl}<`) || s.startsWith(`${decl}=`) || s.startsWith(`${decl}:`));
+			if (at !== -1) return {
+				source,
+				line: at + 1,
+				column: 1,
+				text: true
+			};
+		}
+		for (let i = line, k = 0; i >= 0 && k <= 8; i--, k++) {
+			const raw = gen[i]?.trim() ?? "";
+			if (i < line && (raw.startsWith("//#region") || raw.startsWith("//#endregion"))) break;
+			const t = gen[i] ? norm(gen[i]) : "";
+			if (t.length < 6 || t.startsWith("//")) continue;
+			let at = normed.indexOf(t);
+			let wrapped = false;
+			if (at === -1 && t.length >= 6) {
+				at = normed.findIndex((s) => s.length > t.length && s.startsWith(t));
+				wrapped = at !== -1;
+			}
+			if (at === -1 && i < line) {
+				const d = declared_function(gen[i] ?? "");
+				if (d) at = normed.findIndex((s) => s.includes(`function${d}(`) || s.startsWith(`${d}=`) || s.startsWith(`${d}:`));
+			}
+			if (at === -1) continue;
+			let open = 0;
+			let inside = i < line;
+			for (let j = i; j < line && inside; j++) {
+				open += bracket_balance(gen[j] ?? "");
+				if (open <= 0) inside = false;
+			}
+			const same = inside && (wrapped || bracket_balance(src[at]) <= 0);
+			if (wrapped && i < line && !same) continue;
+			const hit = same || i === line ? at + 1 : at + 1 + (line - i);
+			return hit <= src.length ? {
+				source,
+				line: hit,
+				column: 1,
+				text: true
+			} : void 0;
+		}
+		for (let i = line + 1; i <= line + 3 && i < gen.length; i++) {
+			const raw = gen[i]?.trim() ?? "";
+			if (raw.startsWith("//#endregion") || raw.startsWith("//#region")) break;
+			const t = norm(gen[i]);
+			if (t.length < 6 || t.startsWith("//")) continue;
+			const at = normed.indexOf(t);
+			if (at === -1) continue;
+			const hit = at + 1 - (i - line);
+			return hit >= 1 ? {
+				source,
+				line: hit,
+				column: 1,
+				text: true
+			} : void 0;
+		}
+	}
+	/**
+	* A LINE OF A FUNCTION MATCHED BY TEXT that matched nothing itself (a build without maps: the
+	* build wrote `void 0`, folded a declaration into the next line, or wrapped one statement over
+	* several lines). From the nearest line above it that did match, within the function: still
+	* inside that statement (its brackets not yet closed) → that statement's line; else as far
+	* below it as in the build. Else from the function's own line. 0-based lines in, 1-based out.
+	*/
+	text_nearby(url, line, fn_line) {
+		const path = clean_url(url);
+		for (let up = line - 1; up >= fn_line && up >= line - 8; up--) {
+			const near = this.resolve(url, up, 0);
+			if (!near?.text) continue;
+			const gen = this.#gen_lines.get(path);
+			let open = 0;
+			for (let i = up; i < line && gen; i++) open += bracket_balance(gen[i] ?? "");
+			return open > 0 ? near.line : near.line + (line - up);
+		}
+		const head = this.resolve(url, fn_line, 0);
+		return head?.text ? head.line + (line - fn_line) : void 0;
+	}
+	/** A FUNCTION whose own line carries no mapping (Svelte leaves `function _page($$renderer…) {`
+	*  unmapped and maps the body from its next line to `+page.svelte`): the first mapped line of
+	*  its body, a few lines down. V8 places a function at its definition, so without this every
+	*  route component read as its built chunk. Generated code (ogygia's virtual modules) is not a
+	*  source anyone opens, and is left unmapped. */
+	resolve_body(url, line) {
+		for (let k = 1; k <= 3; k++) {
+			const m = this.resolve(url, line + k, 0);
+			if (!m) continue;
+			return m.source.includes("virtual:") ? void 0 : m;
+		}
+	}
+	resolve(url, line, column) {
+		const first = this.#resolve_one(url, line, column);
+		if (!first) return first;
+		const s = first.source;
+		if (first.line > 0 && (s.endsWith(".js") || s.endsWith(".mjs") || s.endsWith(".cjs"))) {
+			const deeper = this.#resolve_one(s, first.line - 1, first.column - 1);
+			if (deeper) return {
+				...deeper,
+				...deeper.name || !first.name ? {} : { name: first.name },
+				...deeper.near_name || !first.near_name ? {} : { near_name: first.near_name }
+			};
+		}
+		return first;
+	}
+	#resolve_one(url, line, column) {
+		let path = clean_url(url);
+		const q = path.indexOf("?");
+		if (q !== -1) {
+			const base = path.slice(0, q);
+			if (base.endsWith(".js") || base.endsWith(".mjs") || base.endsWith(".cjs")) path = base;
+		}
+		if (!this.#any_ext && !path.endsWith(".js") && !path.endsWith(".mjs") && !path.endsWith(".cjs")) return;
+		let entry = this.#cache.get(path);
+		if (entry === void 0) {
+			entry = null;
+			const raw = this.#read(path + ".map");
+			if (raw) try {
+				const map = JSON.parse(raw);
+				if (typeof map.mappings === "string" && Array.isArray(map.sources)) {
+					const root = map.sourceRoot ?? "";
+					entry = {
+						lines: decode_packed(map.mappings),
+						sources: map.sources.map((s) => root + s),
+						names: Array.isArray(map.names) ? map.names : []
+					};
+					if (Array.isArray(map.sourcesContent)) for (let i = 0; i < entry.sources.length; i++) {
+						const text = map.sourcesContent[i];
+						if (typeof text === "string") {
+							const key = join_source(path, entry.sources[i]);
+							if (!this.#embedded.has(key)) this.#embedded.set(key, text);
+						}
+					}
+				}
+			} catch {}
+			this.#cache.set(path, entry);
+		}
+		if (!entry) {
+			const m = this.#module_at?.(path, line + 1);
+			if (!m) return void 0;
+			if (!m.text) return {
+				source: m.source,
+				line: 0,
+				column: 0
+			};
+			const r = this.#by_text(path, m.source, line);
+			if (r) this.text_hit = true;
+			return r;
+		}
+		const { segs, starts } = entry.lines;
+		if (entry.sources.length === 1 && segs.length === 0) return this.#by_text(path, join_source(path, entry.sources[0]), line);
+		if (line < 0 || line + 1 >= starts.length) return void 0;
+		const first = starts[line];
+		const end = starts[line + 1];
+		if (end <= first) return void 0;
+		let lo = first, hi = end - 1, best = -1;
+		while (lo <= hi) {
+			const mid = lo + hi >> 1;
+			if (segs[mid * SEG] <= column) {
+				best = mid;
+				lo = mid + 1;
+			} else hi = mid - 1;
+		}
+		const m = (best === -1 ? first : best) * SEG;
+		const m_src = segs[m + 1];
+		const m_line = segs[m + 2];
+		const m_name = segs[m + 3];
+		const source = entry.sources[m_src];
+		if (!source) return void 0;
+		this.hit = true;
+		let near_name;
+		if (m_name < 0 && best !== -1) for (let d = 1; d <= 4 && !near_name; d++) for (const i of [best + d, best - d]) {
+			if (i < first || i >= end) continue;
+			const s = i * SEG;
+			if (segs[s + 1] !== m_src || segs[s + 2] !== m_line || segs[s + 3] < 0 || Math.abs(segs[s] - column) > 32) continue;
+			near_name = entry.names[segs[s + 3]];
+			break;
+		}
+		return {
+			source: join_source(path, source),
+			line: m_line + 1,
+			column: segs[m + 4] + 1,
+			name: m_name >= 0 ? entry.names[m_name] : void 0,
+			...near_name ? { near_name } : {}
+		};
+	}
+};
+/** opened minus closed brackets on a line, outside strings and after no `//` comment */
+function bracket_balance(line) {
+	let n = 0;
+	let quote = "";
+	for (let i = 0; i < line.length; i++) {
+		const c = line[i];
+		if (quote) {
+			if (c === "\\") i++;
+			else if (c === quote) quote = "";
+			continue;
+		}
+		if (c === "\"" || c === "'" || c === "`") quote = c;
+		else if (c === "/" && line[i + 1] === "/") break;
+		else if (c === "(" || c === "[" || c === "{") n++;
+		else if (c === ")" || c === "]" || c === "}") n--;
+	}
+	return n;
+}
+/** the function a built line declares: `async function lookup(key) {` → `lookup`,
+*  `const load = async (e) => {` → `load`; undefined for any other line */
+function declared_function(line) {
+	const t = line.trim();
+	const word = (from) => {
+		let end = from;
+		while (end < t.length && /[\w$]/.test(t[end])) end++;
+		return end > from ? t.slice(from, end) : void 0;
+	};
+	const fn = t.indexOf("function");
+	if (fn !== -1) {
+		let i = fn + 8;
+		if (t[i] === "*") i++;
+		while (t[i] === " ") i++;
+		const name = word(i);
+		if (name && (t[i + name.length] === "(" || t[i + name.length] === " ")) return name;
+	}
+	for (const kw of [
+		"const ",
+		"let ",
+		"var "
+	]) {
+		if (!t.startsWith(kw)) continue;
+		const name = word(kw.length);
+		if (!name) return void 0;
+		const rest = t.slice(kw.length + name.length).trimStart();
+		return rest.startsWith("= (") || rest.startsWith("= async") || rest.startsWith("= function") ? name : void 0;
+	}
+}
+function sourcemap_resolver(read, module_at, opts) {
+	return new SourceMapResolver(read, module_at, opts);
+}
+function display_name(f) {
+	return f.functionName || "(anonymous)";
+}
+function short_path(url) {
+	const u = clean_url(url);
+	const nm = u.lastIndexOf("node_modules/");
+	if (nm !== -1) return u.slice(nm + 13);
+	const own = app_relative(u);
+	if (own !== void 0) return own;
+	const parts = u.split("/");
+	return parts.length > 4 ? parts.slice(-4).join("/") : u;
+}
+function analyze(profile, resolver, call_counts, timeline_input, rename, url_category) {
+	const calls_by_key = /* @__PURE__ */ new Map();
+	const by_id = /* @__PURE__ */ new Map();
+	for (const n of profile.nodes) by_id.set(n.id, n);
+	/** µs per tick: V8's line ticks are sample counts, the profile's mean delta turns them into time */
+	const samples_n = profile.samples?.length ?? 0;
+	const us_per_tick = samples_n > 0 ? (profile.endTime - profile.startTime) / samples_n : 0;
+	const self_us = /* @__PURE__ */ new Map();
+	const samples = profile.samples ?? [];
+	const deltas = profile.timeDeltas ?? [];
+	/** CPU set aside as another request's: a render of the same page another visitor overlapped (by
+	*  time, here), or a stack under another route's file (below) */
+	let other_us = 0;
+	const aside = timeline_input?.set_aside?.length ? timeline_input.set_aside : void 0;
+	if (samples.length && deltas.length) {
+		let t = profile.startTime;
+		for (let i = 0; i < samples.length; i++) {
+			const d = deltas[i] ?? 0;
+			t += d;
+			if (d <= 0) continue;
+			if (aside) {
+				const ms = timeline_input.perf_start + (t - profile.startTime) / 1e3;
+				if (aside.some((w) => ms >= w.start && ms <= w.end)) {
+					other_us += d;
+					continue;
+				}
+			}
+			self_us.set(samples[i], (self_us.get(samples[i]) ?? 0) + d);
+		}
+	} else {
+		const total = profile.endTime - profile.startTime;
+		let hits = 0;
+		for (const n of profile.nodes) hits += n.hitCount ?? 0;
+		const per_hit = hits > 0 ? total / hits : 0;
+		for (const n of profile.nodes) if (n.hitCount) self_us.set(n.id, n.hitCount * per_hit);
+	}
+	const resolved = /* @__PURE__ */ new Map();
+	/** per function key: source line → µs (the hot lines), filled from every node's positionTicks */
+	const line_us = /* @__PURE__ */ new Map();
+	/** per merged component key: the start line of each frame it merged → its self µs */
+	const comp_line_self = /* @__PURE__ */ new Map();
+	/** a node's line ticks, mapped to source lines when the frame was */
+	const line_ticks_of = /* @__PURE__ */ new Map();
+	for (const n of profile.nodes) {
+		const f = n.callFrame;
+		let url = f.url;
+		let line = f.lineNumber + 1;
+		let col = f.columnNumber + 1;
+		let name = display_name(f);
+		let cat = categorize(f);
+		let hinted = false;
+		if (url_category && f.url && (cat.category === "app" || cat.category === "component")) {
+			const h = url_category(f.url, f.functionName, f.lineNumber + 1);
+			if (typeof h === "string") cat = {
+				category: h,
+				...h === "dependency" ? { pkg: "ogygia" } : {}
+			};
+			else if (h) cat = {
+				category: h.category,
+				...h.pkg ? { pkg: h.pkg } : {}
+			};
+			hinted = !!h;
+		}
+		const mapping = resolver && (cat.category === "app" || cat.category === "component" || hinted || f.url.includes("/node_modules/.vite/"));
+		if (n.positionTicks?.length && us_per_tick > 0) {
+			let tick_n = 0;
+			for (const p of n.positionTicks) tick_n += p.ticks;
+			const own = self_us.get(n.id);
+			const per = own !== void 0 && tick_n > 0 ? own / tick_n : us_per_tick;
+			const ticks = [];
+			for (const p of n.positionTicks) {
+				const at = (mapping ? resolver.resolve(f.url, p.line - 1, 0) : void 0)?.line ?? (mapping ? resolver.text_nearby(f.url, p.line - 1, f.lineNumber) : void 0);
+				ticks.push({
+					line: at ?? p.line,
+					us: p.ticks * per
+				});
+			}
+			line_ticks_of.set(n.id, ticks);
+		}
+		if (mapping) {
+			const mapped = resolver.resolve(f.url, f.lineNumber, f.columnNumber) ?? resolver.resolve_body(f.url, f.lineNumber);
+			if (mapped) {
+				url = mapped.source;
+				line = mapped.line;
+				col = mapped.column;
+				if (!f.functionName && mapped.name) name = mapped.name;
+				else if (f.functionName && MINIFIED_NAME_RE.test(f.functionName)) {
+					const from_source = mapped.name ? void 0 : resolver.name_at_source(mapped.source, mapped.line, mapped.column);
+					const better = mapped.name ?? from_source ?? mapped.near_name;
+					if (better) name = better;
+				}
+				const recat = categorize({
+					...f,
+					functionName: name === "(anonymous)" ? "" : name,
+					url: mapped.source
+				});
+				if (!(hinted && recat.category === "app")) cat = recat;
+			}
+		}
+		if ((!f.functionName || f.functionName === "(anonymous)") && cat.category !== "dependency") {
+			const derived = component_name_from_file(clean_url(url));
+			if (derived) {
+				name = derived;
+				cat = { category: "component" };
+			}
+		}
+		if (cat.category === "component") name = strip_bundler_suffix(name);
+		if (rename) {
+			const better = rename(name, url, "frame");
+			if (better) {
+				name = better;
+				cat = { category: "component" };
+			}
+		}
+		resolved.set(n.id, {
+			key: "",
+			name,
+			url,
+			line,
+			col,
+			category: cat.category,
+			pkg: cat.pkg,
+			candidate: cat.category === "component" && !clean_url(url).endsWith(".svelte")
+		});
+	}
+	const parent_of = /* @__PURE__ */ new Map();
+	for (const n of profile.nodes) for (const c of n.children ?? []) parent_of.set(c, n.id);
+	const roots = profile.nodes.filter((n) => !parent_of.has(n.id));
+	for (const n of profile.nodes) {
+		const r = resolved.get(n.id);
+		if (!r || r.name !== "hash" || r.category !== "app") continue;
+		const up = parent_of.get(n.id);
+		if (up !== void 0 && resolved.get(up)?.name === "render_response") resolved.set(n.id, {
+			...r,
+			category: "dependency",
+			pkg: "@sveltejs/kit"
+		});
+	}
+	{
+		const verdict = /* @__PURE__ */ new Map();
+		const owned = (id) => {
+			const hit = verdict.get(id);
+			if (hit !== void 0) return hit;
+			const r = resolved.get(id);
+			let out = false;
+			if (r && (r.category === "node" || r.category === "v8")) {
+				const up = parent_of.get(id);
+				out = up !== void 0 && (resolved.get(up)?.category === "profiler" || owned(up));
+			}
+			verdict.set(id, out);
+			return out;
+		};
+		for (const n of profile.nodes) {
+			if (!owned(n.id)) continue;
+			const r = resolved.get(n.id);
+			resolved.set(n.id, {
+				...r,
+				category: "profiler",
+				key: "profiler:" + r.name + " " + r.url
+			});
+		}
+	}
+	const foreign_ids = /* @__PURE__ */ new Set();
+	if (timeline_input?.route) {
+		const route = timeline_input.route;
+		const foreign = (url) => another_routes_file(route, clean_url(url));
+		const walk = (id, under) => {
+			const r = resolved.get(id);
+			const here = under || !!r && foreign(r.url);
+			if (here) foreign_ids.add(id);
+			for (const c of by_id.get(id)?.children ?? []) walk(c, here);
+		};
+		for (const root of roots) walk(root.id, false);
+		for (const id of foreign_ids) {
+			other_us += self_us.get(id) ?? 0;
+			resolved.set(id, {
+				key: "(other requests)",
+				name: "(other requests)",
+				url: "",
+				line: 0,
+				col: 0,
+				category: "idle",
+				candidate: false
+			});
+			line_ticks_of.delete(id);
+		}
+	}
+	const svelte_below = /* @__PURE__ */ new Map();
+	const has_svelte_below = (node) => {
+		const cached = svelte_below.get(node.id);
+		if (cached !== void 0) return cached;
+		let below = false;
+		for (const c of node.children ?? []) {
+			const child = by_id.get(c);
+			if (!child) continue;
+			if (resolved.get(child.id).category === "svelte" || has_svelte_below(child)) below = true;
+		}
+		svelte_below.set(node.id, below);
+		return below;
+	};
+	const confirmed = /* @__PURE__ */ new Set();
+	for (const n of profile.nodes) {
+		const r = resolved.get(n.id);
+		if (r.category !== "component") continue;
+		if (!r.candidate || ROUTE_FILE_FN_RE.test(r.name) || has_svelte_below(n)) confirmed.add(r.name);
+	}
+	for (const n of profile.nodes) {
+		const r = resolved.get(n.id);
+		if (r.candidate && !confirmed.has(r.name)) r.category = "app";
+		else if (r.candidate && rename) {
+			const better = rename(r.name, r.url, "confirmed");
+			if (better) r.name = better;
+		}
+		r.key = r.category === "component" ? `C:${r.name}` : r.category === "profiler" ? `profiler:${r.name} ${r.url}` : r.name === "(anonymous)" && r.url ? `${r.name} ${r.url}:${r.line}` : `${r.name} ${r.url}`;
+		if (call_counts && !calls_by_key.has(r.key)) {
+			const f = n.callFrame;
+			const c = call_counts[(f.functionName || "") + "\0" + f.url] ?? (f.scriptId ? call_counts[(f.functionName || "") + "\0#" + f.scriptId] : void 0);
+			if (c && (r.category !== "component" || strip_bundler_suffix(f.functionName) === r.name)) calls_by_key.set(r.key, c);
+		}
+	}
+	const agg = /* @__PURE__ */ new Map();
+	const files = /* @__PURE__ */ new Map();
+	const buckets = /* @__PURE__ */ new Map();
+	let idle_us = 0;
+	let gc_us = 0;
+	let busy_us = 0;
+	let overhead_us = 0;
+	const path = /* @__PURE__ */ new Map();
+	/** inclusive µs per profile NODE (one node = one distinct call path) — what ranks the stacks */
+	const node_total_us = /* @__PURE__ */ new Map();
+	/** every node of a key, for the stacks below */
+	const nodes_by_key = /* @__PURE__ */ new Map();
+	const comp_stack = [];
+	const markup_us = /* @__PURE__ */ new Map();
+	const logic_us = /* @__PURE__ */ new Map();
+	const parent_us = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		const r = resolved.get(node.id);
+		const s = self_us.get(node.id) ?? 0;
+		const nested = (path.get(r.key) ?? 0) > 0;
+		path.set(r.key, (path.get(r.key) ?? 0) + 1);
+		if (!nested) {
+			const list = nodes_by_key.get(r.key);
+			if (list) list.push(node.id);
+			else nodes_by_key.set(r.key, [node.id]);
+		}
+		const is_comp = r.category === "component";
+		const parent_comp = comp_stack[comp_stack.length - 1];
+		if (is_comp) comp_stack.push(r.key);
+		const ticks = line_ticks_of.get(node.id);
+		if (ticks) {
+			let m = line_us.get(r.key);
+			if (!m) line_us.set(r.key, m = /* @__PURE__ */ new Map());
+			for (const t of ticks) m.set(t.line, (m.get(t.line) ?? 0) + t.us);
+		}
+		let stat = agg.get(r.key);
+		if (!stat) {
+			stat = {
+				key: r.key,
+				name: r.name,
+				url: short_path(r.url),
+				path: clean_url(r.url),
+				line: r.line,
+				col: r.col,
+				category: r.category,
+				pkg: r.pkg,
+				self_ms: 0,
+				total_ms: 0,
+				calls: calls_by_key.get(r.key)
+			};
+			agg.set(r.key, stat);
+		} else if (r.url.endsWith(".svelte") && !stat.url.endsWith(".svelte")) {
+			stat.url = short_path(r.url);
+			stat.path = clean_url(r.url);
+			stat.line = r.line;
+			stat.col = r.col;
+		}
+		if (is_comp && s > 0 && r.url.endsWith(".svelte")) {
+			let m = comp_line_self.get(r.key);
+			if (!m) comp_line_self.set(r.key, m = /* @__PURE__ */ new Map());
+			m.set(r.line, (m.get(r.line) ?? 0) + s);
+		}
+		if (s > 0) {
+			stat.self_ms += s / 1e3;
+			for (const [k, count] of path) if (count > 0) agg.get(k).total_ms += s / 1e3;
+			if (r.category === "idle") idle_us += s;
+			else if (r.category === "profiler") overhead_us += s;
+			else {
+				busy_us += s;
+				if (r.category === "gc") gc_us += s;
+			}
+			const near = comp_stack[comp_stack.length - 1];
+			if (near !== void 0) {
+				if (r.category === "svelte") markup_us.set(near, (markup_us.get(near) ?? 0) + s);
+				else if (r.category === "component" || r.category === "app" || r.category === "dependency" || r.category === "node") logic_us.set(near, (logic_us.get(near) ?? 0) + s);
+			}
+			if (r.url) {
+				const fk = short_path(r.url);
+				const fg = files.get(fk) ?? {
+					key: fk,
+					category: r.category,
+					self_ms: 0
+				};
+				fg.self_ms += s / 1e3;
+				files.set(fk, fg);
+			}
+			const bk = r.category === "dependency" || r.category === "svelte" ? r.pkg ?? "node_modules" : r.category === "component" || r.category === "app" ? "your code" : r.category === "node" ? "node core" : r.category === "gc" ? "garbage collection" : r.category === "idle" ? "idle (waiting)" : r.category === "profiler" ? "profiler overhead" : "v8 internals";
+			const bg = buckets.get(bk) ?? {
+				key: bk,
+				category: r.category,
+				self_ms: 0
+			};
+			bg.self_ms += s / 1e3;
+			buckets.set(bk, bg);
+		}
+		let total = s;
+		for (const c of node.children ?? []) {
+			const child = by_id.get(c);
+			if (child) total += visit(child);
+		}
+		node_total_us.set(node.id, total);
+		if (is_comp) {
+			comp_stack.pop();
+			if (!nested && parent_comp !== void 0 && parent_comp !== r.key) {
+				let m = parent_us.get(r.key);
+				if (!m) parent_us.set(r.key, m = /* @__PURE__ */ new Map());
+				m.set(parent_comp, (m.get(parent_comp) ?? 0) + total);
+			}
+		}
+		const left = path.get(r.key) - 1;
+		if (left === 0) path.delete(r.key);
+		else path.set(r.key, left);
+		return total;
+	};
+	for (const root of roots) visit(root);
+	const STACKS_PER_FN = 3;
+	const STACK_DEPTH = 14;
+	const frames_above = (id) => {
+		const frames = [];
+		let cur = parent_of.get(id);
+		while (cur !== void 0 && frames.length < STACK_DEPTH) {
+			const r = resolved.get(cur);
+			if (r.category === "profiler") {
+				while (frames.length && frames[frames.length - 1].c === "node" && frames[frames.length - 1].f.includes("async_local_storage")) frames.pop();
+				cur = parent_of.get(cur);
+				continue;
+			}
+			if (!r.name.startsWith("(")) {
+				const f = {
+					n: r.name,
+					f: r.url ? `${short_path(r.url)}:${r.line}` : "",
+					c: r.category
+				};
+				if (r.category === "component") {
+					let i = frames.length - 1;
+					while (i >= 0 && frames[i].c === "svelte") i--;
+					const prev = i >= 0 && frames[i].c === "component" && frames[i].n === r.name ? frames[i] : null;
+					if (prev) {
+						frames.length = i + 1;
+						const is_body = (x) => x.f.includes(".svelte:");
+						if (is_body(f) && (!is_body(prev) || r.line < Number(prev.f.split(":").pop()))) frames[i] = f;
+						cur = parent_of.get(cur);
+						continue;
+					}
+				}
+				frames.push(f);
+			}
+			cur = parent_of.get(cur);
+		}
+		return frames;
+	};
+	const stacks_of = (key) => {
+		const ids = nodes_by_key.get(key);
+		if (!ids) return [];
+		const by_path = /* @__PURE__ */ new Map();
+		for (const id of ids) {
+			const us = node_total_us.get(id) ?? 0;
+			if (us <= 0) continue;
+			const frames = frames_above(id);
+			const sig = frames.map((f) => f.n + "\0" + f.f).join("\n");
+			const seen = by_path.get(sig);
+			if (seen) seen.ms += us;
+			else by_path.set(sig, {
+				ms: us,
+				frames
+			});
+		}
+		return [...by_path.values()].sort((a, b) => b.ms - a.ms).slice(0, STACKS_PER_FN).map((s) => ({
+			ms: round2(s.ms / 1e3),
+			frames: s.frames
+		}));
+	};
+	/** a node's children as the app sees them: the profiler's own wrappers (`span`, `within`) and the
+	*  AsyncLocalStorage `run` right under them fold away, their children hung on the real caller
+	*  (their own self time is the profiler's, not drawn) */
+	const app_children = (node, under_profiler = false) => {
+		const out = [];
+		for (const c of node.children ?? []) {
+			const child = by_id.get(c);
+			if (!child) continue;
+			const r = resolved.get(child.id);
+			if (r.category === "profiler" || under_profiler && r.category === "node" && r.url.includes("async_local_storage")) out.push(...app_children(child, r.category === "profiler"));
+			else out.push(child);
+		}
+		return out;
+	};
+	const to_flame = (node) => {
+		const r = resolved.get(node.id);
+		const s = (self_us.get(node.id) ?? 0) / 1e3;
+		const children = [];
+		const merged = /* @__PURE__ */ new Map();
+		for (const child of app_children(node)) {
+			const fn = to_flame(child);
+			if (!fn) continue;
+			const existing = merged.get(fn.n + " " + fn.f);
+			if (existing) {
+				existing.t += fn.t;
+				existing.s += fn.s;
+				if (fn.ch) existing.ch = [...existing.ch ?? [], ...fn.ch];
+			} else merged.set(fn.n + " " + fn.f, fn);
+		}
+		for (const m of merged.values()) children.push(m);
+		children.sort((a, b) => b.t - a.t);
+		const total = s + children.reduce((acc, c) => acc + c.t, 0);
+		if (total < .005) return null;
+		const fn = {
+			n: r.name,
+			c: r.category,
+			t: round2(total),
+			s: round2(s),
+			f: r.url ? `${short_path(r.url)}:${r.line}` : ""
+		};
+		if (children.length) fn.ch = children;
+		return fn;
+	};
+	const flame_roots = [];
+	for (const root of roots) if (resolved.get(root.id).name === "(root)") for (const child of app_children(root)) {
+		const fn = to_flame(child);
+		if (fn && fn.c !== "idle") flame_roots.push(fn);
+	}
+	else {
+		const fn = to_flame(root);
+		if (fn && fn.c !== "idle") flame_roots.push(fn);
+	}
+	flame_roots.sort((a, b) => b.t - a.t);
+	const flame = {
+		n: "all",
+		c: "v8",
+		t: round2(flame_roots.reduce((a, c) => a + c.t, 0)),
+		s: 0,
+		f: "",
+		ch: flame_roots
+	};
+	const min_t = flame.t * .001;
+	const prune = (node) => {
+		if (!node.ch) return;
+		node.ch = node.ch.filter((c) => c.t >= min_t);
+		if (!node.ch.length) delete node.ch;
+		else for (const c of node.ch) prune(c);
+	};
+	prune(flame);
+	const deopt_by_key = /* @__PURE__ */ new Map();
+	for (const n of profile.nodes) {
+		if (!n.deoptReason) continue;
+		const r = resolved.get(n.id);
+		if (!r || r.category === "idle" || r.category === "gc" || r.category === "v8" || r.category === "profiler") continue;
+		let row = deopt_by_key.get(r.key);
+		if (!row) deopt_by_key.set(r.key, row = {
+			key: r.key,
+			name: r.name,
+			url: short_path(r.url),
+			line: r.line,
+			category: r.category,
+			reasons: {},
+			count: 0,
+			self_ms: 0
+		});
+		row.reasons[n.deoptReason] = (row.reasons[n.deoptReason] ?? 0) + 1;
+		row.count++;
+	}
+	for (const row of deopt_by_key.values()) row.self_ms = round2(agg.get(row.key)?.self_ms ?? 0);
+	const deopts = [...deopt_by_key.values()].sort((x, y) => y.self_ms - x.self_ms || y.count - x.count).slice(0, 40);
+	const overhead_functions = [...agg.values()].filter((f) => f.category === "profiler" && f.self_ms >= .01).sort((x, y) => y.self_ms - x.self_ms).slice(0, 10).map((f) => ({
+		name: f.name,
+		url: f.url,
+		line: f.line,
+		self_ms: round2(f.self_ms)
+	}));
+	const functions = [...agg.values()].filter((f) => (f.self_ms >= .01 || (f.category === "app" || f.category === "component") && f.total_ms >= .05) && f.category !== "idle" && f.category !== "gc" && f.category !== "v8" && f.category !== "profiler").sort((a, b) => b.self_ms - a.self_ms);
+	for (const [key, m] of comp_line_self) {
+		if (line_us.has(key)) continue;
+		const stat = agg.get(key);
+		if (!stat) continue;
+		let sum = 0;
+		let best = -1;
+		let best_us = 0;
+		for (const [line, us] of m) {
+			sum += us;
+			if (us > best_us) {
+				best_us = us;
+				best = line;
+			}
+		}
+		if (best > 0 && best_us >= sum / 2) stat.line = best;
+	}
+	const LINES_PER_FN = 8;
+	const lines_of = (key) => {
+		const m = line_us.get(key);
+		if (!m) return void 0;
+		const list = [...m].map(([line, us]) => ({
+			line,
+			ms: round2(us / 1e3)
+		})).filter((l) => l.ms > 0).sort((a, b) => b.ms - a.ms).slice(0, LINES_PER_FN);
+		return list.length ? list : void 0;
+	};
+	/** the code around a function's hot lines: the top three when they sit close together, else the
+	*  hottest with a little context — enough to recognise the line, never the whole file */
+	const src_of = (f) => {
+		if (!resolver || !f.path) return void 0;
+		const hot = (f.lines ?? []).slice(0, 3).map((l) => l.line);
+		if (!hot.length && f.line > 0) hot.push(f.line);
+		if (!hot.length) return void 0;
+		let a = Math.min(...hot) - 2;
+		let b = Math.max(...hot) + 2;
+		if (b - a > 16) {
+			a = hot[0] - 3;
+			b = hot[0] + 3;
+		}
+		return resolver.source_lines(f.path, a, b);
+	};
+	/** what a function called: every child of its outermost nodes, grouped by the child's key. A
+	*  child with the SAME key (recursion, a component's inner frame under its wrapper) is walked
+	*  through, so its children count as the caller's own. Pseudo frames never show. */
+	const CALLEES_PER_FN = 6;
+	const callees_of = (key, total_ms) => {
+		const ids = nodes_by_key.get(key);
+		if (!ids || total_ms <= 0) return void 0;
+		const by = /* @__PURE__ */ new Map();
+		const walk = (id) => {
+			for (const c of by_id.get(id)?.children ?? []) {
+				const rc = resolved.get(c);
+				if (!rc) continue;
+				if (rc.key === key) {
+					walk(c);
+					continue;
+				}
+				if (rc.name.startsWith("(") && !rc.url) continue;
+				const us = node_total_us.get(c) ?? 0;
+				if (us <= 0) continue;
+				const e = by.get(rc.key);
+				if (e) e.us += us;
+				else by.set(rc.key, {
+					r: rc,
+					us
+				});
+			}
+		};
+		for (const id of ids) walk(id);
+		const list = [...by.values()].sort((a, b) => b.us - a.us).slice(0, CALLEES_PER_FN).map(({ r, us }) => ({
+			key: r.key,
+			name: r.name,
+			category: r.category,
+			...r.pkg ? { pkg: r.pkg } : {},
+			file: r.url ? `${short_path(r.url)}:${r.line}` : "",
+			ms: round2(us / 1e3),
+			share: Math.min(1, round2(us / 1e3 / total_ms))
+		})).filter((c) => c.ms >= .05);
+		return list.length ? list : void 0;
+	};
+	const FRAMEWORK_PKG = (p) => p.startsWith("@sveltejs/") || p === "svelte" || p.startsWith("ogygia") || p === "vite";
+	const facts_of = /* @__PURE__ */ new Map();
+	const facts = (id) => {
+		const hit = facts_of.get(id);
+		if (hit) return hit;
+		const out = {
+			app: false,
+			edges: []
+		};
+		let child;
+		let cur = id;
+		while (cur !== void 0) {
+			const r = resolved.get(cur);
+			if (r.category === "app" || r.category === "component") {
+				out.app = true;
+				if (child && child.category === "dependency" && child.pkg && !FRAMEWORK_PKG(child.pkg)) out.edges.push({
+					app: r.key,
+					lib: child,
+					pkg: child.pkg
+				});
+			}
+			if (r.category === "dependency" && r.pkg && !FRAMEWORK_PKG(r.pkg)) out.root_pkg = r.pkg;
+			child = r;
+			cur = parent_of.get(cur);
+		}
+		facts_of.set(id, out);
+		return out;
+	};
+	/** per package, the app → library entries in time order */
+	const entries = /* @__PURE__ */ new Map();
+	const orphans = [];
+	{
+		let t = 0;
+		for (let i = 0; i < samples.length; i++) {
+			const d = deltas[i] ?? 0;
+			t += d;
+			const r = resolved.get(samples[i]);
+			if (!r || r.category === "idle" || r.category === "profiler") continue;
+			const fx = facts(samples[i]);
+			if (fx.app) for (const e of fx.edges) {
+				let list = entries.get(e.pkg);
+				if (!list) entries.set(e.pkg, list = []);
+				list.push({
+					t,
+					app: e.app,
+					lib: e.lib
+				});
+			}
+			else if (fx.root_pkg && d > 0) orphans.push({
+				t,
+				us: d,
+				pkg: fx.root_pkg
+			});
+		}
+	}
+	/** app key → library key → { the library frame, µs of orphan work it started } */
+	const async_us = /* @__PURE__ */ new Map();
+	for (const o of orphans) {
+		const list = entries.get(o.pkg);
+		if (!list?.length) continue;
+		let lo = 0;
+		let hi = list.length - 1;
+		let at = -1;
+		while (lo <= hi) {
+			const mid = lo + hi >> 1;
+			if (list[mid].t <= o.t) {
+				at = mid;
+				lo = mid + 1;
+			} else hi = mid - 1;
+		}
+		const e = list[at >= 0 ? at : 0];
+		let m = async_us.get(e.app);
+		if (!m) async_us.set(e.app, m = /* @__PURE__ */ new Map());
+		const cur = m.get(e.lib.key);
+		if (cur) cur.us += o.us;
+		else m.set(e.lib.key, {
+			lib: e.lib,
+			us: o.us
+		});
+	}
+	for (const k of async_us.keys()) {
+		const s = agg.get(k);
+		if (s && !functions.includes(s)) functions.push(s);
+	}
+	/** a function's callees with its async library work merged in (and its total grown by it) */
+	const with_async = (key, total_ms, callees) => {
+		const m = async_us.get(key);
+		if (!m) return {
+			...callees ? { callees } : {},
+			async_ms: 0
+		};
+		let async_ms = 0;
+		const list = [...callees ?? []];
+		for (const { lib, us } of m.values()) {
+			const ms = us / 1e3;
+			async_ms += ms;
+			const same = list.find((c) => c.key === lib.key);
+			if (same) {
+				same.ms = round2(same.ms + ms);
+				same.async_ms = round2((same.async_ms ?? 0) + ms);
+			} else list.push({
+				key: lib.key,
+				name: lib.name,
+				category: lib.category,
+				file: lib.url ? `${short_path(lib.url)}:${lib.line}` : "",
+				ms: round2(ms),
+				share: 0,
+				async_ms: round2(ms)
+			});
+		}
+		const whole = total_ms + async_ms;
+		for (const c of list) c.share = whole > 0 ? Math.min(1, round2(c.ms / whole)) : 0;
+		list.sort((a, b) => b.ms - a.ms);
+		return {
+			callees: list.slice(0, CALLEES_PER_FN),
+			async_ms: round2(async_ms)
+		};
+	};
+	for (const [i, f] of functions.entries()) {
+		f.self_ms = round2(f.self_ms);
+		f.total_ms = round2(f.total_ms);
+		if (i < 120) {
+			f.stacks = stacks_of(f.key);
+			f.lines = lines_of(f.key);
+			const src = src_of(f);
+			if (src) f.src = src;
+			if (f.name.startsWith("(") && f.line > 0 && (f.category === "app" || f.category === "component")) {
+				const snip = resolver?.line_at_source(f.path || clean_url(f.url), f.line);
+				if (snip) f.label = snip;
+			}
+		}
+		if ((i < 120 || f.total_ms >= .5 || async_us.has(f.key)) && (f.category === "app" || f.category === "component")) {
+			const { callees, async_ms } = with_async(f.key, f.total_ms, callees_of(f.key, f.total_ms));
+			if (callees) f.callees = callees;
+			if (async_ms) f.async_ms = async_ms;
+			if (!f.stacks) f.stacks = stacks_of(f.key);
+		}
+	}
+	const run_us = /* @__PURE__ */ new Map();
+	const runs = timeline_input?.runs;
+	const overhead_run_us = runs ? Array.from({ length: runs.length }, () => 0) : [];
+	const owner_run_us = /* @__PURE__ */ new Map();
+	const owner_memo = /* @__PURE__ */ new Map();
+	const owner_group_of = (id) => {
+		if (owner_memo.has(id)) return owner_memo.get(id);
+		const frames = [];
+		let cur = id;
+		while (cur !== void 0 && frames.length < 64) {
+			const rr = resolved.get(cur);
+			frames.push({
+				name: rr.name,
+				url: rr.url,
+				line: rr.line,
+				category: rr.category,
+				pkg: rr.pkg
+			});
+			cur = parent_of.get(cur);
+		}
+		const leaf = frames[0];
+		const o = !leaf || leaf.category === "idle" || leaf.name === "(root)" || leaf.name === "(program)" ? void 0 : owner_of_stack(frames);
+		const open = o ? o.label.lastIndexOf(" (") : -1;
+		const g = !o || o.category === "profiler" ? void 0 : o.category === "dependency" && open !== -1 && o.label.endsWith(")") ? o.label.slice(open + 2, -1) : o.category === "node" ? "node core" : o.label;
+		owner_memo.set(id, g);
+		return g;
+	};
+	if (runs?.length && samples.length && deltas.length) {
+		let t_us = profile.startTime;
+		let ri = 0;
+		const comps_on_stack = /* @__PURE__ */ new Map();
+		const comps_of = (id) => {
+			const hit = comps_on_stack.get(id);
+			if (hit) return hit;
+			const out = [];
+			let cur = id;
+			while (cur !== void 0) {
+				const rr = resolved.get(cur);
+				if (rr.category === "component" && !out.includes(rr.key)) out.push(rr.key);
+				cur = parent_of.get(cur);
+			}
+			comps_on_stack.set(id, out);
+			return out;
+		};
+		for (let i = 0; i < samples.length; i++) {
+			const d = deltas[i] ?? 0;
+			t_us += d;
+			if (d <= 0) continue;
+			const t = timeline_input.perf_start + (t_us - profile.startTime) / 1e3;
+			while (ri < runs.length && t > runs[ri].end) ri++;
+			if (ri >= runs.length) break;
+			if (t < runs[ri].start) continue;
+			if (resolved.get(samples[i])?.category === "profiler") overhead_run_us[ri] += d;
+			const owner = owner_group_of(samples[i]);
+			if (owner) {
+				let arr = owner_run_us.get(owner);
+				if (!arr) owner_run_us.set(owner, arr = Array.from({ length: runs.length }, () => 0));
+				arr[ri] += d;
+			}
+			for (const key of comps_of(samples[i])) {
+				let arr = run_us.get(key);
+				if (!arr) run_us.set(key, arr = Array.from({ length: runs.length }, () => 0));
+				arr[ri] += d;
+			}
+		}
+	}
+	const components = [...agg.values()].filter((f) => f.category === "component" && f.total_ms >= .01).sort((a, b) => b.total_ms - a.total_ms).map((f) => {
+		let parent;
+		let best = 0;
+		for (const [p, us] of parent_us.get(f.key) ?? []) if (us > best) {
+			best = us;
+			parent = agg.get(p)?.name;
+		}
+		const per_run = run_us.get(f.key);
+		const lines = f.lines ?? lines_of(f.key);
+		const src = f.src ?? src_of({
+			path: f.path,
+			line: f.line,
+			lines
+		});
+		const { callees, async_ms } = f.callees ? {
+			callees: f.callees,
+			async_ms: f.async_ms ?? 0
+		} : with_async(f.key, f.total_ms, callees_of(f.key, f.total_ms));
+		return {
+			...f,
+			self_ms: round2(f.self_ms),
+			total_ms: round2(f.total_ms),
+			stacks: f.stacks ?? stacks_of(f.key),
+			lines,
+			...src ? { src } : {},
+			...callees ? { callees } : {},
+			...async_ms ? { async_ms } : {},
+			markup_ms: round2((markup_us.get(f.key) ?? 0) / 1e3),
+			logic_ms: round2((logic_us.get(f.key) ?? 0) / 1e3),
+			...parent ? { parent } : {},
+			...per_run ? { runs_ms: per_run.map((us) => round2(us / 1e3)) } : {}
+		};
+	});
+	const by_name = new Map(components.map((c) => [c.name, c]));
+	for (const c of components) {
+		if (!c.name.endsWith(" (island host)")) continue;
+		const island = by_name.get(c.name.slice(0, -14));
+		if (!island?.path || island.path.includes("/.svelte-kit/")) continue;
+		c.url = island.url;
+		c.path = island.path;
+		c.line = island.line;
+		c.lines = [];
+		delete c.src;
+	}
+	const file_list = [...files.values()].sort((a, b) => b.self_ms - a.self_ms);
+	for (const f of file_list) f.self_ms = round2(f.self_ms);
+	const bucket_list = [...buckets.values()].sort((a, b) => b.self_ms - a.self_ms);
+	for (const b of bucket_list) b.self_ms = round2(b.self_ms);
+	const HOT_FOR_PATHS = 40;
+	const ROOT_NAME_RE = /^(?:_(?:page|layout|error)|Root|children|handle|respond|render_response|render_page)$/;
+	const BUILT_CHUNK_RE = /\/(?:chunks|output|\.svelte-kit)\//;
+	const SVELTE_GLUE_RE = /^(?:child|component|each|push|pop|head|slot|snippet|render)$/;
+	/** the profiler's own wrapper frames, by name, for a build that bundled span.ts into the app chunk */
+	const PROFILER_WRAPPER_RE = /^(?:span|within|wrapped|wrap_call)$/;
+	const not_glue = functions.filter((f) => f.self_ms >= .01 && !(f.category === "svelte" && SVELTE_GLUE_RE.test(f.name)));
+	const hot_keys = /* @__PURE__ */ new Set([...not_glue.slice(0, HOT_FOR_PATHS).map((f) => f.key), ...not_glue.filter((f) => f.category === "app" || f.category === "component").slice(0, HOT_FOR_PATHS).map((f) => f.key)]);
+	const can_own = (a) => !ROOT_NAME_RE.test(a.name) && !a.name.startsWith("(") && !a.name.endsWith("(island host)") && (a.category === "component" || a.category === "app" && !BUILT_CHUNK_RE.test(a.url));
+	const cover = /* @__PURE__ */ new Map();
+	/** the hot nodes (every node of a hot key with self time), for the trees below */
+	const hot_nodes = [];
+	for (const n of profile.nodes) {
+		const r = resolved.get(n.id);
+		if (!hot_keys.has(r.key)) continue;
+		const s = self_us.get(n.id) ?? 0;
+		if (s <= 0) continue;
+		hot_nodes.push({
+			id: n.id,
+			key: r.key,
+			us: s
+		});
+		const seen = /* @__PURE__ */ new Set([r.key]);
+		let cur = parent_of.get(n.id);
+		while (cur !== void 0) {
+			const a = resolved.get(cur);
+			if (can_own(a) && !seen.has(a.key)) {
+				seen.add(a.key);
+				let m = cover.get(a.key);
+				if (!m) cover.set(a.key, m = /* @__PURE__ */ new Map());
+				m.set(r.key, (m.get(r.key) ?? 0) + s);
+			}
+			cur = parent_of.get(cur);
+		}
+	}
+	const TREE_FANOUT = 6;
+	/** an anonymous function reads by where it is (`fn @ ds-ssr.ts:46`), everything else by name */
+	const path_label = (name, url, line, path) => {
+		if (!name.startsWith("(") || !url) return name;
+		const file = url.split("/").pop()?.split("?")[0] ?? url;
+		const snippet = resolver?.line_at_source(path ?? clean_url(url), line);
+		return snippet ? `fn @ ${file}:${line} · ${snippet}` : `fn @ ${file}:${line}`;
+	};
+	const build_tree = (owner_key, fn_keys) => {
+		const o = agg.get(owner_key);
+		const root = {
+			key: o.key,
+			name: o.name,
+			category: o.category,
+			file: o.url ? `${o.url}:${o.line}` : "",
+			ms: 0,
+			hot: hot_keys.has(o.key),
+			calls: o.calls ?? null,
+			children: []
+		};
+		const node_of = (parent, r) => {
+			let c = parent.children.find((x) => x.key === r.key);
+			if (!c) {
+				c = {
+					key: r.key,
+					name: path_label(r.name, r.url, r.line),
+					category: r.category,
+					file: r.url ? `${short_path(r.url)}:${r.line}` : "",
+					ms: 0,
+					hot: hot_keys.has(r.key),
+					calls: agg.get(r.key)?.calls ?? null,
+					children: []
+				};
+				parent.children.push(c);
+			}
+			return c;
+		};
+		for (const h of hot_nodes) {
+			if (!fn_keys.has(h.key)) continue;
+			const chain = [];
+			let cur = h.id;
+			let found = false;
+			while (cur !== void 0 && chain.length < 64) {
+				const r = resolved.get(cur);
+				if (r.key === owner_key && cur !== h.id) {
+					found = true;
+					break;
+				}
+				if (!(r.category === "profiler" || (r.name.startsWith("(") || r.category === "svelte" || r.name === "Region" || PROFILER_WRAPPER_RE.test(r.name)) && !hot_keys.has(r.key)) && (chain.length === 0 || chain[chain.length - 1].key !== r.key)) chain.push(r);
+				cur = parent_of.get(cur);
+			}
+			if (!found) continue;
+			chain.reverse();
+			const us = h.us;
+			root.ms += us;
+			let at = root;
+			for (const r of chain.slice(-10)) {
+				at = node_of(at, r);
+				at.ms += us;
+			}
+		}
+		const finish = (n) => {
+			n.ms = round2(n.ms / 1e3);
+			n.children.sort((x, y) => y.ms - x.ms);
+			if (n.children.length > TREE_FANOUT) {
+				const rest = n.children.slice(TREE_FANOUT);
+				n.children = n.children.slice(0, TREE_FANOUT);
+				n.children.push({
+					key: "",
+					name: `(${rest.length} more)`,
+					category: "unknown",
+					file: "",
+					ms: round2(rest.reduce((t, c) => t + c.ms, 0) / 1e3),
+					hot: false,
+					children: []
+				});
+			}
+			for (const c of n.children) if (c.key) finish(c);
+		};
+		finish(root);
+		return root;
+	};
+	const paths = [];
+	const taken = /* @__PURE__ */ new Set();
+	const min_path_us = Math.max(2e3, busy_us * .01);
+	for (let round = 0; round < 5; round++) {
+		let best = null;
+		const scored = [];
+		for (const [ak, m] of cover) {
+			if (taken.has(ak)) continue;
+			const fns = [...m].filter(([hk]) => !taken.has(hk));
+			if (fns.length < 2) continue;
+			const us = fns.reduce((t, [, v]) => t + v, 0);
+			if (us < min_path_us) continue;
+			scored.push({
+				key: ak,
+				us,
+				fns
+			});
+		}
+		if (!scored.length) break;
+		scored.sort((x, y) => y.us - x.us);
+		best = scored[0];
+		const by_key = new Map(scored.map((c) => [c.key, c]));
+		let node = build_tree(best.key, new Set(best.fns.map(([hk]) => hk)));
+		for (let depth = 0; depth < 12; depth++) {
+			const c = node.children[0];
+			if (!c || !c.key || c.ms < node.ms * .9) break;
+			if (c.name.startsWith("(")) break;
+			node = c;
+			const cand = by_key.get(c.key);
+			if (cand) best = cand;
+		}
+		const owner = agg.get(best.key);
+		if (!owner) break;
+		taken.add(best.key);
+		for (const [hk] of best.fns) taken.add(hk);
+		const fns = best.fns.map(([hk, us]) => {
+			const f = agg.get(hk);
+			return {
+				key: hk,
+				name: path_label(f.name, f.url, f.line, f.path),
+				url: f.url,
+				line: f.line,
+				category: f.category,
+				pkg: f.pkg,
+				ms: round2(us / 1e3)
+			};
+		}).sort((x, y) => y.ms - x.ms);
+		paths.push({
+			owner: {
+				key: owner.key,
+				name: owner.name,
+				url: owner.url,
+				line: owner.line,
+				category: owner.category,
+				total_ms: round2(owner.total_ms),
+				calls: owner.calls
+			},
+			fns,
+			ms: round2(best.us / 1e3),
+			share: owner.total_ms > 0 ? round2(Math.min(1, best.us / 1e3 / owner.total_ms)) : 0,
+			tree: build_tree(best.key, new Set(best.fns.map(([hk]) => hk)))
+		});
+	}
+	if (timeline_input && resolver && !timeline_input.hooks) {
+		let hooks_file;
+		const is_hooks = (u) => u.endsWith("hooks.server.ts") || u.endsWith("hooks.server.js");
+		for (const s of resolver.embedded_sources()) if (is_hooks(s)) hooks_file = s;
+		if (!hooks_file) {
+			for (const r of resolved.values()) if (r.url && is_hooks(r.url)) hooks_file = r.url;
+		}
+		if (hooks_file) {
+			const parts = handle_parts((p, a, b) => resolver.source_lines(p, a, b), hooks_file);
+			if (parts.size) timeline_input = {
+				...timeline_input,
+				hooks: parts
+			};
+		}
+	}
+	const timeline = timeline_input ? build_timeline(profile, (id) => {
+		const r = resolved.get(id);
+		return {
+			name: r.name,
+			url: r.url,
+			line: r.line,
+			category: r.category,
+			pkg: r.pkg
+		};
+	}, (id) => parent_of.get(id), timeline_input) : void 0;
+	const capture_cpu = timeline_input?.runs?.length ? build_timeline(profile, (id) => {
+		const r = resolved.get(id);
+		return {
+			name: r.name,
+			url: r.url,
+			line: r.line,
+			category: r.category,
+			pkg: r.pkg
+		};
+	}, (id) => parent_of.get(id), {
+		perf_start: timeline_input.perf_start,
+		window: {
+			start: timeline_input.perf_start,
+			end: timeline_input.perf_start + (profile.endTime - profile.startTime) / 1e3
+		},
+		calls: []
+	}).segments.filter((s) => s.kind === "cpu").map((s) => ({
+		t0: s.t0,
+		t1: s.t1,
+		label: s.label,
+		category: s.category,
+		...s.file ? { file: s.file } : {}
+	})) : void 0;
+	const stacks = timeline_input ? build_stack_index(profile, (id) => {
+		const r = resolved.get(id);
+		return {
+			name: r.name,
+			url: r.url,
+			line: r.line,
+			category: r.category
+		};
+	}, (id) => parent_of.get(id), timeline_input.perf_start, timeline_input.window) : void 0;
+	return {
+		duration_ms: round2((profile.endTime - profile.startTime) / 1e3),
+		busy_ms: round2(busy_us / 1e3),
+		idle_ms: round2(idle_us / 1e3),
+		gc_ms: round2(gc_us / 1e3),
+		overhead_ms: round2(overhead_us / 1e3),
+		overhead_functions,
+		...runs?.length ? { overhead_by_run_ms: overhead_run_us.map((us) => round2(us / 1e3)) } : {},
+		...capture_cpu ? { capture_cpu } : {},
+		...owner_run_us.size ? { owner_runs_ms: Object.fromEntries([...owner_run_us].map(([k, v]) => [k, v.map((us) => round2(us / 1e3))])) } : {},
+		deopts,
+		sample_count: samples.length,
+		functions,
+		components,
+		files: file_list,
+		buckets: bucket_list,
+		flame,
+		sourcemapped: resolver?.hit ?? false,
+		...other_us > 0 ? { other_requests_ms: round2(other_us / 1e3) } : {},
+		...resolver?.text_hit ? { text_mapped: true } : {},
+		...timeline ? { timeline } : {},
+		...stacks ? { stacks } : {},
+		paths
+	};
+}
+function round2(n) {
+	return Math.round(n * 100) / 100;
+}
+/** Aggregate a sampled heap profile into "who allocates the most" rows. */
+/** BYTES PER COMPONENT: every sampled allocation credited to the nearest component above it in
+*  the heap tree (the same rule as markup/logic: nested components take their own). */
+/** A minified identifier: what a production client chunk calls its functions (`Y`, `Gr`, `_a`, `#u`). */
+const MINIFIED_NAME_RE = /^#?[A-Za-z_$][A-Za-z0-9_$]?$/;
+/**
+* The renamer for a BROWSER profile: a component confirmed in a minified client chunk (Svelte's
+* runtime is below it, so it is one, but its name is `Y`) is named after the `.svelte` files the
+* build put in that chunk — `ProductCard`, or `ProductCard (+2 in chunk)` when the chunk holds
+* several. `contents` is the build handoff's chunk summary by path (`chunkContents`). Only the
+* confirmed stage renames: an unconfirmed `Pt` is a helper and stays app code.
+*/
+function chunk_component_renamer(contents) {
+	const cache = /* @__PURE__ */ new Map();
+	return (name, url, stage) => {
+		if (stage !== "confirmed" || !MINIFIED_NAME_RE.test(name)) return void 0;
+		let path;
+		try {
+			path = new URL(url, "http://x").pathname;
+		} catch {
+			return;
+		}
+		if (!cache.has(path)) {
+			const comps = (contents(path) ?? []).filter((s) => s.endsWith(".svelte")).map((s) => component_name_from_file(s) ?? s.split("/").pop().replace(/\.svelte$/, ""));
+			cache.set(path, comps.length ? comps.length === 1 ? comps[0] : `${comps[0]} (+${comps.length - 1} in chunk)` : void 0);
+		}
+		return cache.get(path);
+	};
+}
+function heap_by_component(head, limit = 60) {
+	const by = /* @__PURE__ */ new Map();
+	const stack = [];
+	const visit = (node) => {
+		const f = with_script_url(node.callFrame);
+		const c = categorize(f);
+		let name = f.functionName;
+		if (c.category === "component") name = strip_bundler_suffix(name);
+		else if ((!f.functionName || f.functionName === "(anonymous)") && c.category !== "dependency") {
+			const derived = component_name_from_file(clean_url(f.url));
+			if (derived) name = derived;
+		}
+		const is_comp = c.category === "component" || name !== f.functionName && !!name;
+		if (is_comp) stack.push(name);
+		const near = stack[stack.length - 1];
+		if (near !== void 0 && node.selfSize > 0) by.set(near, (by.get(near) ?? 0) + node.selfSize);
+		for (const ch of node.children ?? []) visit(ch);
+		if (is_comp) stack.pop();
+	};
+	visit(head);
+	return [...by.entries()].map(([name, bytes]) => ({
+		name,
+		bytes
+	})).sort((a, b) => b.bytes - a.bytes).slice(0, limit);
+}
+function analyze_heap(head, limit = 25) {
+	const agg = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		const f = with_script_url(node.callFrame);
+		const key = `${f.functionName} ${f.url}`;
+		let stat = agg.get(key);
+		if (!stat) {
+			stat = {
+				name: f.functionName || "(anonymous)",
+				url: short_path(f.url),
+				line: f.lineNumber + 1,
+				category: categorize(f).category,
+				self_bytes: 0,
+				total_bytes: 0
+			};
+			agg.set(key, stat);
+		}
+		stat.self_bytes += node.selfSize;
+		let total = node.selfSize;
+		for (const c of node.children ?? []) total += visit(c);
+		stat.total_bytes += total;
+		return total;
+	};
+	visit(head);
+	return [...agg.values()].filter((a) => a.self_bytes > 0 && a.category !== "v8" && a.category !== "gc" && a.category !== "profiler").sort((a, b) => b.self_bytes - a.self_bytes).slice(0, limit);
+}
+export { SourceMapResolver, analyze, analyze_heap, another_routes_file, build_stack_index, categorize, chunk_component_renamer, clean_url, component_name_from_file, decode_mappings, decode_packed, heap_by_component, join_source, learn_script_urls, route_dirs, route_file_of, sourcemap_resolver, strip_bundler_suffix, with_script_url };