@ogygia/devtools 0.0.0 → 0.11.1

package/dist/profiler/index.js

@@ -0,0 +1,4921 @@
+import { analyze, analyze_heap, categorize, chunk_component_renamer, heap_by_component, learn_script_urls, sourcemap_resolver } from "./analyze.js";
+import { another_routes_file, route_dirs } from "./route-files.js";
+import { TRACE_HEADER, encode_trace } from "./net.js";
+import { derive_findings, is_dump, island_host_renamer, island_name, island_rows_of, page_score_of, path_template, report_dump, report_json } from "./report.js";
+import { is_ogp, ogp_decode, ogp_encode, recover_ogp_bytes } from "./crypto.js";
+import { AFTER_LOGIN_PARAM, SESSION_COOKIE, describe_cookie_diagnosis, raw_cookie_values, session_cookie_values } from "./session-cookie.js";
+import { label_call, load_lane_of, phase_of_frame } from "./timeline.js";
+import { merge_visits, parse_visit } from "./visit.js";
+import { own_requests } from "./own-requests.js";
+import { MAX_VISITS_PER_KEY } from "./storage/visits.js";
+import { hole_slots } from "./hole-slots.js";
+import { client_windows, interaction_windows } from "./client-windows.js";
+import { byte_strip } from "./byte-strip.js";
+import { stream_tail } from "./stream-tail.js";
+import { BEACON_STANDALONE_TAG } from "./beacon-standalone.js";
+import { build_river, load_return_keys, seed_key_bytes } from "./river.js";
+import { SinkBuffer } from "./sink.js";
+import { attribute_gc, gc_kind, heap_sites } from "./gc.js";
+import { alloc_timeline } from "./alloc.js";
+import { contention } from "./contention.js";
+import { build_lineage, data_prop_names, data_reads, whole_read_line } from "./lineage.js";
+import { build_ledger, pkg_of } from "./ledger.js";
+import { at_line, build_drill, call_group, tag_fills } from "./drill.js";
+import { forecast_of } from "./forecast.js";
+import { site_fixes } from "./site-fixes.js";
+import { may_be_chunk, module_category, module_lookup } from "./module-map.js";
+import { embedded_chunk, embedded_files, embedded_map_of, embedded_source, load_embedded_maps } from "./embedded-maps.js";
+import { module_imports, route_imports } from "./route-imports.js";
+import { app_relative } from "./app-path.js";
+import { attr_sites, doc_diff } from "./doc-diff.js";
+import { almost_same_document_pattern, counted_sync_io, find_cold_caches, find_patterns, find_same_answers, find_wait_patterns, heap_growth, is_clear_leak, is_flat, late_island_pattern, render_per_item_pattern, same_document_pattern, same_work_pattern, seed_whole_pattern, stable_answers, varied_answers, wait_save_on_path } from "./patterns.js";
+import { constant_work, each_blocks, formatter_rewrite, hoist_plan, key_sources, late_island_keys, line_rw, load_inputs, names_on, parent_use, tokens } from "./source-scan.js";
+import { compare_reports, island_files_diff, page_history, vitals_moved as vitals_moved$1 } from "./compare.js";
+import { gzip_large } from "./compress.js";
+import { io_kind, mark_left_each_run } from "./async-io.js";
+import { set_span_recorder } from "./span.js";
+import { register_profiler_file } from "./frames.js";
+import { app_asset_rel, client_dir_candidates, client_file_finder } from "./client-files.js";
+import { build_profiler_router } from "./profiler-router.js";
+import { detect_dev } from "./env.js";
+import { refresh_target } from "./refresh-stub.js";
+import { assets_diff, engine_of, hydration_hazards, vital_parts, weigh_assets } from "@ogygia/core/insights";
+import { hole_stats_of, mark_personal, request_stats_of, set_batch_hole_listener, set_request_stats_detail } from "@ogygia/core/internal/server";
+import { fnv1a32 } from "@ogygia/core/plugin/utils";
+import { chunkBarrels, chunkContents, chunkDuplicates, chunkHeavy, islandHazards, islandPageKeys, islandPageWhy } from "virtual:ogygia/island-deps";
+import { error, isHttpError, isRedirect } from "@ogygia/router";
+// src/profiler/index.ts
+/** Set on the login page's URL when a login just succeeded and the session still did not arrive. */
+const LOGIN_FAILED_PARAM = "session";
+/** I/O resources a line can wait on one after another, as a readable target. Timers and ticks
+*  are left out: a timer awaited per turn is the `yield-per-item` pattern, read from the code. */
+const WAIT_TARGET = {
+	FSREQCALLBACK: "file access",
+	FSREQPROMISE: "file access",
+	GETADDRINFOREQWRAP: "DNS lookup",
+	GETNAMEINFOREQWRAP: "DNS lookup",
+	QUERYWRAP: "DNS query",
+	TCPCONNECTWRAP: "socket connect",
+	PIPECONNECTWRAP: "pipe connect"
+};
+/** A response body read chunk by chunk, each chunk's end offset stamped with when it arrived
+*  (ms after `t0`): the byte strip's "left the server at". */
+async function read_timed(res, t0) {
+	const reader = res.body?.getReader();
+	if (!reader) return {
+		text: await res.text(),
+		chunks: []
+	};
+	const dec = new TextDecoder();
+	let text = "";
+	const chunks = [];
+	for (;;) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		text += dec.decode(value, { stream: true });
+		if (chunks.length < 4e3) chunks.push({
+			end: text.length,
+			t: round2(performance.now() - t0)
+		});
+	}
+	text += dec.decode();
+	return {
+		text,
+		chunks
+	};
+}
+register_profiler_file();
+const MAX_VITALS_PATHS = 200;
+const MAX_VITALS_SAMPLES = 30;
+const MAX_SAMPLED_WINDOWS = 60;
+const SAMPLED_FUNCTIONS_PER_WINDOW = 150;
+const MAX_BEACON_FPS = 2e3;
+const MAX_BEACON_SAMPLES = 64;
+const MAX_BEACON_BODY = 65536;
+const MAX_BEACON_CPU_BODY = 6291456;
+const MAX_BEACON_VISIT_BODY = 524288;
+/** the allocation sampler's interval while attributing GC: coarse on purpose (64 KB, against the
+*  16 KB the allocators table used) — the attribution needs shares, not every object, and every
+*  sample is a record V8 keeps until the read */
+const GC_SAMPLING_BYTES = 65536;
+/** the live-objects sampler of the memory passes after the timed runs (what one render keeps, and
+*  the growth check): finer, because those are VERDICTS on a line, not shares. At 64 KB a 1 MB
+*  cache entry is ~14 samples, and a 4-entry cache's halfway-to-end ratio swung 1.10–2.00 around
+*  its true 1.33 (the leak line is 1.85): the slow-patterns decoy read "grows" 1 run in ~17, and a
+*  real leak was missed now and then. At 16 KB it stays 1.16–1.57. These renders are not timed:
+*  it costs about half a second of the profile's wall time on the heaviest test page, no timing. */
+const LIVE_SAMPLING_BYTES = 16384;
+/** the fine heap series (alloc.ts): the timer's period and the most samples one window keeps */
+const HEAP_SERIES_PERIOD_MS = 20;
+const HEAP_SERIES_MAX = 2e3;
+/** the sampler keeps objects already collected: the ALLOCATION stream, what drives the collector,
+*  not just what is still alive when the profile is read */
+const GC_SAMPLING_FLAGS = {
+	includeObjectsCollectedByMajorGC: true,
+	includeObjectsCollectedByMinorGC: true
+};
+/** how long a page profile waits for a background window (trap / sampler) to finish — the
+*  longest such window is the trap's 5 s */
+const PAGE_WAITS_FOR_BACKGROUND_MS = 8e3;
+/** a started window stops itself after this, even with no stop (it holds the recorder) */
+const WINDOW_MAX_MS = 6e4;
+/** the header a test's driver sends with each request of a window (its signed id) */
+const WINDOW_HEADER = "x-og-window";
+/** a window's requests sit in the store's visit rows under this page key (never a real path) */
+const WINDOW_PAGE_PREFIX = "\0window:";
+const MAX_VISITS_PER_PAGE = 5;
+/** a screen narrower than this is a phone's (its own first screen, its own hidden islands) */
+const NARROW_SCREEN_PX = 768;
+/** Svelte's client runtime, by the names that show up under a component while it hydrates */
+/** the package in a CDN script's path: `/npm/@scope/name@8/dist/x.js`, `/name@1.2.3/x.js`, `/gh/user/repo@v/` */
+const CDN_PKG_RE = /\/(?:npm\/)?((?:@[\w.-]+\/)?[\w.-]+)@[\w.^~-]+\//;
+const SVELTE_CLIENT_FN_RE = /^(?:set_text|set_attribute|set_class|set_style|template|from_html|child|sibling|first_child|append|mount|hydrate|hydrate_template|each|if_block|render_effect|template_effect|effect|derived|proxy|get|set|push|pop|init|reset|next|skip_nodes|create_text|remove_nodes|event|delegate|bind_value|component|snippet|slot|head)$/;
+/**
+* Chromium's JS Self-Profiling trace (`Profiler.stop()`) as a V8 cpuprofile: a stack is a chain of
+* frames, so every distinct stack becomes one node whose parent is its parent stack; the samples
+* are timestamps (ms) → time deltas (µs); a sample with no stack is idle. Bounded (samples,
+* stacks); `null` for anything not shaped like a trace. Exported for the tests.
+*/
+function self_profile_to_cpuprofile(trace) {
+	const t = trace;
+	if (!t || !Array.isArray(t.frames) || !Array.isArray(t.stacks) || !Array.isArray(t.samples)) return null;
+	const resources = Array.isArray(t.resources) ? t.resources.map((r) => typeof r === "string" ? r : "") : [];
+	const frames = t.frames.slice(0, 5e4);
+	const stacks = t.stacks.slice(0, 1e5);
+	const samples = t.samples.slice(0, 2e5);
+	const frame_of = (i) => {
+		const f = frames[i];
+		if (!f) return {
+			functionName: "(unknown)",
+			url: "",
+			lineNumber: 0,
+			columnNumber: 0
+		};
+		const rid = typeof f.resourceId === "number" ? f.resourceId : -1;
+		return {
+			functionName: typeof f.name === "string" ? f.name : "",
+			url: rid >= 0 ? resources[rid] ?? "" : "",
+			lineNumber: typeof f.line === "number" ? Math.max(0, f.line - 1) : 0,
+			columnNumber: typeof f.column === "number" ? Math.max(0, f.column - 1) : 0
+		};
+	};
+	const nodes = [{
+		id: 1,
+		callFrame: {
+			functionName: "(root)",
+			url: "",
+			lineNumber: 0,
+			columnNumber: 0
+		},
+		children: [2]
+	}, {
+		id: 2,
+		callFrame: {
+			functionName: "(idle)",
+			url: "",
+			lineNumber: 0,
+			columnNumber: 0
+		}
+	}];
+	const children = /* @__PURE__ */ new Map([[1, [2]]]);
+	for (let i = 0; i < stacks.length; i++) {
+		const s = stacks[i];
+		const fid = typeof s?.frameId === "number" ? s.frameId : -1;
+		const parent = typeof s?.parentId === "number" && s.parentId >= 0 && s.parentId < stacks.length ? s.parentId + 3 : 1;
+		nodes.push({
+			id: i + 3,
+			callFrame: frame_of(fid)
+		});
+		(children.get(parent) ?? children.set(parent, []).get(parent)).push(i + 3);
+	}
+	for (const n of nodes) {
+		const ch = children.get(n.id);
+		if (ch?.length) n.children = ch;
+	}
+	const sample_ids = [];
+	const deltas = [];
+	let last = null;
+	let first = 0;
+	for (const s of samples) {
+		const ts = typeof s?.timestamp === "number" ? s.timestamp : null;
+		if (ts === null) continue;
+		if (last === null) first = ts;
+		const sid = typeof s?.stackId === "number" && s.stackId >= 0 && s.stackId < stacks.length ? s.stackId + 3 : 2;
+		sample_ids.push(sid);
+		deltas.push(last === null ? 0 : Math.max(0, Math.round((ts - last) * 1e3)));
+		last = ts;
+	}
+	if (!sample_ids.length) return null;
+	return {
+		nodes,
+		startTime: Math.round(first * 1e3),
+		endTime: Math.round((last ?? first) * 1e3),
+		samples: sample_ids,
+		timeDeltas: deltas
+	};
+}
+const MAX_BEACON_ISLANDS = 400;
+/** the tag the runtime looks for: its content is the beacon endpoint */
+const BEACON_META = "ogygia-profiler-beacon";
+/** an island fingerprint: 8–32 lowercase hex chars, checked without a regex (per beacon sample) */
+function is_hex_id(s) {
+	if (s.length < 8 || s.length > 32) return false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (!(c >= 48 && c <= 57 || c >= 97 && c <= 102)) return false;
+	}
+	return true;
+}
+/** GET each URL through the app's own fetch and count its bytes — the JS weight of an island's
+*  closure. Cached per process (immutable hashed assets), a handful at a time, capped in time so
+*  a slow static host can never hold a report hostage. */
+async function weigh_urls(urls, fetch_url, cache, budget_ms = 4e3) {
+	const todo = [...new Set(urls)].filter((u) => u && !cache.has(u));
+	const deadline = Date.now() + budget_ms;
+	let i = 0;
+	const worker = async () => {
+		while (i < todo.length && Date.now() < deadline) {
+			const u = todo[i++];
+			try {
+				const res = await with_timeout(fetch_url(u), Math.max(200, deadline - Date.now()), "weigh");
+				if (!res.ok) {
+					cache.set(u, null);
+					continue;
+				}
+				const len = Number(res.headers.get("content-length"));
+				const bytes = !res.headers.get("content-encoding") && Number.isFinite(len) && len > 0 ? len : (await res.arrayBuffer()).byteLength;
+				cache.set(u, bytes);
+			} catch {
+				cache.set(u, null);
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(6, todo.length) }, worker));
+	const out = {};
+	for (const u of new Set(urls)) {
+		const b = cache.get(u);
+		if (typeof b === "number") out[u] = b;
+	}
+	return out;
+}
+const percentile = (sorted, p) => sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))] ?? 0;
+function summarize_measures(entries) {
+	const by_name = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		let t = by_name.get(e.name);
+		if (!t) by_name.set(e.name, t = {
+			name: e.name,
+			count: 0,
+			total_ms: 0,
+			max_ms: 0
+		});
+		t.count++;
+		t.total_ms += e.ms;
+		if (e.ms > t.max_ms) t.max_ms = e.ms;
+	}
+	return [...by_name.values()].map((t) => ({
+		...t,
+		total_ms: round2(t.total_ms),
+		max_ms: round2(t.max_ms)
+	})).sort((a, b) => b.total_ms - a.total_ms).slice(0, 30);
+}
+const MAX_SPANS_PER_REQUEST = 2e3;
+const MAX_WINDOW_SPANS = 2e4;
+const MAX_TAGS = 16;
+/** the process's live profiler (the newest): an older one's background timers stand down */
+const LIVE_PROFILER = Symbol.for("ogygia.profiler.live");
+const MAX_NET_PER_REQUEST = 100;
+const MAX_WINDOW_NET = 2e3;
+const MAX_BACKGROUND_NET = 300;
+const RECORDING_MAX_MS = 35e3;
+const RECORDING_HARD_CAP_MS = 3e4;
+const PER_RENDER_TIMEOUT_MS = 15e3;
+/** the heap's fill (of its limit) past which no timed render is made: one more could end the process */
+const HEAP_STOP = .85;
+/** …and past which the extra renders (what a render keeps, the growth check) are skipped */
+const HEAP_EXTRAS = .7;
+/** …and past which a profile does not start: the warm-up renders come before any check, and a
+*  render's own peak (not only what it keeps) needs the room */
+const HEAP_START = .75;
+/** the main thread's work in a render: the code on the sampled stacks and the collector's pauses */
+const MAIN_THREAD_CPU = /* @__PURE__ */ new Set([
+	"app",
+	"component",
+	"dependency",
+	"node",
+	"svelte",
+	"gc"
+]);
+/** app modules whose built lines are their source lines, near enough to match by text */
+const SCRIPT_MODULE_EXTS = [
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs"
+];
+/** marks the profiler's keep-the-answers render (its value: the recording's token) */
+const ANSWERS_HEADER = "x-og-profiler-answers";
+/** renders the keep-the-answers measure takes at most (their median is the figure) */
+const ANSWER_RENDERS = 3;
+/** an inspector-unavailable recording error (edge runtimes) vs a real profiling failure */
+const INSPECTOR_ERR = /inspector/;
+const WIN_DRIVE_RE = /^[A-Za-z]:[\\/]/;
+const QUERY_SUFFIX_RE = /\?.*$/;
+/** the seed script in a rendered document (report time, one document: not a hot path) */
+const SEED_SCRIPT_RE = /<script\b[^>]*type="application\/ogygia-page"[^>]*>([\s\S]*?)<\/script>/i;
+const SRC_RELATIVE_RE = /(?:^|[/\\])src[/\\](.*)$/;
+const BACKSLASH_G = /\\/g;
+const PATH_SEP_RE = /[/\\]/;
+const TRAILING_SLASH_RE = /\/$/;
+/** a WebAssembly script "file" as V8 names it: `/wasm/00034eea`, `wasm://wasm/…` */
+const WASM_FRAME_RE = /^(?:wasm:\/\/|\/wasm\/)|[/\\]wasm\/[0-9a-f]+$/;
+/** a resolved caller that lives in node_modules or Kit's runtime source: the framework, not the app */
+const FRAMEWORK_SOURCE_RE = /[/\\]node_modules[/\\]|(?:^|[/\\])runtime[/\\](?:server|app|telemetry)[/\\]/;
+const NODE_MODULES_RE = /[/\\]node_modules[/\\]/;
+/** a Kit endpoint file in a resolved caller string (`+server.ts`, or its built `_server.ts.js`) */
+const SERVER_ROUTE_FILE_RE = /[/\\](?:\+server\.[jt]s|_server\.[jt]s\.js):\d+/;
+/** the file inside a resolved caller string: `name (file:line)` or `file:line` */
+const CALLER_FILE_RE = /(?:\(|^)([^()]+):\d+\)?$/;
+/** what the dev source peek may read */
+const SOURCE_EXT_RE = /\.(?:svelte|ts|js|mjs|cjs|tsx|jsx|svx|md|json)$/;
+const SERVERLESS_RESERVE_MS = 5e3;
+/** the app lines the pattern finder reads, and the ones the report keeps and shows */
+const LEDGER_FOR_PATTERNS = 200;
+const LEDGER_SHOWN = 40;
+/** how long a page recording waits for its store write before answering (inside the reserve) */
+const PERSIST_WAIT_MS = 3e3;
+/** The whole-request wall budget (ms) before the platform's gateway kills a /page profile — Infinity
+*  on a real server (adapter-node, dev). An explicit OGYGIA_PROFILER_BUDGET_MS wins over detection. */
+function detect_request_budget_ms() {
+	const override = Number(process.env.OGYGIA_PROFILER_BUDGET_MS);
+	if (Number.isFinite(override) && override > 0) return override;
+	const env = process.env;
+	if (env.VERCEL) return 3e5;
+	if (env.NETLIFY) return 1e4;
+	if (env.AWS_LAMBDA_FUNCTION_NAME || env.LAMBDA_TASK_ROOT) return 3e4;
+	return Infinity;
+}
+/** Time allotted to the profiling work itself (warm-up + runs + coverage), keeping RESERVE for the
+*  rest of the request. Halves as a floor so a very small budget still spends most of itself working. */
+function serverless_work_budget_ms() {
+	const req = detect_request_budget_ms();
+	if (!Number.isFinite(req)) return Infinity;
+	return Math.max(req - SERVERLESS_RESERVE_MS, Math.floor(req * .5));
+}
+/**
+* Page mode renders the SAME page N times, so its outbound calls are the same handful repeated N
+* times — a waterfall of 5×3 identical bars is noise. Given each run's [start,end] window, keep only
+* ONE representative render's net + io (the run that captured the most calls — the fullest picture;
+* ties go to the later, warmer run) so the network view reads as "one request + its leaf calls". CPU
+* stays merged across all runs (more samples = steadier median); network is inherently per-render.
+*/
+function scope_net_to_one_run(cap, windows) {
+	if (windows.length <= 1) return windows[0] ?? null;
+	const within = (t, w) => t >= w.start && t <= w.end;
+	let best = windows[0];
+	let best_n = -1;
+	for (const w of windows) {
+		const n = cap.net.reduce((s, c) => s + (within(c.start, w) ? 1 : 0), 0);
+		if (n >= best_n) {
+			best_n = n;
+			best = w;
+		}
+	}
+	cap.net = cap.net.filter((c) => within(c.start, best));
+	cap.io_ops = cap.io_ops.filter((o) => within(o.start, best));
+	return best;
+}
+/**
+* The profiler as a class — state lives in fields, not closures, matching the
+* `OgygiaHandle` house style. `profiler(options)` (below) constructs one and
+* returns its bound `handle`.
+*/
+var Profiler = class {
+	base;
+	sample_interval;
+	max_reports;
+	ring_size;
+	want_network;
+	want_heap;
+	dev;
+	want_server_timing;
+	secret;
+	ui_enabled;
+	#disabled;
+	#ring = [];
+	#reports = /* @__PURE__ */ new Map();
+	/** the browser's hydration timings, by island fingerprint (`/beacon`) — joined into reports at view time */
+	#beacons = /* @__PURE__ */ new Map();
+	/** the browser's web vitals per page path (`/beacon`), the profiler user's own visits */
+	#vitals = /* @__PURE__ */ new Map();
+	/** the app's own browser marks per page path, per name (`mark()` from ogygia/profiler/client) */
+	#marks = /* @__PURE__ */ new Map();
+	/** the trap (catch the slow one) and the always-on sampler: their state */
+	#trap;
+	#client_cpu;
+	/** the browser's CPU profile of hydration, per page path (the profiler user's latest visit) */
+	#client_cpus = /* @__PURE__ */ new Map();
+	/** per page, the slowest interaction's CPU (its wait and its handlers), the latest trace */
+	#interaction_cpus = /* @__PURE__ */ new Map();
+	/** the beacon's visits per page (the browser's picture of a page load), a few kept each */
+	#visits = /* @__PURE__ */ new Map();
+	/** THE SINK: rows an ephemeral host posts out before it dies (see sink.ts) */
+	#sink = new SinkBuffer();
+	#sink_url = null;
+	#sink_key = null;
+	#sink_every = 1e4;
+	#sink_timer = null;
+	#sink_inflight = false;
+	#sink_last = null;
+	#trap_caught = 0;
+	#trap_running = false;
+	#trap_timer = null;
+	#sample;
+	#sampled = [];
+	#sample_timer = null;
+	#background_note = null;
+	/** bytes per asset URL, measured once per process */
+	#weights = /* @__PURE__ */ new Map();
+	/** every page asset weighed so far (hashed assets never change): page-assets.ts */
+	#asset_weights = /* @__PURE__ */ new Map();
+	#background_net = [];
+	#window_net = null;
+	#inflight = 0;
+	#recording_since = 0;
+	/** performance.now() when this instance's first request arrived (its cold start, on Lambda) */
+	#first_request_pt;
+	/** requests this instance has handled */
+	#requests_seen = 0;
+	#recorder_busy = false;
+	/** page profiles waiting for a background window to give the recorder back */
+	#page_waiting = 0;
+	/** the durable report store (SQLite/Redis/Postgres/custom), when configured — else null and the
+	*  in-memory map is all there is (the prior behaviour) */
+	#store = null;
+	#als = null;
+	#init_done = null;
+	/** Re-assert the `globalThis.fetch` patch before a profile (self-heal if it was replaced). */
+	#ensure_net = null;
+	/** wraps Kit's `event.fetch` (in-process same-origin dispatch) with the recorder, per attributed request */
+	#wrap_event_fetch = null;
+	/** the network layer's kept answers (net.ts): what the keep-the-answers render is served */
+	#kept = null;
+	/** the keep-the-answers render in flight: its request carries this token, and only these calls
+	*  (`GET <url>`, the same answer in every timed render) are served from memory */
+	#answers = null;
+	constructor(options = {}) {
+		this.base = options.path ?? "/__profiler";
+		this.sample_interval = clamp(options.sampleInterval ?? 500, 50, 1e4);
+		this.max_reports = options.maxReports ?? 6;
+		this.ring_size = options.recentRequests ?? 500;
+		this.want_network = options.network !== false;
+		this.want_heap = options.heap !== false;
+		this.dev = detect_dev();
+		this.want_server_timing = options.serverTiming ?? this.dev;
+		this.secret = options.secret ?? process.env.OGYGIA_PROFILER_SECRET ?? "";
+		this.ui_enabled = options.enabled !== false && (this.dev || this.secret !== "");
+		this.#disabled = options.enabled === false;
+		this.#trap = options.trap && options.trap.over > 0 ? options.trap : null;
+		if (options.store) {
+			this.#store = options.store;
+			(async () => this.#store.init?.())().catch((e) => {
+				console.error("[ogygia/profiler] store init failed; falling back to in-memory:", e);
+				this.#store = null;
+			});
+		}
+		this.#client_cpu = options.clientCpu !== false;
+		if (options.sink?.url) {
+			this.#sink_url = options.sink.url;
+			this.#sink_key = options.sink.key ?? this.secret ?? null;
+			this.#sink_every = Math.max(1e3, options.sink.every ?? 1e4);
+			if (!Number.isFinite(serverless_work_budget_ms())) {
+				this.#sink_timer = setInterval(() => void this.#sink_flush(), this.#sink_every);
+				this.#sink_timer.unref?.();
+			}
+		}
+		this.#sample = options.sample ? options.sample : null;
+		globalThis[LIVE_PROFILER] = this;
+		if (!this.#disabled) set_batch_hole_listener((request, s) => this.#batch_hole(request, s));
+	}
+	/** Logged requests by their Request (a batch's holes find their request here), and the holes that
+	*  settled before their request was logged. */
+	#logged = /* @__PURE__ */ new WeakMap();
+	#early_holes = /* @__PURE__ */ new WeakMap();
+	/** ONE HOLE OF A BATCH, logged as its own hole request — the shape every hole reading here knows
+	*  (the cache table, the render slots, a visit's holes): its own time within the batch, no CPU of
+	*  its own (the batch request carries that). */
+	#batch_hole(request, s) {
+		const base = this.#logged.get(request);
+		if (!base) {
+			const early = this.#early_holes.get(request);
+			if (early) early.push(s);
+			else this.#early_holes.set(request, [s]);
+			return;
+		}
+		const { ms, status, ...hole } = s;
+		this.#ring.push({
+			...base,
+			ms: round2(ms),
+			cpu_ms: 0,
+			status,
+			hole,
+			og: void 0
+		});
+		if (this.#ring.length > this.ring_size) this.#ring.shift();
+	}
+	/** A newer profiler took this process over (a dev server that re-ran the app's hooks). */
+	#superseded() {
+		return globalThis[LIVE_PROFILER] !== this;
+	}
+	/** Stand down: the background timers stop (a sink sends what it holds first). */
+	#retire() {
+		if (this.#trap_timer) clearTimeout(this.#trap_timer);
+		if (this.#sample_timer) clearTimeout(this.#sample_timer);
+		this.#trap_timer = null;
+		this.#sample_timer = null;
+		if (this.#sink_timer) {
+			clearInterval(this.#sink_timer);
+			this.#sink_timer = null;
+			this.#sink_flush();
+		}
+	}
+	/** Arm the background recorders (once, from the first request). Both need a real server: on a
+	*  serverless host an instance lives for one request and the inspector is often unavailable. */
+	#arm_background() {
+		if (!this.#trap && !this.#sample) return;
+		if (Number.isFinite(serverless_work_budget_ms())) {
+			this.#background_note = "trap / sampling are off on this serverless host (an instance lives for one request).";
+			return;
+		}
+		if (this.#trap && !this.#trap_timer) this.#schedule_trap(1e3);
+		if (this.#sample && !this.#sample_timer) this.#schedule_sample((this.#sample.every ?? 60) * 1e3);
+	}
+	#schedule_trap(delay_ms) {
+		this.#trap_timer = setTimeout(() => void this.#trap_cycle(), delay_ms);
+		this.#trap_timer.unref?.();
+	}
+	#schedule_sample(delay_ms) {
+		this.#sample_timer = setTimeout(() => void this.#sample_cycle(), delay_ms);
+		this.#sample_timer.unref?.();
+	}
+	/** One rolling trap window: sample coarsely, then keep the window only if a request in it blew
+	*  past the threshold. The slowest such request is the report's request; the timeline is its. */
+	async #trap_cycle() {
+		const t = this.#trap;
+		this.#trap_timer = null;
+		if (this.#superseded()) return this.#retire();
+		const keep = t.keep ?? 3;
+		if (this.#trap_caught >= keep) return;
+		if (this.#page_waiting) return this.#schedule_trap(1e3);
+		if (!this.#try_acquire_recorder()) return this.#schedule_trap(2e3);
+		this.#trap_running = true;
+		this.#recording_since = Date.now();
+		try {
+			const window_ms = t.window ?? 5e3;
+			const cap = await this.#capture_window((t.interval ?? 10) * 1e3, () => new Promise((r) => setTimeout(r, window_ms)), { light: true });
+			const slow = this.#ring.filter((e) => !e.internal && e.pt !== void 0 && e.ts >= cap.t0 && e.ts + e.ms <= cap.t1 && e.ms >= t.over).sort((x, y) => y.ms - x.ms)[0];
+			if (slow) {
+				cap.window = {
+					start: slow.pt,
+					end: slow.pt + slow.ms
+				};
+				const id = await this.#finish_report(cap, {
+					trigger: "trap",
+					request: {
+						method: slow.method,
+						path: slow.path,
+						route: slow.route,
+						ms: slow.ms
+					},
+					trap_over: t.over
+				});
+				const stored = this.#reports.get(id);
+				if (stored) stored.replay = {
+					path: slow.path + (slow.search ?? ""),
+					headers: slow.replay_headers ?? {}
+				};
+				if (stored && this.#sink_url) {
+					this.#sink.push({
+						k: "trap",
+						t: stored.meta.created,
+						path: slow.path,
+						ms: slow.ms,
+						id,
+						dump: report_dump(stored.analysis, stored.meta, this.#report_extras(stored))
+					});
+					this.#sink_flush();
+				}
+				this.#trap_caught++;
+			}
+		} catch {
+			this.#trap_caught = keep;
+		} finally {
+			this.#trap_running = false;
+			this.#recording_since = 0;
+			this.#release_als();
+			this.#release_recorder();
+		}
+		if (this.#trap_caught < keep) this.#schedule_trap(1e3);
+	}
+	/** One always-on sample: a short coarse window folded into the rolling hot-functions table. */
+	async #sample_cycle() {
+		const s = this.#sample;
+		this.#sample_timer = null;
+		if (this.#superseded()) return this.#retire();
+		const every_ms = (s.every ?? 60) * 1e3;
+		if (this.#page_waiting) return this.#schedule_sample(Math.min(every_ms, 2e3));
+		if (!this.#try_acquire_recorder()) return this.#schedule_sample(Math.min(every_ms, 5e3));
+		this.#trap_running = true;
+		this.#recording_since = Date.now();
+		try {
+			const window_ms = s.window ?? 2e3;
+			const cap = await this.#capture_window((s.interval ?? 10) * 1e3, () => new Promise((r) => setTimeout(r, window_ms)), { light: true });
+			const resolver = await this.#make_resolver();
+			const a = analyze(cap.profile, resolver, void 0, void 0, void 0, this.#module_hint);
+			this.#sampled.push({
+				at: cap.t0,
+				ms: cap.duration_ms,
+				busy_ms: a.busy_ms,
+				functions: a.functions.slice(0, SAMPLED_FUNCTIONS_PER_WINDOW).map((f) => ({
+					key: f.key,
+					name: f.name,
+					url: f.url,
+					line: f.line,
+					category: f.category,
+					pkg: f.pkg,
+					self_ms: f.self_ms
+				}))
+			});
+			while (this.#sampled.length > MAX_SAMPLED_WINDOWS) this.#sampled.shift();
+			if (this.#sink_url) {
+				const w = this.#sampled[this.#sampled.length - 1];
+				this.#sink.push({
+					k: "win",
+					t0: w.at,
+					t1: w.at + w.ms,
+					fns: w.functions.slice(0, 40).map((f) => ({
+						name: f.name,
+						file: f.url,
+						self_ms: f.self_ms,
+						category: f.category
+					}))
+				});
+			}
+		} catch {
+			return;
+		} finally {
+			this.#trap_running = false;
+			this.#recording_since = 0;
+			this.#release_als();
+			this.#release_recorder();
+		}
+		this.#schedule_sample(every_ms);
+	}
+	/** The always-on table: every kept window folded, hot functions by summed self time. */
+	#sampled_summary() {
+		if (!this.#sample) return null;
+		const by_key = /* @__PURE__ */ new Map();
+		let sampled_ms = 0;
+		let busy_ms = 0;
+		for (const w of this.#sampled) {
+			sampled_ms += w.ms;
+			busy_ms += w.busy_ms;
+			for (const f of w.functions) {
+				const g = by_key.get(f.key);
+				if (g) {
+					g.self_ms = round2(g.self_ms + f.self_ms);
+					g.windows++;
+				} else by_key.set(f.key, {
+					...f,
+					windows: 1
+				});
+			}
+		}
+		return {
+			every_s: this.#sample.every ?? 60,
+			window_ms: this.#sample.window ?? 2e3,
+			windows: this.#sampled.length,
+			since: this.#sampled[0]?.at ?? null,
+			sampled_ms: round2(sampled_ms),
+			busy_ms: round2(busy_ms),
+			functions: [...by_key.values()].sort((x, y) => y.self_ms - x.self_ms).slice(0, 40)
+		};
+	}
+	#collect_window(call) {
+		if (this.#window_net && this.#window_net.length < MAX_WINDOW_NET) this.#window_net.push(call);
+	}
+	/** An attributed request's context: its own calls (capped), each also offered to the window. */
+	#request_ctx(entry) {
+		const collect_window = (call) => this.#collect_window(call);
+		return {
+			entry,
+			net: [],
+			spans: [],
+			route: entry.route,
+			path: entry.path,
+			on_net(call) {
+				if (this.net.length < MAX_NET_PER_REQUEST) this.net.push(call);
+				collect_window(call);
+			}
+		};
+	}
+	#init() {
+		return this.#init_done ??= (async () => {
+			this.#arm_background();
+			if (!this.want_network) return;
+			try {
+				const { AsyncLocalStorage } = await import("node:async_hooks");
+				this.#als = new AsyncLocalStorage();
+			} catch {
+				this.#als = null;
+			}
+			if (this.#als) try {
+				const { install_net_capture, ensure_fetch_patched, wrap_event_fetch, keep_answers, kept_answer, drop_answers, answer_diff } = await import("./net.js");
+				this.#wrap_event_fetch = wrap_event_fetch;
+				this.#kept = {
+					keep: keep_answers,
+					get: kept_answer,
+					drop: drop_answers,
+					diff: answer_diff
+				};
+				await install_net_capture(this.#als, (call) => {
+					this.#collect_window(call);
+					this.#background_net.push(call);
+					if (this.#background_net.length > MAX_BACKGROUND_NET) this.#background_net.shift();
+				});
+				this.#ensure_net = ensure_fetch_patched;
+			} catch {}
+		})();
+	}
+	/** A recording is "active" only if one started recently — a run abandoned by a frozen/killed
+	*  serverless invocation ages out after the cap instead of wedging the profiler forever. */
+	#recording_active() {
+		return this.#recording_since > 0 && Date.now() - this.#recording_since < RECORDING_MAX_MS;
+	}
+	/** Take the recorder slot without waiting: true if it was free (now ours), false if busy. Recordings
+	*  serialize PER WORKER — one V8 inspector CPU/heap sampler + one attribution context per process — so
+	*  a second recording on the same process is refused, NOT queued in memory: on serverless the process
+	*  can be recycled at any moment (Amplify freezes a worker after ~30 s), so a waiter parked in memory
+	*  is unreliable, and it isn't needed — a retry lands on a different, free worker. The "queue" is the
+	*  CLIENT polling `/page` until a worker says yes (see RunView). */
+	#try_acquire_recorder() {
+		if (this.#recorder_busy) return false;
+		this.#recorder_busy = true;
+		return true;
+	}
+	/** Free the recorder slot. Called only when the recording is truly finished (its inspector session
+	*  closed) — never from the site-unblock watchdog, which may fire while an orphaned run still holds
+	*  the inspector. */
+	#release_recorder() {
+		this.#recorder_busy = false;
+	}
+	/** Production: detach the profiler's AsyncLocalStorage once a recording ends. An ALS that has
+	*  run once stays enabled — every async hop in the process keeps paying a store copy for it — until
+	*  `disable()`; the next `run()` re-enables it. Dev keeps it on (attribution is always on there). */
+	#release_als() {
+		if (!this.dev) this.#als?.disable();
+	}
+	async #capture_window(interval_us, work, opts = {}) {
+		const { Session } = await import("node:inspector/promises");
+		const perf_hooks = await import("node:perf_hooks");
+		await load_embedded_maps();
+		const session = new Session();
+		session.connect();
+		const histogram = perf_hooks.monitorEventLoopDelay({ resolution: 10 });
+		histogram.enable();
+		const elu0 = perf_hooks.performance.eventLoopUtilization();
+		const cpu0 = process.cpuUsage();
+		const gc_pauses = [];
+		const gc_raw = [];
+		const measures = [];
+		const ingest = (entries) => {
+			for (const e of entries) if (e.entryType === "gc") {
+				gc_pauses.push(e.duration);
+				const d = e.detail ?? {};
+				if (gc_raw.length < 5e3) gc_raw.push({
+					start: e.startTime ?? 0,
+					ms: e.duration,
+					kind: d.kind ?? 0,
+					flags: d.flags ?? 0
+				});
+			} else if (e.entryType === "measure" && measures.length < 5e3) measures.push({
+				name: e.name,
+				ms: e.duration
+			});
+		};
+		let observer;
+		try {
+			observer = new perf_hooks.PerformanceObserver((list) => ingest(list.getEntries()));
+			observer.observe({ entryTypes: ["gc", "measure"] });
+		} catch {}
+		const mem = [];
+		const t0 = Date.now();
+		const sample_mem = () => {
+			const m = process.memoryUsage();
+			mem.push({
+				t: Date.now() - t0,
+				rss: Math.round(m.rss / 1048576),
+				heap_used: Math.round(m.heapUsed / 1048576)
+			});
+		};
+		sample_mem();
+		const mem_timer = setInterval(sample_mem, 250);
+		mem_timer.unref?.();
+		const heap_series = [];
+		let heap_timer;
+		if (!opts.light) try {
+			const v8 = await import("node:v8");
+			const sample_heap = () => {
+				if (heap_series.length >= HEAP_SERIES_MAX) return;
+				heap_series.push({
+					t: perf_hooks.performance.now(),
+					mb: v8.getHeapStatistics().used_heap_size / 1048576
+				});
+			};
+			heap_timer = setInterval(sample_heap, HEAP_SERIES_PERIOD_MS);
+			heap_timer.unref?.();
+		} catch {}
+		this.#window_net = [];
+		const netmod = await import("./net.js").catch(() => null);
+		if (!opts.light) netmod?.set_stack_capture(true);
+		const spans = [];
+		let span_seq = 0;
+		const als = this.#als;
+		const { AsyncLocalStorage: SpanALS } = await import("node:async_hooks");
+		const span_als = new SpanALS();
+		set_span_recorder({
+			begin: (name, attrs) => {
+				const ctx = als?.getStore();
+				const parent = ctx?.span ?? span_als.getStore();
+				const rec = {
+					id: ++span_seq,
+					name: String(name).slice(0, 120),
+					start: perf_hooks.performance.now(),
+					ms: -1,
+					...attrs ? { attrs: { ...attrs } } : {},
+					...parent !== void 0 ? { parent } : {},
+					caller_site: netmod?.nearest_app_site(),
+					route: ctx?.route ?? null,
+					path: ctx?.path ?? null
+				};
+				if (spans.length < MAX_WINDOW_SPANS) spans.push(rec);
+				if (ctx && ctx.spans.length < MAX_SPANS_PER_REQUEST) ctx.spans.push(rec);
+				return rec;
+			},
+			within: (s, fn) => {
+				const ctx = als?.getStore();
+				return ctx && als ? als.run({
+					...ctx,
+					span: s.id
+				}, fn) : span_als.run(s.id, fn);
+			},
+			end: (s, attrs, error) => {
+				s.ms = round2(perf_hooks.performance.now() - s.start);
+				if (attrs) s.attrs = {
+					...s.attrs,
+					...attrs
+				};
+				if (error !== void 0) s.error = error instanceof Error ? error.message : String(error);
+			},
+			tag: (key, value) => {
+				const ctx = als?.getStore();
+				if (!ctx) return;
+				const tags = ctx.entry.tags ??= {};
+				if (key in tags || Object.keys(tags).length < MAX_TAGS) tags[key] = value;
+			}
+		});
+		const iomod = opts.light ? null : await import("./async-io.js").catch(() => null);
+		let io_rec = iomod ? await iomod.record_async_io() : null;
+		let heap_head = null;
+		set_request_stats_detail(true);
+		try {
+			await session.post("Profiler.enable");
+			await session.post("Profiler.setSamplingInterval", { interval: interval_us });
+			let heap_on = false;
+			if (this.want_heap && !opts.light) try {
+				await session.post("HeapProfiler.enable");
+				if (opts.gc_attr !== false) try {
+					await session.post("HeapProfiler.startSampling", {
+						samplingInterval: GC_SAMPLING_BYTES,
+						...GC_SAMPLING_FLAGS
+					});
+					heap_on = true;
+				} catch {
+					try {
+						await session.post("HeapProfiler.stopSampling");
+						await session.post("HeapProfiler.startSampling", {
+							samplingInterval: GC_SAMPLING_BYTES,
+							...GC_SAMPLING_FLAGS
+						});
+						heap_on = true;
+					} catch (e) {
+						if (process.env.OGYGIA_PROFILER_DEBUG) console.error("[ogygia/profiler] allocation sampling unavailable, GC attribution off:", e);
+						await session.post("HeapProfiler.startSampling", { samplingInterval: 16384 });
+					}
+				}
+				else await session.post("HeapProfiler.startSampling", { samplingInterval: 16384 });
+			} catch {}
+			const perf_start = perf_hooks.performance.now();
+			await session.post("Profiler.start");
+			const gc_slices = [];
+			const gc_dict = {};
+			await work();
+			const perf_end = perf_hooks.performance.now();
+			const { profile } = await session.post("Profiler.stop");
+			learn_script_urls(profile);
+			if (this.want_heap && !opts.light) try {
+				heap_head = (await session.post("HeapProfiler.stopSampling")).profile?.head ?? null;
+				if (heap_on && heap_head) {
+					const cur = heap_sites(heap_head, gc_dict);
+					const bytes = {};
+					for (const [k, v] of cur) if (v > 0) bytes[k] = v;
+					gc_slices.push({
+						t0: 0,
+						t1: round2(perf_end - perf_start),
+						bytes
+					});
+				}
+			} catch {
+				heap_head = null;
+			}
+			const t1 = Date.now();
+			sample_mem();
+			try {
+				if (observer) ingest(observer.takeRecords());
+			} catch {}
+			const cpu = process.cpuUsage(cpu0);
+			const elu = perf_hooks.performance.eventLoopUtilization(elu0);
+			const duration_ms = t1 - t0;
+			const net = this.#window_net ?? [];
+			for (const s of spans) if (s.ms < 0) s.open = true;
+			return {
+				profile,
+				heap: heap_head,
+				mem,
+				net,
+				spans,
+				gc_pauses,
+				gc_events: gc_raw.filter((g) => g.start >= perf_start && g.start <= perf_end).map((g) => ({
+					t: round2(g.start - perf_start),
+					ms: round2(g.ms),
+					kind: gc_kind(g.kind),
+					flags: g.flags
+				})),
+				gc_slices,
+				gc_dict,
+				...io_rec ? { promises: io_rec.promises() } : {},
+				io_ops: io_rec ? io_rec.stop() : [],
+				call_counts: {},
+				measures: summarize_measures(measures),
+				loop: {
+					p50: round2(histogram.percentile(50) / 1e6),
+					p99: round2(histogram.percentile(99) / 1e6),
+					max: round2(histogram.max / 1e6)
+				},
+				cpu_percent: duration_ms > 0 ? round2((cpu.user + cpu.system) / 1e3 / duration_ms * 100) : void 0,
+				elu_percent: round2(elu.utilization * 100),
+				t0,
+				t1,
+				duration_ms,
+				perf_start,
+				...heap_series.length >= 3 ? { heap_series: heap_series.filter((h) => h.t >= perf_start && h.t <= perf_end).map((h) => ({
+					t: round2(h.t - perf_start),
+					mb: h.mb
+				})) } : {}
+			};
+		} finally {
+			clearInterval(mem_timer);
+			if (heap_timer) clearInterval(heap_timer);
+			histogram.disable();
+			set_span_recorder(null);
+			span_als.disable();
+			set_request_stats_detail(false);
+			netmod?.set_stack_capture(false);
+			io_rec?.stop();
+			try {
+				observer?.disconnect();
+			} catch {}
+			this.#window_net = null;
+			try {
+				session.disconnect();
+			} catch {}
+		}
+	}
+	/**
+	* Exact per-function call counts (the ×N), from V8 precise coverage. Run as
+	* its OWN render, not during the CPU sampling window — coverage disables
+	* inlining, so mixing it into the sampled profile makes tiny hot functions
+	* (svelte's `child`, `push`) look like the bottleneck. Counts are per this
+	* single render.
+	*/
+	/** Call counts from one render under precise coverage. That render runs with V8's inlining off,
+	*  so a CPU profile taken during it (`with_profile`) keeps every app function in its own frame:
+	*  the report reads it for WHO a merged line's time belongs to (`unsmear`), never for how long
+	*  anything takes (no inlining makes everything slower). Same render, no extra one. */
+	async #count_calls(work, with_profile = false) {
+		const counts = {};
+		let profile;
+		try {
+			const { Session } = await import("node:inspector/promises");
+			const session = new Session();
+			session.connect();
+			try {
+				await session.post("Profiler.enable");
+				await session.post("Profiler.startPreciseCoverage", {
+					callCount: true,
+					detailed: false
+				});
+				if (with_profile) {
+					await session.post("Profiler.setSamplingInterval", { interval: 200 });
+					await session.post("Profiler.start");
+				}
+				try {
+					await work();
+				} finally {
+					if (with_profile) try {
+						profile = (await session.post("Profiler.stop")).profile;
+					} catch {
+						profile = void 0;
+					}
+				}
+				const cov = await session.post("Profiler.takePreciseCoverage");
+				await session.post("Profiler.stopPreciseCoverage");
+				for (const script of cov.result) for (const fn of script.functions) {
+					const nm = fn.functionName;
+					if (!nm || nm.startsWith("(")) continue;
+					const c = fn.ranges[0]?.count ?? 0;
+					if (c > 0) {
+						const k = nm + "\0" + script.url;
+						counts[k] = (counts[k] ?? 0) + c;
+						if (script.scriptId) {
+							const ki = nm + "\0#" + script.scriptId;
+							counts[ki] = (counts[ki] ?? 0) + c;
+						}
+					}
+				}
+			} finally {
+				session.disconnect();
+			}
+		} catch {}
+		return {
+			counts,
+			...profile ? { profile } : {}
+		};
+	}
+	/** URL → local client file, for the browser CPU profile (see client-files.ts); undefined off Node */
+	async #client_file_finder(origin) {
+		try {
+			const fs = await import("node:fs");
+			const path = await import("node:path");
+			const entry = process.argv[1] ? path.dirname(process.argv[1]) : void 0;
+			const dirs = client_dir_candidates(entry, process.cwd(), path.join);
+			return client_file_finder(origin, dirs, (p) => fs.existsSync(p), path.join);
+		} catch {
+			return;
+		}
+	}
+	/** THE MODULE MAP's word on a bundled server frame (no sourcemap needed): the profiler's own code,
+	*  ogygia's runtime or a bundled package, else nothing (the app's) — `analyze`'s `url_category` */
+	#module_find = module_lookup();
+	/** A BUILD WITHOUT SOURCEMAPS: a line of a built chunk named by the source module it came from
+	*  (the build's module map), so `chunks/format.js:131` reads as src/lib/format.ts */
+	/** a position in a BUILT chunk that the module map files under the app (no sourcemap to resolve
+	*  it): the place to charge memory to, as the ledger names chunk lines. Undefined otherwise */
+	#chunk_at(url, line) {
+		if (!url || !line || line <= 0) return void 0;
+		let path = url;
+		if (path.startsWith("file://")) try {
+			path = decodeURIComponent(new URL(path).pathname);
+		} catch {
+			return;
+		}
+		if (!may_be_chunk(path)) return void 0;
+		const id = this.#module_find(path, line);
+		return id && !module_category(id) ? {
+			path,
+			line
+		} : void 0;
+	}
+	#label_module(x) {
+		if (x.module || !may_be_chunk(x.path)) return;
+		const id = this.#module_find(x.path, x.line);
+		if (id && !module_category(id)) x.module = id;
+	}
+	#module_hint = (url, _name, line) => {
+		const id = this.#module_find(url, line);
+		return id ? module_category(id) : void 0;
+	};
+	async #make_resolver() {
+		try {
+			const fs = await import("node:fs");
+			const path = await import("node:path");
+			const entry = process.argv[1] ? path.dirname(process.argv[1]) : void 0;
+			const bases = entry ? [
+				entry,
+				path.dirname(entry),
+				"."
+			] : ["."];
+			const is_abs = (p) => p.startsWith("/") || WIN_DRIVE_RE.test(p);
+			await load_embedded_maps();
+			const dev_map = this.dev ? globalThis[Symbol.for("ogygia.profiler.dev-maps")] : void 0;
+			const dev_client_map = this.dev ? globalThis[Symbol.for("ogygia.profiler.dev-client-maps")] : void 0;
+			return sourcemap_resolver((p) => {
+				if (dev_map && p.endsWith(".map")) {
+					const m = dev_map(p.slice(0, -4));
+					if (m) return m;
+				}
+				if (dev_client_map && p.startsWith("/") && p.endsWith(".map")) {
+					const m = dev_client_map(p.slice(0, -4));
+					if (m) return m;
+				}
+				for (const base of is_abs(p) ? [""] : bases) try {
+					return fs.readFileSync(base ? path.join(base, p) : p, "utf8");
+				} catch {}
+				return p.endsWith(".map") ? embedded_map_of(p.slice(0, -4)) : embedded_source(p) ?? embedded_chunk(p);
+			}, (chunk, line) => {
+				const id = this.#module_find(chunk, line);
+				if (!id || id.startsWith("\0") || id.startsWith("virtual:")) return void 0;
+				if (id.startsWith("src/")) {
+					if (!SCRIPT_MODULE_EXTS.some((e) => id.endsWith(e))) return void 0;
+					return {
+						source: path.resolve(process.cwd(), id),
+						text: true
+					};
+				}
+				return {
+					source: path.resolve(process.cwd(), id),
+					text: false
+				};
+			}, { any_ext: !!dev_map });
+		} catch {
+			return;
+		}
+	}
+	async #finish_report(cap, meta_partial, fetch_url) {
+		const own = `${this.base}/`;
+		const path_of = (u) => {
+			if (u.startsWith("/")) return u;
+			try {
+				return new URL(u).pathname;
+			} catch {
+				return u;
+			}
+		};
+		cap.net = cap.net.filter((c) => !path_of(c.url).startsWith(own));
+		const resolver = await this.#make_resolver();
+		const heap = cap.heap ? analyze_heap(cap.heap) : null;
+		const heap_components = cap.heap ? heap_by_component(cap.heap) : null;
+		const rel_src = (f) => {
+			const clean = f.replace(QUERY_SUFFIX_RE, "");
+			const m = SRC_RELATIVE_RE.exec(clean);
+			if (m) return m[1].replace(BACKSLASH_G, "/");
+			return clean.split(PATH_SEP_RE).slice(-3).join("/");
+		};
+		/** the source position a caller resolved to (absolute when the map gave one): what the
+		*  pattern finder reads the call site's code from */
+		let last_at;
+		const resolve_caller = (site) => {
+			last_at = void 0;
+			if (!site) return void 0;
+			const name = site.fn && site.fn !== "(anonymous)" && !site.fn.includes(".") ? site.fn : void 0;
+			let file = rel_src(site.file);
+			let line = site.line;
+			const m = resolver?.resolve(site.file, Math.max(0, site.line - 1), Math.max(0, site.column - 1));
+			if (m) {
+				file = rel_src(m.source);
+				line = m.line;
+			}
+			if (file.startsWith("profiler/") || file.includes("/profiler/")) return void 0;
+			if (WASM_FRAME_RE.test(file)) return void 0;
+			if (FRAMEWORK_SOURCE_RE.test(file) || m && NODE_MODULES_RE.test(m.source)) return void 0;
+			last_at = {
+				path: m ? m.source : site.file,
+				line
+			};
+			return name ? `${name} (${file}:${line})` : `${file}:${line}`;
+		};
+		for (const c of cap.net) {
+			const ats = [];
+			const chain = (c.caller_chain ?? (c.caller_site ? [c.caller_site] : [])).map((site) => {
+				const text = resolve_caller(site);
+				if (text && last_at && ats.length < 2) ats.push(last_at);
+				return text;
+			}).filter((s) => !!s);
+			c.caller = chain[0] ?? c.caller;
+			if (ats[0]) c.caller_at = ats[0];
+			if (ats[1]) c.outer_at = ats[1];
+			if (chain.length > 1) c.callers = chain;
+			delete c.caller_site;
+			delete c.caller_chain;
+		}
+		for (const o of cap.io_ops) {
+			o.caller = resolve_caller(o.caller_site);
+			if (o.caller && last_at) o.caller_at = last_at;
+			delete o.caller_site;
+		}
+		for (const s of cap.spans) {
+			s.caller = resolve_caller(s.caller_site);
+			delete s.caller_site;
+		}
+		if (cap.promises) {
+			const merged = /* @__PURE__ */ new Map();
+			for (const t of cap.promises.top) {
+				const m = t.site ? resolver?.resolve(t.site.file, Math.max(0, t.site.line - 1), Math.max(0, t.site.column - 1)) : void 0;
+				const src = m?.source ?? t.site?.file ?? "";
+				const nm = src.lastIndexOf("/node_modules/");
+				const fn = m?.name ?? t.site?.fn ?? "";
+				const caller = !t.site ? t.caller : nm !== -1 ? `${fn} (${pkg_of(src.slice(nm + 14))})` : m ? `${fn} (${rel_src(m.source)}:${m.line})` : t.caller;
+				merged.set(caller, (merged.get(caller) ?? 0) + t.share);
+			}
+			cap.promises = {
+				count: cap.promises.count,
+				top: [...merged].sort((a, b) => b[1] - a[1]).map(([caller, share]) => ({
+					caller,
+					share: Math.round(share * 100) / 100
+				}))
+			};
+		}
+		const requests = this.#ring.filter((e) => e.ts + e.ms >= cap.t0 && e.ts <= cap.t1);
+		const page_path = meta_partial.page?.split("?")[0];
+		const own_route = meta_partial.trigger === "page" ? requests.find((e) => e.internal && e.path === page_path && e.route)?.route : meta_partial.request?.route;
+		const timeline_input = cap.window ? {
+			...this.#timeline_input(cap),
+			...own_route ? { route: own_route } : {}
+		} : void 0;
+		const analysis = analyze(cap.profile, resolver, cap.call_counts, timeline_input, island_host_renamer(requests), this.#module_hint);
+		const id = Math.random().toString(36).slice(2, 10);
+		const meta = {
+			id,
+			created: cap.t0,
+			duration_ms: round2(cap.duration_ms),
+			sample_interval_us: this.sample_interval,
+			requests,
+			loop_delay: cap.loop,
+			cpu_percent: cap.cpu_percent,
+			elu_percent: cap.elu_percent,
+			rss_mb: cap.mem.at(-1)?.rss,
+			node: process.version,
+			dev: this.dev || void 0,
+			...meta_partial
+		};
+		let gc_attr;
+		if (cap.gc_slices?.length && (cap.gc_events?.length || Object.keys(cap.gc_dict ?? {}).length)) try {
+			if (resolver && cap.gc_dict) {
+				const short = (u) => u.replace(/^file:\/\//, "").split("/").slice(-2).join("/");
+				for (const site of Object.values(cap.gc_dict)) {
+					const m = site.url ? resolver.resolve(site.url, site.line - 1, 0) : void 0;
+					if (m) {
+						site.url = m.source;
+						site.line = m.line;
+						const c = categorize({
+							functionName: site.name,
+							url: m.source,
+							lineNumber: m.line - 1,
+							columnNumber: 0,
+							scriptId: ""
+						});
+						if (site.category !== "component" && c.category !== "component") site.category = c.category;
+					}
+					let caller_at;
+					if (site.caller_url && site.caller_name) {
+						const c = resolver.resolve(site.caller_url, (site.caller_line ?? 1) - 1, 0);
+						if (c) {
+							site.caller = `${site.caller_name} (${short(c.source)}:${c.line})`;
+							caller_at = {
+								path: c.source,
+								line: c.line
+							};
+							if (site.category !== "component" && categorize({
+								functionName: site.caller_name,
+								url: c.source,
+								lineNumber: 0,
+								columnNumber: 0,
+								scriptId: ""
+							}).category === "profiler") site.category = "profiler";
+						}
+					}
+					if ((site.category === "app" || site.category === "component") && m) site.at = {
+						path: m.source,
+						line: m.line
+					};
+					else if (caller_at) site.at = caller_at;
+					else if (!m) {
+						const at = this.#chunk_at(site.url, site.line) ?? this.#chunk_at(site.caller_url, site.caller_line);
+						if (at) site.at = at;
+					}
+				}
+			}
+			const first = cap.mem[0]?.heap_used;
+			const last = cap.mem[cap.mem.length - 1]?.heap_used;
+			const window_offset_ms = cap.window ? round2(cap.window.start - cap.perf_start) : 0;
+			gc_attr = attribute_gc({
+				slices: cap.gc_slices,
+				events: cap.gc_events ?? [],
+				dict: cap.gc_dict ?? {},
+				window_ms: cap.duration_ms,
+				...analysis.capture_cpu ? { running: analysis.capture_cpu } : analysis.timeline ? { running: analysis.timeline.segments.filter((s) => s.kind === "cpu").map((s) => ({
+					t0: s.t0 + window_offset_ms,
+					t1: s.t1 + window_offset_ms,
+					label: s.label,
+					category: s.category,
+					file: s.file
+				})) } : {},
+				...first !== void 0 && last !== void 0 ? { retained_mb: last - first } : {}
+			});
+			gc_attr.window_offset_ms = window_offset_ms;
+		} catch (e) {
+			if (process.env.OGYGIA_PROFILER_DEBUG) console.error("[ogygia/profiler] GC attribution failed:", e);
+			gc_attr = void 0;
+		}
+		{
+			const cpu_over = analysis.overhead_ms;
+			const gc_over = gc_attr?.summary.overhead_ms ?? 0;
+			const n = meta.runs?.length ?? 0;
+			const per_run = Array.from({ length: n }, () => 0);
+			const cpu_in_runs = analysis.overhead_by_run_ms ?? [];
+			for (let i = 0; i < n; i++) per_run[i] += cpu_in_runs[i] ?? 0;
+			if (gc_attr && cap.runs?.length) for (const p of gc_attr.pauses) {
+				const t_abs = cap.perf_start + p.t;
+				const i = cap.runs.findIndex((r) => t_abs >= r.start && t_abs <= r.end);
+				if (i !== -1) per_run[i] += p.ms_measured - p.ms;
+			}
+			const in_runs = per_run.reduce((a, b) => a + b, 0);
+			meta.overhead = {
+				cpu_ms: round2(cpu_over),
+				gc_ms: round2(gc_over),
+				per_run_ms: n ? round2(in_runs / n) : 0,
+				...n ? { per_run: per_run.map(round2) } : {},
+				note: "the profiler’s own CPU frames and its share of the GC pauses, taken out of every number in this report: each run loses exactly what fell inside it; the start-up scan of compiled code and the final reads sit outside the runs. The sampler’s own thread and the inspector’s are not visible from inside and are not taken out."
+			};
+			if (n && in_runs > 0) {
+				meta.runs_measured = [...meta.runs];
+				meta.runs = meta.runs.map((r, i) => round2(Math.max(0, r - per_run[i])));
+			}
+		}
+		const gc = gc_attr ? {
+			count: gc_attr.summary.count,
+			total_ms: gc_attr.summary.total_ms,
+			max_ms: gc_attr.summary.max_ms
+		} : cap.gc_pauses.length ? {
+			count: cap.gc_pauses.length,
+			total_ms: round2(cap.gc_pauses.reduce((a, c) => a + c, 0)),
+			max_ms: round2(Math.max(...cap.gc_pauses))
+		} : null;
+		const raw_json = JSON.stringify(cap.profile);
+		let raw = raw_json;
+		try {
+			const { gzipSync } = await import("node:zlib");
+			raw = gzipSync(raw_json);
+		} catch {}
+		let weights;
+		let contents;
+		let heavy;
+		let barrels;
+		let hazards;
+		if (fetch_url && !this.dev) {
+			const urls = [];
+			for (const r of island_rows_of(meta)) urls.push(r.module_url, ...r.hints);
+			if (urls.length) weights = await weigh_urls(urls, fetch_url, this.#weights);
+			for (const u of new Set(urls)) {
+				const inside = chunkContents(u);
+				if (inside?.length) (contents ??= {})[u] = inside;
+				const h = chunkHeavy(u);
+				if (h?.top.length) (heavy ??= {})[u] = h;
+				const b = chunkBarrels(u);
+				if (b?.length) (barrels ??= {})[u] = b;
+			}
+			for (const r of island_rows_of(meta)) {
+				const built = islandHazards(r.entry);
+				if (built?.length) (hazards ??= {})[r.entry] = built;
+			}
+			if (contents) {
+				const read = await this.#source_reader();
+				for (const r of island_rows_of(meta)) {
+					if (hazards?.[r.entry]) continue;
+					const files = /* @__PURE__ */ new Set();
+					for (const u of [r.module_url, ...r.hints]) for (const f of contents[u] ?? []) if (f.endsWith(".svelte") && f.startsWith("src/")) files.add(f);
+					const found = [];
+					for (const f of files) {
+						const src = read(f.slice(4)) ?? read(f);
+						if (src) for (const h of hydration_hazards(src).slice(0, 3)) found.push({
+							file: f,
+							...h
+						});
+					}
+					if (found.length) (hazards ??= {})[r.entry] = found.slice(0, 5);
+				}
+			}
+		}
+		let alloc;
+		if (cap.heap_series?.length) try {
+			const window_offset_ms = cap.window ? round2(cap.window.start - cap.perf_start) : 0;
+			alloc = alloc_timeline({
+				samples: cap.heap_series,
+				...analysis.capture_cpu ? { running: analysis.capture_cpu } : analysis.timeline ? { running: analysis.timeline.segments.filter((s) => s.kind === "cpu").map((s) => ({
+					t0: s.t0 + window_offset_ms,
+					t1: s.t1 + window_offset_ms,
+					label: s.label,
+					category: s.category,
+					file: s.file
+				})) } : {},
+				gc: (cap.gc_events ?? []).map((g) => ({
+					t: g.t,
+					ms: g.ms
+				})),
+				...cap.window ? { window: {
+					offset_ms: window_offset_ms,
+					ms: round2(cap.window.end - cap.window.start)
+				} } : {}
+			});
+		} catch {
+			alloc = void 0;
+		}
+		let contended;
+		{
+			const windows = cap.runs?.length ? cap.runs : cap.window ? [cap.window] : [];
+			if (windows.length) try {
+				const self_paths = /* @__PURE__ */ new Set();
+				for (const c of cap.net) {
+					const at = c.url.indexOf("://");
+					const rest = at === -1 ? c.url : c.url.slice(c.url.indexOf("/", at + 3));
+					const q = rest.indexOf("?");
+					self_paths.add(q === -1 ? rest : rest.slice(0, q));
+				}
+				contended = contention({
+					requests: this.#ring,
+					windows,
+					own: this.#ring.filter((e) => e.internal && e.pt !== void 0 && windows.some((w) => e.pt >= w.start - 1 && e.pt <= w.end)),
+					self_paths
+				});
+			} catch {
+				contended = void 0;
+			}
+		}
+		this.#reports.set(id, {
+			meta,
+			analysis,
+			heap,
+			heap_components,
+			net: cap.net,
+			spans: cap.spans,
+			mem: cap.mem,
+			measures: cap.measures,
+			gc,
+			io: cap.io_ops,
+			...cap.promises ? { promises: cap.promises } : {},
+			call_counts: cap.call_counts,
+			raw,
+			...weights ? { weights } : {},
+			...contents ? { contents } : {},
+			...heavy ? { heavy } : {},
+			...barrels ? { barrels } : {},
+			...hazards ? { hazards } : {},
+			...gc_attr ? { gc_attr } : {},
+			...alloc ? { alloc } : {},
+			...contended ? { contention: contended } : {}
+		});
+		if (meta_partial.trigger !== "page") {
+			const s = this.#reports.get(id);
+			try {
+				await this.#lines_for(s, void 0, cap.window?.start);
+			} catch {}
+		}
+		if (meta_partial.trigger !== "page") this.#persist(this.#reports.get(id));
+		while (this.#reports.size > this.max_reports) {
+			const oldest = this.#reports.keys().next().value;
+			if (oldest === void 0) break;
+			this.#reports.delete(oldest);
+		}
+		return id;
+	}
+	async #key_matches(provided) {
+		if (this.dev) return true;
+		if (!this.secret || !provided) return false;
+		try {
+			const { createHash, timingSafeEqual } = await import("node:crypto");
+			const h = (str) => createHash("sha256").update(str).digest();
+			return timingSafeEqual(h(provided), h(this.secret)) || timingSafeEqual(h(provided), h(this.#cookie_token(createHash)));
+		} catch {
+			return provided === this.secret;
+		}
+	}
+	#cookie_token(createHash) {
+		return createHash("sha256").update("og-profiler:" + this.secret).digest("hex");
+	}
+	/** Cookie header that starts / clears a profiler session (Set-Cookie value). */
+	#session_cookie(token, event) {
+		const secure = event.url.protocol === "https:" ? "; Secure" : "";
+		const clear = token === "" ? "; Max-Age=0" : "";
+		const age = token === "" ? "" : "; Max-Age=31536000";
+		return `${SESSION_COOKIE}=${token}; Path=${this.base}; HttpOnly; SameSite=Lax${secure}${clear}${age}`;
+	}
+	/** The BEACON FLAG: a second cookie, site-wide, carrying no secret — it only tells the handle
+	*  "this browser is the profiler's user, put the beacon tag in its documents". The session
+	*  cookie stays scoped to the profiler's own path (the `/beacon` POST is under it, so the
+	*  runtime's post still carries the real session). Set with the session, cleared with it. */
+	#beacon_cookie(on, event) {
+		const secure = event.url.protocol === "https:" ? "; Secure" : "";
+		return `og_profiler_beacon=${on ? "1" : ""}; Path=/; HttpOnly; SameSite=Lax${secure}${on ? "" : "; Max-Age=0"}`;
+	}
+	/**
+	* Validate + set up a session. The unlock page POSTs the key here; a match sets the session cookie
+	* and returns to `next`. No HTTP Basic dialog — a plain form + cookie, so the `Authorization` header
+	* is never spent on profiler auth (it stays free, and there's a real Logout).
+	*/
+	async #login(ctx) {
+		const body = await ctx.request.json().catch(() => null);
+		const key = String(body?.key ?? "");
+		const next = this.#safe_next(String(body?.next ?? this.base));
+		if (!await this.#key_matches(key)) return ctx.json({ ok: false }, { status: 401 });
+		const { createHash } = await import("node:crypto");
+		const res = ctx.json({
+			ok: true,
+			next: next + (next.includes("?") ? "&" : "?") + AFTER_LOGIN_PARAM + "=1"
+		});
+		res.headers.set("cache-control", "no-store, private");
+		res.headers.append("set-cookie", this.#session_cookie(this.#cookie_token(createHash), ctx.event));
+		return res;
+	}
+	/** false = denied; true = authed; string = authed AND set this cookie */
+	async #authed(event) {
+		if (!this.ui_enabled) return false;
+		if (this.dev) return true;
+		for (const value of session_cookie_values(event)) if (await this.#key_matches(value)) return true;
+		return this.#key_matches(event.request.headers.get("x-profiler-key"));
+	}
+	/**
+	* What a request that failed auth carried, for a browser that loops on login — no cookie values,
+	* only facts: did a Cookie header arrive, how big, how many `og_profiler` pairs were in it, and
+	* did Kit's own parser find one. 0 pairs with a header = the cookie never reached the server
+	* (dropped on the way, or the jar is past a proxy's limit); pairs but no parse = a parser problem;
+	* more than one pair = duplicates, one of them stale.
+	*/
+	#cookie_diagnosis(event) {
+		const raw = event.request.headers.get("cookie");
+		return {
+			header: raw != null,
+			bytes: raw?.length ?? 0,
+			pairs: raw ? raw_cookie_values(raw, SESSION_COOKIE).length : 0,
+			parsed: event.cookies.get(SESSION_COOKIE) != null
+		};
+	}
+	async #ui(event) {
+		const res = await this.#router().fetch(event.request, event) ?? new Response("Not found", { status: 404 });
+		return this.#flag_cookie(event, await gzip_large(event.request, res));
+	}
+	/** THE BEACON FLAG follows the session, one response later: set on the first response to a
+	*  browser whose session cookie is good and that lacks the flag, cleared on one to a browser with
+	*  the flag and no session. Never beside another Set-Cookie (the login's, the logout's): a host
+	*  that keeps one per response must not lose the session for it. */
+	async #flag_cookie(event, res) {
+		if (this.dev || !this.secret || res.headers.has("set-cookie")) return res;
+		const flag = event.cookies.get("og_profiler_beacon") === "1";
+		const values = session_cookie_values(event);
+		let session = false;
+		for (const v of values) if (await this.#key_matches(v)) session = true;
+		if (session === flag) return res;
+		const out = new Response(res.body, res);
+		out.headers.append("set-cookie", this.#beacon_cookie(session, event));
+		return out;
+	}
+	async #auth_guard(ctx) {
+		const rel = ctx.url.pathname.slice(this.base.length).replace(TRAILING_SLASH_RE, "") || "/";
+		if (rel === "/login" || rel === "/logout" || /^\/report\/[^/.]+$/.test(rel)) return;
+		if (await this.#authed(ctx.event)) return;
+		if (this.ui_enabled && this.secret && !this.dev) {
+			const after_login = ctx.url.searchParams.has(AFTER_LOGIN_PARAM);
+			const diag = this.#cookie_diagnosis(ctx.event);
+			if (after_login || diag.pairs > 0) console.warn(`[ogygia profiler] session not accepted on ${ctx.url.pathname}: ${JSON.stringify(diag)} — ${describe_cookie_diagnosis(diag)}`);
+			const target = new URL(ctx.url);
+			target.searchParams.delete(AFTER_LOGIN_PARAM);
+			const next = encodeURIComponent(target.pathname + target.search);
+			return ctx.redirect(`${this.base}/login?next=${next}${after_login ? `&${LOGIN_FAILED_PARAM}=1` : ""}`);
+		}
+		return new Response("Not found", { status: 404 });
+	}
+	#routes;
+	#router() {
+		return this.#routes ??= build_profiler_router({
+			base: this.base,
+			auth_guard: (c) => this.#auth_guard(c),
+			authed: (c) => this.#authed(c.event),
+			beacon: (c) => this.#beacon(c),
+			replay: (id, c) => this.#replay(id, c),
+			dashboard: (c) => this.#dashboard(c.url.searchParams.get("by")),
+			run_page: (c) => this.#run_page(c),
+			record_page: (c) => this.#record_page(c),
+			window_start: (c) => this.#window_start(c),
+			window_stop: (c) => this.#window_stop(c),
+			reset: (c) => this.#reset(c),
+			status: () => ({
+				recording: this.#recorder_busy || this.#recording_active(),
+				inflight: this.#inflight,
+				rss_mb: Math.round(process.memoryUsage().rss / 1048576),
+				reports: this.#reports.size
+			}),
+			login_props: (c) => ({
+				base: this.base,
+				next: this.#safe_next(c.url.searchParams.get("next")),
+				session_problem: c.url.searchParams.has(LOGIN_FAILED_PARAM) ? describe_cookie_diagnosis(this.#cookie_diagnosis(c.event)) : null
+			}),
+			login: (c) => this.#login(c),
+			logout: (c) => this.#logout(c),
+			upload: (c) => this.#upload(c),
+			report_stored: (id) => this.#reports.get(id ?? ""),
+			report_load: (id) => this.#report_load(id),
+			list_stored: (limit) => this.#list_stored(limit),
+			login_url: (c) => this.ui_enabled && this.secret && !this.dev ? `${this.base}/login?next=${encodeURIComponent(c.url.pathname)}` : null,
+			report_view: (stored) => this.#report_view(stored),
+			report_json: (stored) => this.#report_json(stored),
+			report_dump_json: (stored) => this.#report_dump_json(stored),
+			report_html: (stored, c) => this.#report_html(stored, c),
+			report_posted: (c, as) => this.#report_posted(c, as),
+			report_raw: (stored) => this.#report_raw(stored),
+			compare: (a, b) => this.#compare(a, b),
+			site: (c) => this.#site(c),
+			source: (c) => this.#source(c)
+		});
+	}
+	/**
+	* THE TIMELINE INPUT: the one request's window + every call it waited on. Net calls as they
+	* are. I/O primitives only when they are the app's own wait — the same rule as the "Waiting by
+	* function" table: the op must have a resolved app caller (an unattributed one is undici's
+	* socket timer, a response compressor's zlib stream, the recorder's own timer; a WASM caller
+	* is a library's internals) — and an op that sits inside a net call's span is the other end of
+	* that same call (an in-process API's timer on a self-fetch); the net call already says it.
+	* Each call carries the phase of the code that started it, from the caller's file.
+	*/
+	#timeline_input(cap) {
+		const w = cap.window;
+		const phase_of = (caller) => {
+			const m = caller ? CALLER_FILE_RE.exec(caller) : null;
+			return m ? phase_of_frame({
+				name: "",
+				url: m[1],
+				line: 0,
+				category: "app"
+			}) ?? void 0 : void 0;
+		};
+		const net = cap.net.filter((c) => c.ms >= 0).map((c) => ({
+			start: c.start,
+			end: c.start + c.ms + (c.body_ms ?? 0),
+			c
+		}));
+		const inside_a_call = (s, e) => net.some((n) => s >= n.start - 2 && e <= n.end + 2);
+		const overlaps_a_call = (s, e) => net.some((n) => s < n.end && e > n.start);
+		const is_handler_side = (o) => !!o.caller && SERVER_ROUTE_FILE_RE.test(o.caller) && overlaps_a_call(o.start, o.start + o.ms);
+		return {
+			perf_start: cap.perf_start,
+			window: w,
+			...cap.runs ? { runs: cap.runs } : {},
+			...cap.set_aside?.length ? { set_aside: cap.set_aside } : {},
+			pending: cap.io_ops.filter((o) => o.start <= w.end && o.start + Math.max(o.ms, 0) >= w.start).map((o) => ({
+				start: o.start,
+				end: o.open ? w.end : o.start + o.ms,
+				label: o.caller ? `${o.type} from ${o.caller}` : o.type,
+				kind: io_kind(o.type)
+			})),
+			calls: [
+				...cap.spans.filter((s) => !s.open && s.ms >= 0).map((s) => ({
+					start: s.start,
+					ms: s.ms,
+					label: s.name,
+					kind: "span",
+					caller: s.caller,
+					phase: phase_of(s.caller)
+				})),
+				...cap.net.map((c) => ({
+					start: c.start,
+					ms: c.ms < 0 ? -1 : c.ms + (c.body_ms ?? 0),
+					label: label_call(c.method, c.url),
+					kind: "net",
+					caller: c.caller,
+					phase: phase_of(c.caller),
+					...c.callers ? { callers: c.callers } : {},
+					...c.timings ? { timings: c.timings } : {},
+					...c.ms >= 0 && c.body_ms ? { body_ms: c.body_ms } : {}
+				})),
+				...cap.io_ops.filter((o) => !o.open && o.ms >= .5 && o.type !== "Immediate" && o.type !== "TickObject" && !!o.caller && !o.caller.startsWith("/wasm/") && !o.caller.includes("(/wasm/") && !inside_a_call(o.start, o.start + o.ms) && !is_handler_side(o)).map((o) => ({
+					start: o.start,
+					ms: o.ms,
+					label: `${io_kind(o.type)}${o.caller ? ` · ${o.caller}` : ""}`,
+					kind: io_kind(o.type),
+					caller: o.caller,
+					phase: phase_of(o.caller)
+				}))
+			]
+		};
+	}
+	/**
+	* The report as ONE self-contained HTML file (profiler/standalone.ts): the page is rendered
+	* through this very server (a self-request, marked internal so it is not logged as traffic),
+	* then every stylesheet, the runtime and every island chunk it reaches are fetched the same way
+	* and inlined. Needs a BUILT app: a dev server's module graph is Vite's, hundreds of unbundled
+	* files with transforms — not a thing one file can carry.
+	*/
+	async #report_html(stored, ctx) {
+		if (this.dev) return new Response("The standalone HTML export needs a built app (vite build + preview, or your production deploy): on the dev server the page’s code is hundreds of unbundled modules. Export the .ogp here and open it on a built server, or run the export there.", {
+			status: 400,
+			headers: { "content-type": "text/plain; charset=utf-8" }
+		});
+		const page_url = `${ctx.url.origin}${this.base}/report/${stored.meta.id}`;
+		const headers = { "x-og-profiler-internal": "1" };
+		if (this.secret) headers["x-profiler-key"] = this.secret;
+		const load = async (url) => {
+			for (const f of ctx.fetch === fetch ? [fetch] : [ctx.fetch, fetch]) try {
+				const res = await f(url, { headers });
+				if (res.ok) return await res.text();
+			} catch {}
+			return null;
+		};
+		const html = await load(page_url);
+		if (html === null) return new Response("Could not render the report page.", { status: 502 });
+		const { build_standalone } = await import("./standalone.js");
+		try {
+			const out = await build_standalone(html, {
+				page_url,
+				load
+			});
+			return new Response(out, { headers: {
+				"content-type": "text/html; charset=utf-8",
+				"content-disposition": `attachment; filename="ogygia-profile-${stored.meta.id}.html"`,
+				"cache-control": "no-store"
+			} });
+		} catch (e) {
+			return new Response(e instanceof Error ? e.message : "standalone export failed", { status: 500 });
+		}
+	}
+	/** A report's representations (the standalone file, the agent JSON, the plain dump) from a report
+	*  the request carries: the page's .ogp bytes or the browser's kept copy. On a serverless host the
+	*  instance that made the report is rarely the one a later request lands on; with the report in
+	*  the request, any instance answers. It is held in this instance's memory under its own id, so
+	*  the in-process render of the report page (the standalone file) finds it too. */
+	async #report_posted(ctx, as) {
+		const id = ctx.params.id;
+		if (!id) return new Response("No report id.", { status: 400 });
+		let dump;
+		try {
+			const raw = new Uint8Array(await ctx.request.arrayBuffer());
+			if ((ctx.request.headers.get("content-type") ?? "").startsWith("application/octet-stream")) {
+				const bytes = recover_ogp_bytes(raw);
+				if (!is_ogp(bytes)) return new Response("That is not an ogygia .ogp report.", { status: 400 });
+				dump = await ogp_decode(bytes, this.secret);
+			} else if (ctx.request.headers.get("x-og-encoding") === "gzip") {
+				const { gunzipSync } = await import("node:zlib");
+				dump = JSON.parse(new TextDecoder().decode(gunzipSync(raw)));
+			} else dump = JSON.parse(new TextDecoder().decode(raw));
+		} catch {
+			return new Response("The request carried no report this server can open.", { status: 400 });
+		}
+		if (!is_dump(dump)) return new Response("That is not an ogygia profiler report.", { status: 400 });
+		let stored = this.#reports.get(id);
+		if (!stored) {
+			stored = this.#report_from_dump({
+				...dump,
+				meta: {
+					...dump.meta,
+					id
+				}
+			});
+			this.#reports.set(id, stored);
+			while (this.#reports.size > this.max_reports) {
+				const oldest = this.#reports.keys().next().value;
+				if (oldest === void 0) break;
+				this.#reports.delete(oldest);
+			}
+		}
+		if (as === "html") return this.#report_html(stored, ctx);
+		if (as === "json") return this.#report_json(stored);
+		if (as === "ogp") return this.#ogp_response(id, stored);
+		return this.#report_dump_json(stored);
+	}
+	/** Two stored reports side by side (compare.ts); a 404 when either has expired. */
+	/** THE DATA RIVER for a page report: the last run's calls on their load lanes, what each load's
+	*  source returns, what each island reads (the build's page keys), the seed's bytes per key. */
+	async #river_for(stored, body, last_window) {
+		const tl = stored.analysis.timeline;
+		if (!tl) return void 0;
+		const lanes = tl.lanes ?? [];
+		if (!lanes.length && !stored.net.length) return void 0;
+		const read = await this.#source_reader();
+		const lane_files = [...new Set(lanes.map((l) => l.file))];
+		const river_lanes = lane_files.map((file) => {
+			const src = read(file);
+			return {
+				file,
+				keys: src ? load_return_keys(src) : null
+			};
+		});
+		const calls = stored.net.filter((c) => !last_window || c.start >= last_window.start && c.start <= last_window.end).map((c) => {
+			const text = [
+				c.caller_site?.file ?? "",
+				...c.callers ?? [],
+				c.caller ?? ""
+			].join(" ");
+			const lane = load_lane_of(text)?.file ?? null;
+			return {
+				lane: lane && lane_files.includes(lane) ? lane : lane_files.find((f) => lane && (f.endsWith(lane) || lane.endsWith(f))) ?? null,
+				label: `${c.method} ${c.url}`,
+				ms: Math.max(c.ms, 0) + (c.body_ms ?? 0)
+			};
+		});
+		const by_entry = /* @__PURE__ */ new Map();
+		for (const r of island_rows_of(stored.meta)) {
+			if (by_entry.has(r.entry)) continue;
+			let keys = null;
+			const dev = await this.#dev_island_keys(r.entry);
+			if (dev) keys = dev.keys === "all" ? null : dev.keys ?? [];
+			else try {
+				keys = islandPageKeys(r.entry);
+			} catch {
+				keys = null;
+			}
+			by_entry.set(r.entry, {
+				name: island_name(r),
+				keys
+			});
+		}
+		const seed_m = SEED_SCRIPT_RE.exec(body);
+		const seed = seed_m ? seed_key_bytes(seed_m[1]) : {};
+		if (!calls.length && !Object.keys(seed).length && !by_entry.size) return void 0;
+		return build_river({
+			calls,
+			lanes: river_lanes,
+			islands: [...by_entry.values()],
+			seed
+		});
+	}
+	/** THE LINE LEDGER (ledger.ts): the app lines that cost the most — CPU per line, the bytes each
+	*  allocated and the GC that caused, what a render kept — joined per line, with the code read
+	*  from the source map's embedded copy (so it shows on a deployed host). Then THE PATTERNS
+	*  (patterns.ts): the known slow shapes recognised on those lines. Both land on the report. */
+	/** `w0`: the profiled window's start (performance.now()), the clock the timeline's await graph
+	*  counts from; the waits' critical-path check lines the chains up on it */
+	async #lines_for(s, uninlined_profile, w0, stable, wait_runs, almost) {
+		const resolver = await this.#make_resolver();
+		let uninlined;
+		if (uninlined_profile) try {
+			uninlined = analyze(uninlined_profile, resolver, void 0, void 0, void 0, this.#module_hint).functions;
+		} catch {
+			uninlined = void 0;
+		}
+		const fns = /* @__PURE__ */ new Map();
+		for (const f of s.analysis.functions) fns.set(f.key, f);
+		for (const c of s.analysis.components) {
+			const e = fns.get(c.key);
+			if (!e || !e.lines?.length && c.lines?.length) fns.set(c.key, c);
+		}
+		const ledger = build_ledger({
+			functions: [...fns.values()],
+			makers: s.gc_attr?.makers,
+			retained: s.retained?.sites,
+			...s.growth?.sites ? { grown: {
+				renders: s.growth.renders,
+				sites: s.growth.sites,
+				...s.growth.half_sites && s.growth.half_renders ? { half: {
+					renders: s.growth.half_renders,
+					sites: s.growth.half_sites
+				} } : {}
+			} } : {},
+			code: (p, l) => resolver?.source_lines(p, l, l)?.lines[0],
+			source: resolver ? (p, a, b) => resolver.source_lines(p, a, b) : void 0,
+			...uninlined ? {
+				uninlined,
+				renders: s.meta.trigger === "page" ? s.meta.runs?.length || 1 : 1
+			} : {},
+			limit: LEDGER_FOR_PATTERNS
+		});
+		const source = resolver ? (p, a, b) => resolver.source_lines(p, a, b) : void 0;
+		for (const l of ledger) this.#label_module(l);
+		if (ledger.length) s.ledger = ledger.slice(0, LEDGER_SHOWN);
+		const renders = s.meta.trigger === "page" ? s.meta.runs?.length || 1 : 1;
+		let heap;
+		try {
+			const st = (await import("node:v8")).getHeapStatistics();
+			heap = {
+				limit_bytes: st.heap_size_limit,
+				used_bytes: st.used_heap_size
+			};
+			const fn_mb = Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE);
+			if (fn_mb > 0 && fn_mb * 1024 * 1024 < heap.limit_bytes) heap = {
+				limit_bytes: fn_mb * 1024 * 1024,
+				used_bytes: process.memoryUsage().rss,
+				function: true
+			};
+		} catch {}
+		const patterns = ledger.length ? find_patterns({
+			ledger,
+			functions: [...fns.values()],
+			source,
+			renders,
+			heap,
+			growth: s.growth
+		}) : [];
+		const calls = [];
+		for (const c of s.net) {
+			if (c.ms < 0 || !c.caller_at) continue;
+			const { host, tpl } = path_template(c.url);
+			calls.push({
+				start: c.start,
+				ms: c.ms + (c.body_ms ?? 0),
+				target: `${c.method} ${host}${tpl}`,
+				at: c.caller_at,
+				...c.outer_at ? { outer: c.outer_at } : {},
+				scope: c.path,
+				...c.method === "GET" || c.method === "HEAD" ? { exact: `${c.method} ${c.url}` } : {},
+				...c.bytes !== void 0 ? { bytes: c.bytes } : {},
+				...c.personal ? { personal: true } : {},
+				...c.headers?.["cache-control"] ? { cache: c.headers["cache-control"] } : {}
+			});
+		}
+		for (const o of s.io ?? []) {
+			const target = WAIT_TARGET[o.type];
+			if (!target || o.open || !o.caller_at) continue;
+			calls.push({
+				start: o.start,
+				ms: o.ms,
+				target,
+				at: o.caller_at
+			});
+		}
+		const waits = find_wait_patterns({
+			calls,
+			source
+		});
+		const tl = s.analysis.timeline;
+		for (const p of waits) {
+			if (p.kind !== "waits-in-a-row" || w0 === void 0 || !tl) continue;
+			const on_path = wait_save_on_path(p, tl.awaits, tl.window_ms, w0);
+			if (!on_path || on_path.save_ms >= p.save_ms * .8) continue;
+			p.naive_save_ms = p.save_ms;
+			p.save_ms = on_path.save_ms;
+			p.evidence += `. Started together they would save ${p.naive_save_ms} ms of waiting, but only about ${on_path.save_ms} ms comes off the render` + (on_path.bound_by ? `: ${on_path.bound_by} runs about as long beside them and still sets the end` : ": other work runs as long beside them");
+		}
+		patterns.push(...waits);
+		if (stable?.size) {
+			const same = find_same_answers({
+				calls,
+				stable,
+				source,
+				...tl?.awaits && w0 !== void 0 ? {
+					awaits: tl.awaits,
+					w0
+				} : {}
+			});
+			if (same) patterns.push(same);
+		}
+		if (almost?.size) {
+			const near = find_same_answers({
+				calls,
+				stable: new Set(almost.keys()),
+				almost,
+				source,
+				...tl?.awaits && w0 !== void 0 ? {
+					awaits: tl.awaits,
+					w0
+				} : {}
+			});
+			if (near) patterns.push(near);
+		}
+		if (source && Object.keys(s.call_counts).length) {
+			const cold = find_cold_caches({
+				functions: [...fns.values()],
+				call_counts: s.call_counts,
+				source
+			});
+			if (cold) patterns.push(cold);
+		}
+		const og = own_requests(s.meta).find((r) => r.og?.seed)?.og;
+		const whole = s.lineage?.components.filter((c) => c.island && c.whole && c.whole_line) ?? [];
+		if (og?.seed && whole.length) {
+			const read = await this.#source_reader();
+			const readers = [];
+			for (const c of whole) {
+				const lines = read(c.file)?.split("\n");
+				const at = c.whole_line;
+				if (!lines?.[at - 1]) continue;
+				const from = Math.max(1, at - 2);
+				readers.push({
+					name: c.name,
+					file: c.file,
+					line: at,
+					code: lines[at - 1].trim(),
+					context: {
+						start: from,
+						lines: lines.slice(from - 1, at + 2)
+					}
+				});
+			}
+			const top = og.seed.keys.find((k) => k.shipped);
+			const p = seed_whole_pattern(readers, og.seed_bytes, top ? {
+				key: top.key,
+				bytes: top.bytes
+			} : void 0);
+			if (p) patterns.push(p);
+		}
+		const load_files = [...new Set((s.analysis.timeline?.lanes ?? []).map((l) => l.file))];
+		if (load_files.length) {
+			const read = await this.#source_reader();
+			const work = [];
+			const unread_keys = new Set((s.lineage?.keys ?? []).filter((k) => k.verdict === "unread").map((k) => k.key));
+			const feeds_only_unread = (file, line) => {
+				const fed = (s.lineage?.sources ?? []).filter((x) => x.from === file && x.lines.includes(line));
+				return fed.length > 0 && fed.every((x) => unread_keys.has(x.key));
+			};
+			for (const file of load_files) {
+				const src = read(file);
+				if (!src) continue;
+				const lines = src.split("\n");
+				for (const w of constant_work(src)) {
+					if (feeds_only_unread(file, w.line)) continue;
+					const own = ledger.filter((l) => l.line === w.line && (l.file.endsWith(file) || file.endsWith(l.file))).reduce((t, l) => t + l.cpu_ms + l.lib_ms, 0);
+					const called = w.calls.reduce((t, c) => {
+						const mod = imported_from(src, c, file);
+						return t + [...fns.values()].filter((f) => f.name === c && f.category === "app" && !!mod && f.path.includes(`/${mod}.`)).reduce((u, f) => u + f.total_ms, 0);
+					}, 0);
+					const from = Math.max(1, w.line - 2);
+					work.push({
+						path: file,
+						file,
+						line: w.line,
+						code: lines[w.line - 1].trim(),
+						names: w.names,
+						calls: w.calls,
+						cpu_ms: own + called,
+						context: {
+							start: from,
+							lines: lines.slice(from - 1, w.line + 2)
+						}
+					});
+				}
+			}
+			const p = same_work_pattern(work, renders);
+			if (p) {
+				const file = p.sites[0].path;
+				const src = read(file);
+				const plan = src ? hoist_plan(src) : null;
+				if (src && plan) {
+					const lines = src.split("\n");
+					const stmt = (x) => lines.slice(x.line - 1, x.end);
+					const dedent = (ls) => ls.map((l) => l.startsWith("	") ? l.slice(1) : l.startsWith("  ") ? l.slice(2) : l);
+					p.sites[0].rewrite = {
+						file,
+						line: plan.stmts[0].line,
+						before: plan.stmts.map((x) => stmt(x).join("\n")).join("\n	// …\n"),
+						after: `// at the top level, above line ${plan.above} (\`export … load\`), unchanged, and gone from load():\n${plan.stmts.map((x) => dedent(stmt(x)).join("\n")).join("\n")}`
+					};
+				}
+				patterns.push(p);
+			}
+		}
+		if (s.meta.doc_diff?.groups.some((g) => g.attr && !g.sources && !g.library)) {
+			const read = await this.#source_reader();
+			const norm = (f) => {
+				const at = f.lastIndexOf("/src/");
+				return at !== -1 ? f.slice(at + 5) : f.startsWith("src/") ? f.slice(4) : f;
+			};
+			const files = [.../* @__PURE__ */ new Set([...(s.lineage?.components ?? []).map((c) => norm(c.file)), ...s.analysis.components.filter((c) => c.url.endsWith(".svelte")).map((c) => norm(c.url))])];
+			for (const g of s.meta.doc_diff.groups) {
+				if (!g.attr || g.attr.includes(",")) continue;
+				const tags = g.tag.split(", ");
+				const found = [];
+				let mentioned = false;
+				for (const f of files) {
+					const src = read(f);
+					if (!src) continue;
+					if (src.includes(g.attr)) mentioned = true;
+					for (const x of attr_sites(src, g.attr, tags)) if (found.length < 3) found.push({
+						file: f,
+						...x
+					});
+				}
+				if (found.length) g.sources = found;
+				else if (!mentioned) g.library = true;
+			}
+		}
+		if (s.meta.trigger === "page" && s.meta.prerendered === void 0) {
+			const read = await this.#source_reader();
+			const reqs = s.meta.requests ?? [];
+			const route = s.meta.run_route ?? (reqs.find((r) => r.route && r.path.split("?")[0] === s.meta.page?.split("?")[0]) ?? reqs.find((r) => r.route))?.route;
+			const leaf = [...new Set((s.analysis.timeline?.lanes ?? []).map((l) => l.file))].find((f) => f.includes("+page")) ?? (s.lineage?.components ?? []).find((c) => c.file.endsWith("+page.svelte"))?.file;
+			const dir = route ? `routes${route === "/" ? "" : route}` : leaf ? leaf.slice(0, leaf.lastIndexOf("/")) : "";
+			if (s.meta.run_static || dir && route_prerendered(read, dir)) s.meta.prerendered = true;
+		}
+		const near = s.meta.doc_diff && s.meta.doc_diff.differing <= s.meta.doc_diff.tokens * .05 && s.meta.doc_diff.groups.length <= 6 ? s.meta.doc_diff : void 0;
+		if (!s.meta.prerendered && (s.meta.same_document || near) && s.meta.runs?.length && Math.min(...s.meta.runs) >= 5 && (s.meta.run_status ?? 200) === 200) {
+			const read = await this.#source_reader();
+			const files = [...new Set((s.analysis.timeline?.lanes ?? []).map((l) => l.file))];
+			const VISITOR = /* @__PURE__ */ new Set([
+				"cookies",
+				"locals",
+				"request",
+				"getClientAddress",
+				"platform"
+			]);
+			let visitor = s.net.some((c) => c.personal);
+			const route_files = new Set(files);
+			const leaf = files.find((f) => f.includes("+page")) ?? (s.lineage?.components ?? []).find((c) => c.file.endsWith("+page.svelte"))?.file;
+			if (leaf) {
+				let dir = leaf.slice(0, leaf.lastIndexOf("/"));
+				let first = true;
+				while (dir) {
+					const names = [
+						...first ? [
+							"+page.server.ts",
+							"+page.server.js",
+							"+page.ts",
+							"+page.js"
+						] : [],
+						"+layout.server.ts",
+						"+layout.server.js",
+						"+layout.ts",
+						"+layout.js"
+					];
+					for (const n of names) if (read(`${dir}/${n}`) !== void 0) route_files.add(`${dir}/${n}`);
+					first = false;
+					const up = dir.lastIndexOf("/");
+					if (up === -1) break;
+					dir = dir.slice(0, up);
+				}
+			}
+			for (const f of route_files) {
+				const src = read(f);
+				if ((src ? load_inputs(src) : null)?.some((n) => VISITOR.has(n) || n.startsWith("*"))) visitor = true;
+			}
+			if (!visitor) {
+				const page_file = files.find((f) => f.includes("+page")) ?? files[0] ?? s.meta.page ?? "";
+				const code = page_file ? read(page_file)?.split("\n").find((l) => l.includes("export") && l.includes("load"))?.trim() : void 0;
+				const runs = [...s.meta.runs].sort((a, b) => a - b);
+				const render_ms = runs[Math.floor(runs.length / 2)];
+				const cc = s.meta.run_cache_control;
+				const shut = cc?.toLowerCase().split(",").some((d) => d.trim() === "private" || d.trim() === "no-store");
+				if (s.meta.same_document) patterns.push(same_document_pattern({
+					file: page_file,
+					render_ms,
+					bytes: s.meta.run_bytes ?? 0,
+					...code ? { code } : {},
+					...s.meta.run_sets_cookie || shut ? { blocked: {
+						...s.meta.run_sets_cookie ? { cookie: true } : {},
+						...shut ? { cache_control: cc } : {}
+					} } : {}
+				}));
+				else if (near) patterns.push(almost_same_document_pattern({
+					file: page_file,
+					render_ms,
+					diff: near,
+					...code ? { code } : {}
+				}));
+			}
+		}
+		{
+			const read = await this.#source_reader();
+			const comps = s.analysis.components;
+			const norm = (f) => f.startsWith("src/") ? f.slice(4) : f;
+			const blocks_of = /* @__PURE__ */ new Map();
+			const items = [];
+			for (const c of comps) {
+				if (!c.calls || c.calls < 20 || !c.parent) continue;
+				let file = "";
+				let src;
+				let b;
+				let up = c.parent;
+				for (let hop = 0; up && hop < 4 && !b; hop++) {
+					const parent = comps.find((p) => p.name === up);
+					up = parent?.parent;
+					if (!parent) continue;
+					let own = parent.url.endsWith(".svelte") ? parent.url : void 0;
+					if (!own && parent.path) {
+						const id = this.#module_find(parent.path, parent.line);
+						if (id?.endsWith(".svelte")) own = id;
+					}
+					if (!own) continue;
+					file = norm(own);
+					src = read(file);
+					if (!src) continue;
+					if (!blocks_of.has(file)) blocks_of.set(file, each_blocks(src));
+					b = blocks_of.get(file).find((x) => x.components.includes(c.name));
+				}
+				if (!b || !src) continue;
+				const lines = src.split("\n");
+				const from = Math.max(1, b.line - 2);
+				let made_at;
+				for (const x of b.key ? (s.lineage?.sources ?? []).filter((y) => y.key === b.key) : []) {
+					const sorted = [...x.lines].sort((m, n) => n - m);
+					const at = sorted[1] ?? sorted[0];
+					const code = at ? read(x.from)?.split("\n")[at - 1]?.trim() : void 0;
+					if (at && code) made_at = {
+						path: x.from,
+						file: x.from,
+						line: at,
+						code
+					};
+				}
+				items.push({
+					component: c.name,
+					instances: c.calls,
+					total_ms: c.total_ms,
+					each: {
+						path: file,
+						file,
+						line: b.line,
+						code: lines[b.line - 1].trim(),
+						context: {
+							start: from,
+							lines: lines.slice(from - 1, b.line + 2)
+						}
+					},
+					...b.key ? { key: b.key } : {},
+					...made_at ? { made_at } : {}
+				});
+			}
+			const p = render_per_item_pattern(items, renders);
+			if (p) patterns.push(p);
+		}
+		if (source) {
+			const files = /* @__PURE__ */ new Map();
+			const opts_for = (path) => {
+				let o = files.get(path);
+				if (o) return o;
+				const all = source(path, 1, Number.MAX_SAFE_INTEGER)?.lines;
+				if (!all) return void 0;
+				const svelte = path.endsWith(".svelte");
+				const tag = svelte ? all.find((l) => l.includes("<script") && l.includes("lang=")) : void 0;
+				const ts = path.endsWith(".ts") || path.endsWith(".mts") || path.endsWith(".cts") || !!tag && (tag.includes("ts\"") || tag.includes("ts'") || tag.includes("=ts") || tag.includes("typescript"));
+				const taken = /* @__PURE__ */ new Set();
+				for (const l of all) for (const t of tokens(l)) taken.add(t);
+				o = {
+					ts,
+					svelte,
+					taken,
+					made: /* @__PURE__ */ new Map()
+				};
+				files.set(path, o);
+				return o;
+			};
+			for (const p of patterns) {
+				if (p.kind !== "formatter-per-call") continue;
+				for (const site of p.sites) {
+					if (site.rewrite) continue;
+					const full = source(site.path, site.line, site.line)?.lines[0];
+					const opts = opts_for(site.path);
+					if (!full || !opts) continue;
+					const rw = formatter_rewrite(full, opts);
+					if (rw) {
+						site.rewrite = {
+							file: site.file,
+							line: site.line,
+							...rw
+						};
+						continue;
+					}
+					const above = source(site.path, Math.max(1, site.line - 3), site.line - 1);
+					if (!above) continue;
+					const used = tokens(full);
+					for (let k = above.lines.length - 1; k >= 0; k--) {
+						const l = above.lines[k];
+						if (!l.includes("new Intl.")) continue;
+						const name = line_rw(l).declared[0];
+						if (!name || !used.some((t, i) => t === name && used[i + 1] === "." && used[i - 1] !== ".")) continue;
+						const r2 = formatter_rewrite(l, opts);
+						if (r2) site.rewrite = {
+							file: site.file,
+							line: above.start + k,
+							...r2
+						};
+						break;
+					}
+				}
+			}
+		}
+		const route = own_requests(s.meta).find((r) => r.route)?.route ?? s.meta.request?.route;
+		if (route) for (let i = patterns.length - 1; i >= 0; i--) {
+			const sites = patterns[i].sites;
+			if (sites.length && sites.every((x) => another_routes_file(route, x.path || x.file))) patterns.splice(i, 1);
+		}
+		if (route && s.call_counts && !patterns.some((p) => p.kind === "sync-io")) try {
+			const read = await this.#source_reader();
+			const { join } = await import("node:path");
+			const dirs = route_dirs(route);
+			const rels = [];
+			const add = (dir, names) => {
+				for (const n of names) for (const ext of [".ts", ".js"]) rels.push(`routes/${dir ? dir + "/" : ""}${n}${ext}`);
+			};
+			for (const d of dirs.above("src")) add(d, ["+layout.server", "+layout"]);
+			add(dirs.own("src"), ["+page.server", "+page"]);
+			for (const ext of [".ts", ".js"]) rels.push(`hooks.server${ext}`);
+			const files = [];
+			for (const rel of rels) {
+				const text = read(rel);
+				if (text) files.push({
+					path: join(process.cwd(), "src", rel),
+					file: rel,
+					text
+				});
+			}
+			const own = new Set(files.map((f) => f.file));
+			for (const f of files.slice()) for (const rel of module_imports(f.file, f.text)) {
+				if (own.size >= 30 + rels.length) break;
+				if (own.has(rel)) continue;
+				const text = read(rel);
+				if (!text) continue;
+				own.add(rel);
+				files.push({
+					path: join(process.cwd(), "src", rel),
+					file: rel,
+					text
+				});
+			}
+			const p = counted_sync_io(s.call_counts, files);
+			if (p) patterns.push(p);
+		} catch {}
+		const severe = (p) => (p.kept_bytes ?? 0) >= 8388608 && p.growth !== "levels-off";
+		const per_render = (p) => p.wait ? p.save_ms : p.save_ms / renders;
+		patterns.sort((a, b) => Number(severe(b)) - Number(severe(a)) || per_render(b) - per_render(a));
+		if (patterns.length) s.patterns = patterns;
+		const label = (x) => this.#label_module(x);
+		for (const p of s.patterns ?? []) for (const site of p.sites) {
+			label(site);
+			for (const v of site.via ?? []) label(v);
+		}
+		const tl_drill = s.analysis.timeline;
+		if (tl_drill) {
+			const renders_of = /* @__PURE__ */ new Map();
+			for (const c of s.analysis.components) if (c.calls) renders_of.set(c.name, c.calls);
+			const cold_owners = new Map((s.meta.cold?.owners ?? []).map((o) => [o.label, o.ms]));
+			const drill = build_drill(tl_drill, ledger, patterns, s.gc_attr?.makers ?? [], renders_of, s.analysis.owner_runs_ms ?? {}, cold_owners, wait_runs ?? {});
+			if (drill && source) {
+				const with_code = (n) => {
+					for (const c of n.children ?? []) {
+						const fl = c.kind === "line" && c.at ? at_line(c.at) : void 0;
+						const code = fl ? source(fl.file, fl.line, fl.line)?.lines[0]?.trim() : void 0;
+						if (code) c.code = code.slice(0, 120);
+						with_code(c);
+					}
+				};
+				with_code(drill);
+			}
+			if (drill && s.lineage?.sources) {
+				const verdict = new Map(s.lineage.keys.map((k) => [k.key, k.verdict]));
+				tag_fills(drill, s.lineage.sources.map((x) => ({
+					...x,
+					verdict: verdict.get(x.key) ?? "unknown"
+				})));
+				const read = await this.#source_reader();
+				const late = /* @__PURE__ */ new Map();
+				for (const c of s.lineage.components) {
+					if (c.island || !c.file.endsWith(".svelte")) continue;
+					const src = read(c.file);
+					if (!src) continue;
+					const lines = src.split("\n");
+					for (const k of late_island_keys(src)) if (!s.lineage.components.some((o) => o.file !== c.file && (o.whole || (o.reads ?? []).includes(k.key)))) late.set(k.key, {
+						island: k.island,
+						wake: k.wake,
+						file: c.file,
+						line: k.line,
+						code: lines[k.line - 1]?.trim() ?? ""
+					});
+				}
+				if (late.size) {
+					const items = [];
+					const rows = [];
+					const walk = (n) => {
+						if (n.kind === "wait" && n.fills?.length && n.fills.every((f) => late.has(f.key))) rows.push(n);
+						for (const c of n.children ?? []) walk(c);
+					};
+					walk(drill);
+					for (const r of rows) {
+						const line = r.children?.find((c) => c.kind === "line");
+						const at = line?.children?.find((c) => c.kind === "line")?.at ?? line?.at;
+						if (!at) continue;
+						const colon = at.lastIndexOf(":");
+						const file = at.slice(0, colon);
+						const n = Number(at.slice(colon + 1));
+						const k = late.get(r.fills[0].key);
+						items.push({
+							call: r.label,
+							ms: r.ms,
+							alone: r.alone ?? 0,
+							at: {
+								path: file,
+								file,
+								line: n,
+								code: read(file)?.split("\n")[n - 1]?.trim() ?? ""
+							},
+							key: r.fills[0].key,
+							island: k.island,
+							wake: k.wake,
+							use: {
+								path: k.file,
+								file: k.file,
+								line: k.line,
+								code: k.code
+							}
+						});
+						r.why = [...r.why ?? [], "late-island-wait"];
+					}
+					const p = late_island_pattern(items);
+					if (p) {
+						const list = s.patterns ??= [];
+						list.push(p);
+						list.sort((a, b) => Number(severe(b)) - Number(severe(a)) || per_render(b) - per_render(a));
+					}
+				}
+			}
+			if (drill) s.drill = drill;
+		}
+		if (s.meta.trigger === "page" && (s.meta.run_status ?? 200) === 200) {
+			const by_key = new Map(s.analysis.functions.map((fn) => [fn.key, fn]));
+			const f = forecast_of(s.meta.runs, s.patterns, s.drill, {
+				wait_cap: s.analysis.timeline?.wait_ms,
+				cpu_cap: s.analysis.timeline?.cpu_ms,
+				stacks: (k) => by_key.get(k)?.stacks,
+				...s.meta.answers?.runs_ms.length ? { answers_runs: s.meta.answers.runs_ms } : {},
+				cpu_main: s.analysis.functions.filter((fn) => MAIN_THREAD_CPU.has(fn.category)).reduce((t, fn) => t + fn.self_ms, 0) / Math.max(1, s.meta.runs?.length ?? 1)
+			});
+			if (f) s.forecast = s.analysis.sourcemapped || s.analysis.text_mapped ? f : {
+				...f,
+				partial: true
+			};
+		}
+	}
+	/** A reader of app sources at report time (a file relative to `src/` or the cwd, or absolute);
+	*  undefined where there is no file system, or when the file is not on this machine. */
+	/** THE DEV SERVER: which page.data keys an island's code reads, from the plugin's run of the build's
+	*  analysis (vite/dev-maps.ts), by the island id in its entry (`…/virtual:ogygia/island/<id>.js`).
+	*  Undefined off the dev server or when the plugin cannot say */
+	async #dev_island_keys(entry) {
+		if (!this.dev) return void 0;
+		const ask = globalThis[Symbol.for("ogygia.profiler.dev-page-keys")];
+		const at = entry.indexOf("virtual:ogygia/island/");
+		if (!ask || at === -1) return void 0;
+		const rest = entry.slice(at + 22);
+		const dot = rest.indexOf(".");
+		try {
+			return await ask(dot === -1 ? rest : rest.slice(0, dot));
+		} catch {
+			return;
+		}
+	}
+	async #source_reader() {
+		let fs;
+		let path;
+		try {
+			fs = await import("node:fs");
+			path = await import("node:path");
+		} catch {
+			fs = void 0;
+		}
+		const cache = /* @__PURE__ */ new Map();
+		return (file) => {
+			if (!fs || !path) return void 0;
+			if (cache.has(file)) return cache.get(file);
+			const candidates = file.startsWith("/") ? [file] : [path.join(process.cwd(), "src", file), path.join(process.cwd(), file)];
+			let out;
+			for (const c of candidates) try {
+				out = fs.readFileSync(c, "utf8");
+				break;
+			} catch {}
+			out ??= embedded_source(file);
+			cache.set(file, out);
+			return out;
+		};
+	}
+	/** DATA LINEAGE FROM THE CODE (lineage.ts): the route's page and layouts, every component the
+	*  profile saw with a `.svelte` source on this machine, and the islands (their keys from the
+	*  build), each with the page.data keys it reads — joined to the loads' keys and the seed. */
+	/** every `.svelte` under the app's `src/`, relative to it, listed once (null: no src here) */
+	#svelte_files;
+	/** The `src/`-relative paths of `<name>.svelte` files (a component is named after its file). */
+	async #component_files(name) {
+		this.#svelte_files ??= (async () => {
+			try {
+				const fs = await import("node:fs");
+				const path = await import("node:path");
+				const root = path.join(process.cwd(), "src");
+				const out = [];
+				for (const e of fs.readdirSync(root, {
+					recursive: true,
+					withFileTypes: true
+				})) {
+					if (!e.isFile() || !e.name.endsWith(".svelte")) continue;
+					const rel = path.relative(root, path.join(e.parentPath, e.name)).split(path.sep).join("/");
+					if (!rel.includes("node_modules/")) out.push(rel);
+				}
+				return out;
+			} catch {
+				const carried = embedded_files().filter((f) => f.endsWith(".svelte"));
+				return carried.length ? carried : null;
+			}
+		})();
+		const all = await this.#svelte_files;
+		const leaf = "/" + name + ".svelte";
+		return all ? all.filter((f) => f === name + ".svelte" || f.endsWith(leaf)) : [];
+	}
+	async #lineage_for(stored, body) {
+		const a = stored.analysis;
+		const tl = a.timeline;
+		const read = await this.#source_reader();
+		const lanes = tl?.lanes ?? [];
+		const lane_files = [...new Set(lanes.map((l) => l.file))];
+		if (tl?.chain) {
+			const src = read(tl.chain.page);
+			const use = src ? parent_use(src) : null;
+			if (use) tl.chain.parent_use = use;
+		}
+		const runs = Math.max(stored.meta.runs?.length ?? 1, 1);
+		const wait_by_lane = /* @__PURE__ */ new Map();
+		for (const c of stored.net) {
+			const text = [
+				c.caller_site?.file ?? "",
+				...c.callers ?? [],
+				c.caller ?? ""
+			].join(" ");
+			const lane = load_lane_of(text)?.file;
+			if (!lane) continue;
+			const file = lane_files.includes(lane) ? lane : lane_files.find((f) => f.endsWith(lane) || lane.endsWith(f));
+			if (!file) continue;
+			wait_by_lane.set(file, (wait_by_lane.get(file) ?? 0) + (Math.max(c.ms, 0) + (c.body_ms ?? 0)) / runs);
+		}
+		const lineage_lanes = lane_files.map((file) => {
+			const src = read(file);
+			return {
+				file,
+				keys: src ? load_return_keys(src) : null,
+				...wait_by_lane.has(file) ? { wait_ms: round2(wait_by_lane.get(file)) } : {}
+			};
+		});
+		const files = /* @__PURE__ */ new Map();
+		const route_dirs = /* @__PURE__ */ new Set();
+		for (const f of lane_files) {
+			const at = f.lastIndexOf("/");
+			if (at === -1) continue;
+			let dir = f.slice(0, at);
+			while (dir) {
+				route_dirs.add(dir);
+				const up = dir.lastIndexOf("/");
+				if (up === -1 || dir === "routes") break;
+				dir = dir.slice(0, up);
+			}
+		}
+		for (const dir of route_dirs) for (const leaf of ["+page.svelte", "+layout.svelte"]) {
+			const file = `${dir}/${leaf}`;
+			if (read(file) !== void 0 && !files.has(file)) files.set(file, {
+				name: `${dir.slice(dir.lastIndexOf("/") + 1)}/${leaf}`,
+				island: false
+			});
+		}
+		const norm = (f) => f.startsWith("src/") ? f.slice(4) : f;
+		for (const c of a.components) {
+			if (!c.url.endsWith(".svelte")) continue;
+			const file = norm(c.url);
+			if (files.has(file)) continue;
+			if (read(file) !== void 0) files.set(file, {
+				name: c.name,
+				island: false
+			});
+		}
+		const seed_stats = own_requests(stored.meta).find((r) => r.og?.seed)?.og?.seed;
+		const seen_entries = /* @__PURE__ */ new Set();
+		const islands = [];
+		for (const r of island_rows_of(stored.meta)) {
+			if (seen_entries.has(r.entry)) continue;
+			seen_entries.add(r.entry);
+			const name = island_name(r);
+			let keys;
+			const dev = await this.#dev_island_keys(r.entry);
+			if (dev) keys = dev.keys === "all" ? ["*"] : dev.keys ?? [];
+			else if (seed_stats) {
+				keys = seed_stats.keys.filter((k) => k.readers.includes(name)).map((k) => k.key);
+				if (seed_stats.whole_by.includes(name)) keys.push("*");
+			} else {
+				try {
+					keys = islandPageKeys(r.entry);
+				} catch {
+					keys = void 0;
+				}
+				if (keys === void 0) {
+					const src = read(r.entry);
+					keys = src ? data_reads(src, data_prop_names(src)) : null;
+				} else if (keys === null) keys = ["*"];
+			}
+			let file = norm(r.entry);
+			let whole_line;
+			if (keys?.includes("*") || keys === null) {
+				const comp = a.components.find((c) => c.name === name && c.url.endsWith(".svelte"));
+				const named = await this.#component_files(name);
+				const wanted = route_imports(files.keys(), read, name);
+				const candidates = [
+					...comp ? [norm(comp.url)] : [],
+					...named.filter((f) => wanted.has(f)),
+					...named.filter((f) => !wanted.has(f)),
+					file
+				];
+				for (const f of candidates) {
+					const src = read(f);
+					const line = src ? whole_read_line(src, data_prop_names(src)) : null;
+					if (line) {
+						file = f;
+						whole_line = line;
+						break;
+					}
+				}
+				if (!whole_line) {
+					const whys = [...islandPageWhy(r.entry) ?? [], ...(dev?.why ?? []).map((w) => ({
+						...w,
+						file: app_relative(w.file) ?? w.file
+					}))];
+					for (const w of whys) {
+						if (!w.line) continue;
+						const f = norm(w.file);
+						if (read(f)?.split("\n")[w.line - 1] === void 0) continue;
+						file = f;
+						whole_line = w.line;
+						break;
+					}
+				}
+			}
+			islands.push({
+				name,
+				file,
+				island: true,
+				reads: keys,
+				...whole_line ? { whole_line } : {}
+			});
+			files.delete(norm(r.entry));
+		}
+		const components = [...files.entries()].map(([file, info]) => {
+			const src = read(file);
+			return {
+				name: info.name,
+				file,
+				island: false,
+				reads: data_reads(src, data_prop_names(src))
+			};
+		});
+		if (!components.length && !islands.length) return void 0;
+		const seed_m = SEED_SCRIPT_RE.exec(body);
+		const seed = seed_m ? seed_key_bytes(seed_m[1]) : {};
+		const lineage = build_lineage({
+			components: [...components, ...islands],
+			lanes: lineage_lanes,
+			seed
+		});
+		if (lineage) {
+			const sources = [];
+			for (const file of lane_files) {
+				const src = read(file);
+				const m = src ? key_sources(src) : null;
+				for (const [key, lines] of m ?? []) sources.push({
+					key,
+					from: file,
+					lines,
+					names: names_on(src, lines)
+				});
+			}
+			if (sources.length) lineage.sources = sources;
+		}
+		return lineage;
+	}
+	/** One more render under a LIVE-objects sampler (no collected-objects flag), then a full
+	*  collection, then the profile: every sampled object still alive was allocated by that
+	*  render and kept by something — the leak, by allocation site. Its own session, after the
+	*  runs, so nothing here is charged to them; the sites are source-mapped like the makers. */
+	/** `n` renders with a full collection after each: the used heap after every one — and, from a
+	*  live-objects sampler left on across all of them, what each LINE still holds at the end (a
+	*  leaking line holds about `n` renders' worth; a line filling a bounded cache, about one). */
+	async #growth_check(render, n, until = Infinity) {
+		const { Session } = await import("node:inspector/promises");
+		const session = new Session();
+		session.connect();
+		try {
+			const settled = async () => {
+				await session.post("HeapProfiler.collectGarbage");
+				return process.memoryUsage().heapUsed;
+			};
+			const series = [await settled()];
+			await session.post("HeapProfiler.enable");
+			await session.post("HeapProfiler.startSampling", { samplingInterval: LIVE_SAMPLING_BYTES });
+			const half = Math.floor(n / 2);
+			let half_head;
+			let last = 0;
+			for (let i = 0; i < n; i++) {
+				if (i >= 3 && Date.now() + last > until) break;
+				const t = Date.now();
+				await render();
+				series.push(await settled());
+				if (i + 1 === 3 && is_flat(series)) break;
+				if (i + 1 === 3 && is_clear_leak(series)) {
+					half_head = void 0;
+					break;
+				}
+				if (i + 1 === half) half_head = (await session.post("HeapProfiler.getSamplingProfile")).profile?.head;
+				last = Date.now() - t;
+			}
+			const res = await session.post("HeapProfiler.getSamplingProfile");
+			await session.post("HeapProfiler.stopSampling");
+			const g = heap_growth(series);
+			if (!g) return void 0;
+			const head = res.profile?.head;
+			if (head) g.sites = (await this.#live_sites(head)).rows;
+			if (head && half_head) {
+				g.half_renders = half;
+				g.half_sites = (await this.#live_sites(half_head)).rows;
+			}
+			return g;
+		} finally {
+			try {
+				session.disconnect();
+			} catch {}
+		}
+	}
+	async #retention_pass(render) {
+		const { Session } = await import("node:inspector/promises");
+		const session = new Session();
+		session.connect();
+		try {
+			await session.post("HeapProfiler.enable");
+			await session.post("HeapProfiler.startSampling", { samplingInterval: LIVE_SAMPLING_BYTES });
+			const t = performance.now();
+			await render();
+			const render_ms = round2(performance.now() - t);
+			await session.post("HeapProfiler.collectGarbage");
+			const res = await session.post("HeapProfiler.getSamplingProfile");
+			await session.post("HeapProfiler.stopSampling");
+			const head = res.profile?.head;
+			if (!head) return void 0;
+			const { total, rows } = await this.#live_sites(head);
+			return {
+				total_bytes: total,
+				render_ms,
+				sites: rows
+			};
+		} finally {
+			try {
+				session.disconnect();
+			} catch {}
+		}
+	}
+	/** A live-objects heap sample, after a full collection, as rows: one per allocation line (the
+	*  same builtin from several stacks is one site), each charged to its app line (`at`). */
+	async #live_sites(head) {
+		{
+			const dict = {};
+			const sites = heap_sites(head, dict);
+			const resolver = await this.#make_resolver();
+			const short = (u) => u.replace(/^file:\/\//, "").split("/").slice(-2).join("/");
+			const by_ident = /* @__PURE__ */ new Map();
+			let total = 0;
+			for (const [key, bytes] of sites) {
+				const d = dict[key];
+				if (!d || d.category === "profiler" || d.category === "v8" || d.category === "gc") continue;
+				let url = d.url;
+				let line = d.line;
+				let caller = d.caller;
+				let at;
+				if (resolver) {
+					const m = url ? resolver.resolve(url, line - 1, 0) : void 0;
+					if (m) {
+						url = m.source;
+						line = m.line;
+					}
+					let caller_at;
+					if (d.caller_url && d.caller_name) {
+						const c = resolver.resolve(d.caller_url, (d.caller_line ?? 1) - 1, 0);
+						if (c) {
+							caller = `${d.caller_name} (${short(c.source)}:${c.line})`;
+							caller_at = {
+								path: c.source,
+								line: c.line
+							};
+						}
+					}
+					const cat = m ? categorize({
+						functionName: d.name,
+						url: m.source,
+						lineNumber: m.line - 1,
+						columnNumber: 0,
+						scriptId: ""
+					}).category : d.category;
+					if ((cat === "app" || cat === "component") && m) at = {
+						path: m.source,
+						line: m.line
+					};
+					else at = caller_at;
+					if (!at && !m) at = this.#chunk_at(d.url, d.line) ?? this.#chunk_at(d.caller_url, d.caller_line);
+				}
+				const ident = `${d.name}|${url}|${line}|${caller ?? ""}`;
+				const row = by_ident.get(ident) ?? {
+					name: d.name,
+					url,
+					line,
+					...caller ? { caller } : {},
+					...at ? { at } : {},
+					component: d.component,
+					bytes: 0,
+					share: 0
+				};
+				row.bytes += bytes;
+				by_ident.set(ident, row);
+				total += bytes;
+			}
+			const rows = [...by_ident.values()].sort((a, b) => b.bytes - a.bytes).slice(0, 30);
+			for (const r of rows) r.share = total ? round2(r.bytes / total) : 0;
+			return {
+				total,
+				rows
+			};
+		}
+	}
+	#compare(a, b) {
+		const A = this.#reports.get(a ?? "");
+		const B = this.#reports.get(b ?? "");
+		if (!A || !B) return {
+			base: this.base,
+			cmp: null,
+			a: a ?? "",
+			b: b ?? ""
+		};
+		return {
+			base: this.base,
+			cmp: compare_reports(this.#pack(A), this.#pack(B)),
+			a: A.meta.id,
+			b: B.meta.id
+		};
+	}
+	/** a stored report as the comparison reads it */
+	#pack(s) {
+		return {
+			meta: s.meta,
+			analysis: s.analysis,
+			findings: derive_findings(s.analysis, s.meta, this.#report_extras(s)).filter((f) => f.severity === "warn").map((f) => `${f.code}: ${f.message}`),
+			...s.gc_attr ? { gc: s.gc_attr } : {},
+			...s.patterns ? { patterns: s.patterns } : {},
+			...s.ledger ? { ledger: s.ledger } : {},
+			...s.drill ? { drill: s.drill } : {},
+			...s.forecast ? { forecast: s.forecast } : {}
+		};
+	}
+	/** DEV ONLY: nine lines of a local source file around `l` — the source peek an expanded row
+	*  shows. Behind the login like every route; the path must resolve inside the project (the
+	*  process cwd, symlinks followed) and be a source file. Anything else is a 404. */
+	async #source(ctx) {
+		if (!this.dev) return new Response("Not found", { status: 404 });
+		const p = ctx.url.searchParams.get("p") ?? "";
+		const line = Math.max(1, Number(ctx.url.searchParams.get("l")) || 1);
+		const to = Math.min(line + 60, Math.max(line, Number(ctx.url.searchParams.get("to")) || line));
+		try {
+			const fs = await import("node:fs");
+			const path = await import("node:path");
+			const real = fs.realpathSync(p);
+			const root = fs.realpathSync(process.cwd());
+			if (!real.startsWith(root + path.sep)) return new Response("Not found", { status: 404 });
+			if (!SOURCE_EXT_RE.test(real)) return new Response("Not found", { status: 404 });
+			const lines = fs.readFileSync(real, "utf8").split("\n");
+			const start = Math.max(1, line - 4);
+			const end = Math.min(lines.length, to + 4);
+			return ctx.json({
+				path: real,
+				start,
+				line,
+				lines: lines.slice(start - 1, end)
+			});
+		} catch {
+			return new Response("Not found", { status: 404 });
+		}
+	}
+	/** No open redirect — a `next` only bounces back into the profiler. */
+	#safe_next(next) {
+		const n = next ?? this.base;
+		return n.startsWith(this.base) ? n : this.base;
+	}
+	/** Clear the session cookie and bounce to the dashboard. */
+	#logout(ctx) {
+		const res = ctx.redirect(this.base);
+		res.headers.append("set-cookie", this.#session_cookie("", ctx.event));
+		return res;
+	}
+	#dashboard(by) {
+		const tag_keys = /* @__PURE__ */ new Set();
+		for (const e of this.#ring) for (const k of Object.keys(e.tags ?? {})) tag_keys.add(k);
+		return {
+			base: this.base,
+			recent: this.#ring,
+			routes: route_aggregates(this.#ring, by && tag_keys.has(by) ? by : null),
+			by: by && tag_keys.has(by) ? by : null,
+			tag_keys: [...tag_keys].sort(),
+			reports: [...this.#reports.values()].map((r) => r.meta).reverse(),
+			top_fix: Object.fromEntries([...this.#reports.values()].filter((r) => r.patterns?.length).map((r) => {
+				const p = r.patterns[0];
+				const n = r.meta.trigger === "page" ? r.meta.runs?.length || 1 : 1;
+				return [r.meta.id, {
+					title: p.title,
+					save_ms: round2(p.wait ? p.save_ms : p.save_ms / n),
+					wait: !!p.wait,
+					more: r.patterns.length - 1
+				}];
+			})),
+			site_fixes: this.#site_fixes(),
+			holes: hole_slots(this.#ring),
+			recording: this.#recorder_busy || this.#recording_active(),
+			dev: this.dev,
+			rss_mb: Math.round(process.memoryUsage().rss / 1048576),
+			inflight: this.#inflight,
+			history: page_history([...this.#reports.values()].map((r) => r.meta), (id) => {
+				const s = this.#reports.get(id);
+				if (!s || s.meta.trigger !== "page") return void 0;
+				try {
+					return page_score_of(s.meta, this.#report_extras(s)).score;
+				} catch {
+					return;
+				}
+			}),
+			trap: this.#trap ? {
+				over: this.#trap.over,
+				window_ms: this.#trap.window ?? 5e3,
+				caught: this.#trap_caught,
+				keep: this.#trap.keep ?? 3,
+				armed: !!this.#trap_timer || this.#trap_running
+			} : null,
+			sampled: this.#sampled_summary(),
+			background_note: this.#background_note
+		};
+	}
+	#run_page(ctx) {
+		const q = ctx.url.searchParams;
+		let path = (q.get("p") ?? "").trim();
+		if (path && !path.startsWith("/") && !path.includes("://")) path = "/" + path;
+		if (!path.startsWith("/") || path.startsWith("//")) return error(400, "Give a path on this site, like /docs/overview.");
+		const runs = clamp(Number(q.get("runs")) || 5, 1, 50);
+		const format = q.get("format") === "ogp" ? "ogp" : "";
+		const against_raw = q.get("against") ?? "";
+		let against = "";
+		for (const ch of against_raw) {
+			const c = ch.charCodeAt(0);
+			if (!(c >= 48 && c <= 57 || c >= 97 && c <= 122)) {
+				against = "";
+				break;
+			}
+			against += ch;
+		}
+		return {
+			base: this.base,
+			path,
+			runs,
+			format,
+			...against && against.length <= 32 ? { against } : {}
+		};
+	}
+	#window = null;
+	async #window_sign(nonce) {
+		const { createHmac } = await import("node:crypto");
+		return createHmac("sha256", this.secret || "ogygia-dev-window").update("window:" + nonce).digest("hex").slice(0, 20);
+	}
+	/** A window id from a request, when its signature holds; else null. */
+	async #window_id_of(request) {
+		const raw = request.headers.get(WINDOW_HEADER);
+		if (!raw || raw.length > 80) return null;
+		const dot = raw.indexOf(".");
+		if (dot <= 0) return null;
+		const nonce = raw.slice(0, dot);
+		return await this.#window_sign(nonce) === raw.slice(dot + 1) ? raw : null;
+	}
+	/** A request in a window: written to the store, awaited (see above). */
+	async #window_note(entry, request) {
+		if (!this.#store?.putVisit || entry.internal) return;
+		const id = await this.#window_id_of(request);
+		if (!id) return;
+		const rec = {
+			method: entry.method,
+			path: entry.path,
+			route: entry.route ?? null,
+			ms: entry.ms,
+			status: entry.status ?? null,
+			cpu_ms: entry.cpu_ms,
+			net_ms: entry.net_ms ?? null,
+			net_count: entry.net_count ?? 0,
+			at: Date.now(),
+			instance: this.#instance_id
+		};
+		try {
+			await this.#store.putVisit({
+				key: `${WINDOW_PAGE_PREFIX}${id}\0${rec.at}\0${Math.random().toString(36).slice(2, 8)}`,
+				page: WINDOW_PAGE_PREFIX + id,
+				at: rec.at,
+				visit: JSON.stringify(rec)
+			});
+		} catch {}
+	}
+	/** The requests every instance wrote for a window. */
+	async #window_requests(id) {
+		if (!this.#store?.listVisits) return [];
+		try {
+			return (await this.#store.listVisits(WINDOW_PAGE_PREFIX + id, MAX_VISITS_PER_KEY)).map((r) => JSON.parse(r.visit)).sort((a, b) => a.at - b.at);
+		} catch {
+			return [];
+		}
+	}
+	/** This instance, told apart from the others in a window's requests. */
+	#instance_id = Math.random().toString(36).slice(2, 10);
+	async #window_start(ctx) {
+		const busy = (message) => new Response(JSON.stringify({
+			busy: true,
+			message
+		}), {
+			status: 409,
+			headers: {
+				"content-type": "application/json; charset=utf-8",
+				"retry-after": "2",
+				"cache-control": "no-store"
+			}
+		});
+		if (this.#window) return busy("A window is already recording: stop it first.");
+		if (this.#recorder_busy && this.#trap_running) {
+			this.#page_waiting++;
+			try {
+				const until = Date.now() + PAGE_WAITS_FOR_BACKGROUND_MS;
+				while (this.#recorder_busy && this.#trap_running && Date.now() < until) await new Promise((r) => setTimeout(r, 50));
+			} finally {
+				this.#page_waiting--;
+			}
+		}
+		if (!this.#try_acquire_recorder()) return busy("Another recording holds the recorder. Try again in a moment.");
+		this.#recording_since = Date.now();
+		this.#trap_running = true;
+		this.#ensure_net?.();
+		let stop;
+		const stopped = new Promise((r) => stop = r);
+		const nonce = Math.random().toString(36).slice(2, 12) + Date.now().toString(36);
+		const id = `${nonce}.${await this.#window_sign(nonce)}`;
+		const timer = setTimeout(() => {
+			stop();
+			done.finally(() => {
+				if (this.#window?.id === id) this.#window_release();
+			});
+		}, WINDOW_MAX_MS);
+		timer.unref?.();
+		const done = this.#capture_window(Math.min(this.sample_interval, 1e3), () => stopped, { light: true });
+		done.catch(() => this.#window_release());
+		this.#window = {
+			id,
+			stop,
+			done,
+			timer
+		};
+		return ctx.json({
+			ok: true,
+			id,
+			header: WINDOW_HEADER,
+			shared: !!(this.#store?.putVisit && this.#store.listVisits),
+			max_ms: WINDOW_MAX_MS
+		});
+	}
+	#window_release() {
+		if (this.#window) clearTimeout(this.#window.timer);
+		this.#window = null;
+		this.#trap_running = false;
+		this.#recording_since = 0;
+		this.#release_als();
+		this.#release_recorder();
+	}
+	async #window_stop(ctx) {
+		const asked = ctx.event ? await this.#window_id_of(ctx.event.request) : null;
+		const w = this.#window && (!asked || this.#window.id === asked) ? this.#window : null;
+		if (!w) {
+			if (asked && this.#store?.listVisits) {
+				const reqs = await this.#window_requests(asked);
+				const busy = round2(reqs.reduce((a, r) => a + (r.cpu_ms || 0), 0));
+				return ctx.json({
+					kind: "window",
+					id: null,
+					target: {
+						page: "",
+						runs: []
+					},
+					score: null,
+					forecast: null,
+					findings: [],
+					assets: null,
+					links: {
+						html: "",
+						json: ""
+					},
+					summary: { busy_ms: busy },
+					cpu: "the instance that started the window sampled it; this one only gathered the requests",
+					window: {
+						ms: reqs.length ? reqs[reqs.length - 1].at - reqs[0].at : 0,
+						requests: reqs,
+						instances: new Set(reqs.map((r) => r.instance)).size
+					}
+				});
+			}
+			return ctx.json({ error: "No window is recording (start one with POST /window/start)." }, { status: 400 });
+		}
+		w.stop();
+		let cap;
+		try {
+			cap = await w.done;
+		} catch (e) {
+			this.#window_release();
+			return ctx.json({ error: `The window failed: ${e instanceof Error ? e.message : String(e)}` }, { status: 500 });
+		}
+		const own = `${this.base}/`;
+		const shared = await this.#window_requests(w.id);
+		const others = shared.filter((e) => e.instance !== this.#instance_id && !e.path.startsWith(own) && e.path !== this.base);
+		const requests = [...this.#ring.filter((e) => !e.internal && e.ts >= cap.t0 && e.ts <= cap.t1 && !e.path.startsWith(own) && e.path !== this.base).map((e) => ({
+			method: e.method,
+			path: e.path,
+			route: e.route ?? null,
+			ms: round2(e.ms),
+			status: e.status ?? null,
+			cpu_ms: e.cpu_ms,
+			instance: this.#instance_id
+		})), ...others];
+		try {
+			const id = await this.#finish_report(cap, {
+				trigger: "window",
+				...requests[0] ? { request: {
+					method: requests[0].method,
+					path: requests[0].path,
+					route: requests[0].route,
+					ms: requests[0].ms
+				} } : {}
+			});
+			const s = this.#reports.get(id);
+			return ctx.json({
+				...report_json(s.analysis, s.meta, this.base, this.#report_extras(s)),
+				window: {
+					ms: round2(cap.t1 - cap.t0),
+					requests,
+					...shared.length ? { instances: new Set(requests.map((r) => r.instance)).size } : {}
+				}
+			});
+		} finally {
+			this.#window_release();
+		}
+	}
+	#reset(ctx) {
+		this.#recording_since = 0;
+		this.#release_als();
+		this.#recorder_busy = false;
+		return ctx.redirect(this.base);
+	}
+	async #record_page(ctx, replay) {
+		const event = ctx.event;
+		if (this.#recorder_busy && this.#trap_running) {
+			this.#page_waiting++;
+			try {
+				const until = Date.now() + PAGE_WAITS_FOR_BACKGROUND_MS;
+				while (this.#recorder_busy && this.#trap_running && Date.now() < until) await new Promise((r) => setTimeout(r, 50));
+			} finally {
+				this.#page_waiting--;
+			}
+		}
+		if (!this.#try_acquire_recorder()) return new Response(JSON.stringify({
+			busy: true,
+			message: "A profile is already running on this worker. Waiting for it to finish (or for a free worker)."
+		}), {
+			status: 409,
+			headers: {
+				"content-type": "application/json; charset=utf-8",
+				"retry-after": "2",
+				"cache-control": "no-store"
+			}
+		});
+		const q = ctx.url.searchParams;
+		this.#recording_since = Date.now();
+		const watchdog = setTimeout(() => {
+			this.#recording_since = 0;
+			this.#release_als();
+		}, 32e3);
+		watchdog.unref?.();
+		this.#ensure_net?.();
+		try {
+			const path = replay?.path ?? q.get("p") ?? "";
+			if (!path.startsWith("/") || path.startsWith("//")) return error(400, "Give a path on this site, like /docs/overview.");
+			const runs = clamp(Number(q.get("runs")) || 5, 1, 50);
+			const interval = clamp(Number(q.get("interval")) || 200, 50, 1e4);
+			let heap_now = null;
+			try {
+				heap_now = (await import("node:v8")).getHeapStatistics();
+			} catch {
+				heap_now = null;
+			}
+			if (heap_now && heap_now.heap_size_limit > 0 && heap_now.used_heap_size / heap_now.heap_size_limit >= HEAP_START) return error(503, `The server's heap is ${Math.round(heap_now.used_heap_size / heap_now.heap_size_limit * 100)}% full (${Math.round(heap_now.used_heap_size / 1048576)} of ${Math.round(heap_now.heap_size_limit / 1048576)} MB): profiling now could run it out of memory and end the process. Something keeps what each render makes (the last profile's Kept per render names the line). Restart the server, then profile once.`);
+			const work_budget = serverless_work_budget_ms();
+			const requests_before = Math.max(0, this.#requests_seen - 1);
+			const budget_deadline = Number.isFinite(work_budget) ? Date.now() + work_budget : Infinity;
+			const request_deadline = Date.now() + detect_request_budget_ms();
+			const deadline = Math.min(budget_deadline, Date.now() + RECORDING_HARD_CAP_MS);
+			const fetch_render = (p, extra) => {
+				const left = deadline - Date.now();
+				const ms = Number.isFinite(left) ? Math.max(1, Math.min(PER_RENDER_TIMEOUT_MS, left)) : PER_RENDER_TIMEOUT_MS;
+				return with_timeout(event.fetch(p, { headers: {
+					"sec-fetch-mode": "navigate",
+					"sec-fetch-dest": "document",
+					accept: "text/html",
+					...replay?.headers,
+					...extra,
+					"x-og-profiler-internal": "1"
+				} }), ms, "render timed out (the page or one of its upstream calls did not return in time)");
+			};
+			let target = path;
+			let redirected_from;
+			/** a hop was a prerendered redirect's stub (a meta refresh answered 200) */
+			let redirect_stub = false;
+			let warmup_ms;
+			let warm_status = 0;
+			let warm_bytes = 0;
+			let cold_cap;
+			const want_cold = q.get("cold") !== "0";
+			mem_mark("before the warm-up render");
+			for (let hop = 0; hop < 5; hop++) {
+				let t = performance.now();
+				let res;
+				let body = "";
+				try {
+					if (hop === 0 && want_cold) {
+						let t1 = 0;
+						cold_cap = await this.#capture_window(interval, async () => {
+							t = performance.now();
+							res = await fetch_render(target);
+							body = await res.text();
+							t1 = performance.now();
+						}, { light: true });
+						if (res) warmup_ms = round2(t1 - t);
+					} else {
+						res = await fetch_render(target);
+						body = await res.text();
+						warmup_ms = round2(performance.now() - t);
+					}
+				} catch {
+					break;
+				}
+				if (!res) break;
+				warm_status = res.status;
+				warm_bytes = body.length;
+				const stub = res.ok && !res.redirected ? refresh_target(body, event.url.origin) : null;
+				const next = res.redirected ? new URL(res.url).pathname + new URL(res.url).search : res.status >= 300 && res.status < 400 ? (() => {
+					const loc = res.headers.get("location");
+					if (!loc) return null;
+					const u = new URL(loc, event.url.origin);
+					return u.pathname + u.search;
+				})() : stub;
+				if (!next || next === target) break;
+				redirected_from ??= path;
+				if (stub && next === stub) redirect_stub = true;
+				target = next;
+			}
+			const run_ms = [];
+			const run_windows = [];
+			let run_status = warm_status;
+			let run_cache_control;
+			let run_sets_cookie = false;
+			let run_bytes = warm_bytes;
+			let last_body = "";
+			/** the first render's document, set against the last: what changes between renders */
+			let first_body = "";
+			const body_prints = [];
+			let last_chunks = [];
+			let budget_note;
+			let slowest = warmup_ms ?? 0;
+			const coverage_reserve = () => Math.max(slowest * 4.5, 300);
+			const gc_attr = q.get("gc") !== "0";
+			const retention_reserve = () => gc_attr && this.want_heap ? slowest * 1.5 + 500 : 0;
+			let v8_stats = null;
+			try {
+				v8_stats = (await import("node:v8")).getHeapStatistics;
+			} catch {
+				v8_stats = null;
+			}
+			const heap_fill = () => {
+				const s = v8_stats?.();
+				return s && s.heap_size_limit > 0 ? s.used_heap_size / s.heap_size_limit : 0;
+			};
+			const heap_skipped = [];
+			const heap_guard = () => {
+				const s = v8_stats?.();
+				return s ? {
+					used_mb: Math.round(s.used_heap_size / 1048576),
+					limit_mb: Math.round(s.heap_size_limit / 1048576),
+					skipped: heap_skipped
+				} : void 0;
+			};
+			this.#kept?.keep(true);
+			mem_mark("before the timed renders");
+			const cap = await this.#capture_window(interval, async () => {
+				const path_only = target.split("?")[0];
+				const mixed = (w) => this.#ring.some((e) => !e.internal && e.pt !== void 0 && e.path === path_only && e.pt < w.end && (e.ms > 0 ? e.pt + e.ms : Infinity) > w.start);
+				const want_clean = Math.min(2, runs);
+				for (let i = 0; i < runs * 2; i++) {
+					if (i >= runs && run_windows.filter((w) => !mixed(w)).length >= want_clean) break;
+					if (i > 0 && heap_fill() >= HEAP_STOP) {
+						if (i < runs) {
+							budget_note = `Ran ${i} of ${runs} renders — stopped: the server's heap was ${Math.round(heap_fill() * 100)}% full, and each render of this page keeps more of it.`;
+							heap_skipped.push(`${runs - i} of the timed renders`);
+						}
+						break;
+					}
+					if (i > 0 && Date.now() + slowest + retention_reserve() + coverage_reserve() > deadline) {
+						const serverless = Number.isFinite(budget_deadline) && deadline === budget_deadline;
+						const limit_ms = serverless ? work_budget : RECORDING_HARD_CAP_MS;
+						const budget_label = limit_ms >= 1e3 ? `${Math.round(limit_ms / 1e3)} s` : `${Math.round(limit_ms)} ms`;
+						if (i < runs) budget_note = `Ran ${i} of ${runs} renders — trimmed to fit the ` + (serverless ? `${budget_label} serverless budget` : `${budget_label} limit on one recording`) + ` (the page renders in ~${Math.round(warmup_ms ?? 0)} ms). Fewer runs, same accuracy per run.`;
+						break;
+					}
+					const t = performance.now();
+					let res;
+					try {
+						res = await fetch_render(target);
+					} catch {
+						budget_note = i > 0 ? `Ran ${i} of ${runs} renders — stopped early, a later render hung (the page or an upstream call did not return within ${Math.round(PER_RENDER_TIMEOUT_MS / 1e3)}s).` : void 0;
+						break;
+					}
+					const { text: body, chunks } = await read_timed(res, t);
+					const done = performance.now();
+					run_status = res.status;
+					run_bytes = body.length;
+					run_cache_control = res.headers.get("cache-control") ?? void 0;
+					if (res.headers.has("set-cookie")) run_sets_cookie = true;
+					body_prints.push(`${fnv1a32(body)}:${body.length}`);
+					if (!first_body) first_body = body;
+					last_body = body;
+					last_chunks = chunks;
+					run_ms.push(round2(done - t));
+					slowest = Math.max(slowest, done - t);
+					run_windows.push({
+						start: t,
+						end: done
+					});
+					await new Promise((r) => setImmediate(r));
+				}
+			}, { gc_attr });
+			if (run_ms.length === 0) return error(504, "The page did not return in time to profile it. It (or an upstream call it makes) is either hung or slower than the recording budget — try a lighter path, or check that page for a stuck request.");
+			const target_path = target.split("?")[0];
+			const own_calls = /* @__PURE__ */ new Set();
+			for (const c of cap.net) try {
+				own_calls.add(new URL(c.url, "http://x").pathname);
+			} catch {}
+			const outside = this.#ring.filter((e) => !e.internal && e.pt !== void 0 && (e.path === target_path || !own_calls.has(e.path.split("?")[0]) && !e.path.startsWith(this.base)));
+			const mixed_at = run_windows.map((w) => outside.some((e) => e.pt < w.end && (e.ms > 0 ? e.pt + e.ms : Infinity) > w.start));
+			let runs_set_aside = 0;
+			if (mixed_at.some(Boolean) && mixed_at.some((m) => !m)) {
+				const aside = [];
+				for (let i = run_windows.length - 1; i >= 0; i--) {
+					if (!mixed_at[i]) continue;
+					aside.push(run_windows[i]);
+					run_windows.splice(i, 1);
+					run_ms.splice(i, 1);
+					body_prints.splice(i, 1);
+					runs_set_aside++;
+				}
+				cap.set_aside = aside;
+			}
+			const stable = stable_answers(cap.net, run_windows);
+			this.#kept?.keep(false);
+			const almost = /* @__PURE__ */ new Map();
+			if (this.#kept) for (const key of varied_answers(cap.net, run_windows)) {
+				const d = this.#kept.diff(key);
+				if (d && d.size >= 64 && d.bytes <= Math.max(48, d.size * .02)) almost.set(key, d.text);
+			}
+			mem_mark("after the timed renders");
+			let answers;
+			if (stable.size && this.#kept) {
+				const state = {
+					token: `${fnv1a32(`${Math.random()}:${Date.now()}`).toString(36)}${fnv1a32(String(performance.now())).toString(36)}`,
+					keys: stable
+				};
+				this.#answers = state;
+				try {
+					const ms = [];
+					for (let i = 0; i < ANSWER_RENDERS; i++) {
+						if (Date.now() + slowest + retention_reserve() + coverage_reserve() > deadline) break;
+						const t = performance.now();
+						const res = await fetch_render(target, { [ANSWERS_HEADER]: state.token });
+						await res.text();
+						if (res.status !== run_status) break;
+						ms.push(round2(performance.now() - t));
+					}
+					if (ms.length) answers = {
+						runs_ms: ms,
+						calls: stable.size
+					};
+				} catch {
+					answers = void 0;
+				} finally {
+					this.#answers = null;
+					this.#kept.drop();
+				}
+			}
+			const wait_runs = {};
+			for (const c of cap.net) {
+				if (c.ms < 0) continue;
+				const ri = run_windows.findIndex((w) => c.start >= w.start && c.start <= w.end);
+				if (ri === -1) continue;
+				const k = call_group(label_call(c.method, c.url));
+				(wait_runs[k] ??= Array.from({ length: run_windows.length }, () => 0))[ri] += c.ms + (c.body_ms ?? 0);
+			}
+			mark_left_each_run(cap.io_ops, run_windows);
+			cap.window = scope_net_to_one_run(cap, run_windows) ?? void 0;
+			cap.runs = run_windows;
+			let cold;
+			mem_mark("after the answer renders");
+			const cold_route = this.#ring.find((e) => e.internal && e.path === target_path && e.route)?.route;
+			if (cold_cap && warmup_ms !== void 0) try {
+				const p = cold_cap.profile;
+				const whole = {
+					start: cold_cap.perf_start,
+					end: cold_cap.perf_start + (p.endTime - p.startTime) / 1e3
+				};
+				const a0 = analyze(p, await this.#make_resolver(), void 0, {
+					perf_start: cold_cap.perf_start,
+					window: whole,
+					calls: [],
+					runs: [whole],
+					...cold_route ? { route: cold_route } : {}
+				}, void 0, this.#module_hint);
+				const owners = Object.entries(a0.owner_runs_ms ?? {}).map(([label, ms]) => ({
+					label,
+					ms: ms[0]
+				})).filter((o) => o.ms >= .5).sort((x, y) => y.ms - x.ms).slice(0, 40);
+				cold = {
+					ms: warmup_ms,
+					busy_ms: a0.busy_ms,
+					files: a0.files.filter((f) => f.category !== "idle" && f.category !== "gc" && f.category !== "profiler" && f.self_ms >= .5).slice(0, 40).map((f) => ({
+						file: f.key,
+						category: f.category,
+						ms: f.self_ms
+					})),
+					...owners.length ? { owners } : {},
+					calls: cold_cap.net.length
+				};
+			} catch {
+				cold = void 0;
+			}
+			mem_mark("after the answer renders and the cold analysis");
+			let retained;
+			let retain_ms = 0;
+			const heap_ok = heap_fill() < HEAP_EXTRAS;
+			if (gc_attr && this.want_heap && !heap_ok) heap_skipped.push("the render that measures what a render keeps");
+			if (gc_attr && this.want_heap && heap_ok && Date.now() + retention_reserve() + coverage_reserve() < deadline) try {
+				const t = Date.now();
+				retained = await this.#retention_pass(async () => {
+					await fetch_render(target).then((r) => r.text());
+				});
+				retain_ms = Date.now() - t;
+			} catch {
+				retained = void 0;
+			}
+			mem_mark("after the retention render");
+			let growth;
+			if (retained && retained.total_bytes >= 262144) {
+				const each = Math.max(retain_ms, slowest + 300);
+				const room = deadline - Date.now() - coverage_reserve() - 1500;
+				const s = v8_stats?.();
+				const heap_n = s ? Math.floor((s.heap_size_limit * HEAP_STOP - s.used_heap_size) / retained.total_bytes) : Infinity;
+				const n = Math.min(6, Math.floor(room / each), heap_n);
+				if (heap_n < 3) heap_skipped.push("the growth check (a few more renders, to tell a leak from a cache filling)");
+				if (n >= 3) try {
+					growth = await this.#growth_check(async () => {
+						await fetch_render(target).then((r) => r.text());
+					}, n, Date.now() + room);
+				} catch {
+					growth = void 0;
+				}
+			}
+			mem_mark("after the retention and growth renders");
+			const counted = heap_fill() < HEAP_STOP ? await this.#count_calls(async () => {
+				await fetch_render(target).then((r) => r.text());
+			}, true) : (heap_skipped.push("the call-count render (the ×N counts)"), { counts: {} });
+			cap.call_counts = counted.counts;
+			mem_mark("after the coverage render");
+			const app_fetch = async (u) => {
+				try {
+					const r = await event.fetch(u, { headers: { "x-og-profiler-internal": "1" } });
+					if (r.ok) return r;
+				} catch {}
+				return fetch(new URL(u, event.url.origin), { headers: { "x-og-profiler-internal": "1" } });
+			};
+			const id = await this.#finish_report(cap, {
+				trigger: "page",
+				page: target,
+				redirected_from,
+				...redirect_stub ? { redirect_stub: true } : {},
+				...process.env.AWS_LAMBDA_FUNCTION_NAME && !process.env.VERCEL && !process.env.NETLIFY ? {
+					lambda: true,
+					...Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) > 0 ? { lambda_mb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) } : {}
+				} : {},
+				heap_limit_mb: Math.round((await import("node:v8")).getHeapStatistics().heap_size_limit / 1048576),
+				instance: {
+					first_request_ms: round2(this.#first_request_pt ?? 0),
+					node_ms: round2(performance.nodeTiming?.bootstrapComplete ?? 0),
+					age_s: Math.round(performance.now() / 100) / 10,
+					requests_before
+				},
+				warmup_ms,
+				run_status,
+				run_bytes,
+				...run_cache_control ? { run_cache_control } : {},
+				...run_sets_cookie ? { run_sets_cookie: true } : {},
+				...(() => {
+					const path = target.split("?")[0];
+					for (let k = this.#ring.length - 1; k >= 0; k--) {
+						const e = this.#ring[k];
+						if (e.path === path) return e.route ? { run_route: e.route } : {};
+					}
+					return run_status === 200 && !this.dev ? { run_static: true } : {};
+				})(),
+				budget_note,
+				...heap_skipped.length ? { heap_guard: heap_guard() } : {},
+				runs: run_ms,
+				...runs_set_aside ? { runs_set_aside } : {},
+				...body_prints.length >= 2 && body_prints.every((p) => p === body_prints[0]) ? { same_document: true } : {},
+				...cold ? { cold } : {},
+				...answers ? { answers } : {}
+			}, app_fetch);
+			mem_mark("after the report was built");
+			const s = this.#reports.get(id);
+			if (retained) s.retained = retained;
+			if (growth) s.growth = growth;
+			if (!s.meta.same_document && first_body && last_body && run_ms.length >= 2) try {
+				const rows = island_rows_of(s.meta);
+				const name_of = (entry) => {
+					const tail = entry.startsWith(".") ? entry.slice(1) : entry;
+					const r = rows.find((x) => x.entry === tail || x.entry.endsWith(tail));
+					return r ? island_name(r) : void 0;
+				};
+				const diff = doc_diff(first_body, last_body, name_of);
+				if (diff) s.meta.doc_diff = diff;
+			} catch {}
+			if (last_body) {
+				try {
+					s.strip = byte_strip(last_body);
+					if (last_chunks.length > 1) {
+						s.strip.chunks = last_chunks;
+						const tail = stream_tail(last_body, s.strip, last_chunks);
+						if (tail) s.strip.tail = tail;
+					}
+				} catch {}
+				if (this.dev) s.assets_missing = "the dev server serves modules one by one, so its JS says nothing about a build: profile a build (preview or deploy) to weigh the page";
+				else try {
+					const extra = [];
+					for (const r of island_rows_of(s.meta)) {
+						const lazy = r.wake !== "load" && r.wake !== "idle";
+						for (const u of [r.module_url, ...r.hints]) if (u) extra.push({
+							url: u,
+							kind: "script",
+							blocking: false,
+							via: "island",
+							...lazy ? { lazy: true } : {}
+						});
+					}
+					const { gzipSync } = await import("node:zlib");
+					s.assets = await weigh_assets({
+						html: last_body,
+						page_url: new URL(target, event.url.origin).href,
+						fetch_url: app_fetch,
+						cache: this.#asset_weights,
+						gzip: (b) => gzipSync(b, { level: 6 }).byteLength,
+						budget_ms: q.get("weigh") === "full" ? Math.max(500, Math.min(12e4, request_deadline - Date.now() - 4e3)) : Math.max(500, Math.min(6e3, request_deadline - Date.now() - 8e3)),
+						...q.get("weigh") === "full" ? { max_files: 2e3 } : {},
+						extra,
+						contents_of: (u) => {
+							try {
+								const path = new URL(u).pathname;
+								const rel = app_asset_rel(path);
+								return chunkContents(rel ? "/" + rel : path);
+							} catch {
+								return null;
+							}
+						}
+					});
+				} catch {
+					s.assets_missing = "the page could not be weighed";
+				}
+				try {
+					s.river = await this.#river_for(s, last_body, run_windows[run_windows.length - 1]);
+				} catch {}
+				try {
+					s.lineage = await this.#lineage_for(s, last_body);
+				} catch {}
+			}
+			try {
+				await this.#lines_for(s, counted.profile, cap.window?.start, stable, wait_runs, almost);
+			} catch {}
+			const persist_wait = Math.max(200, Math.min(PERSIST_WAIT_MS, request_deadline - Date.now() - 2e3));
+			await Promise.race([this.#persist(s), new Promise((r) => setTimeout(r, persist_wait))]);
+			if (q.get("format") === "keep") return ctx.json({
+				id,
+				url: ctx.href("/report/[id]", { id }),
+				dump: report_dump(s.analysis, s.meta, this.#report_extras(s))
+			});
+			if (q.get("format") === "ogp") return this.#ogp_response(id, s);
+			if (q.get("format") === "json" || (ctx.request.headers.get("accept") ?? "").includes("application/json")) {
+				const since = await this.#since_for(s, this.#prev_in_memory(s));
+				const shared = this.#shared_of(s.meta);
+				const full = {
+					...report_json(s.analysis, s.meta, this.base, this.#report_extras(s)),
+					...since ? { since } : {},
+					...shared.length ? { shared } : {}
+				};
+				return ctx.json(pick_fields(full, q.get("fields")));
+			}
+			return ctx.redirect(ctx.href("/report/[id]", { id }));
+		} catch (e) {
+			if (isHttpError(e) || isRedirect(e)) throw e;
+			return error(500, e instanceof Error && INSPECTOR_ERR.test(e.message) ? "CPU profiling needs a Node.js server (adapter-node or dev). This platform does not expose the V8 inspector." : `Profiling failed: ${e instanceof Error ? e.message : String(e)}`);
+		} finally {
+			clearTimeout(watchdog);
+			this.#recording_since = 0;
+			this.#kept?.keep(false);
+			this.#kept?.drop();
+			this.#answers = null;
+			this.#release_als();
+			this.#release_recorder();
+		}
+	}
+	async #upload(ctx) {
+		try {
+			const bytes = recover_ogp_bytes(new Uint8Array(await ctx.request.arrayBuffer()));
+			if (!is_ogp(bytes)) return ctx.json({ error: "That file is not an ogygia .ogp profile. If you moved it between machines, copy it as a binary file — a text editor or chat can silently re-encode it." }, { status: 400 });
+			const ogp_key = ctx.request.headers.get("x-ogp-key") || this.secret;
+			const dump = await ogp_decode(bytes, ogp_key);
+			if (!is_dump(dump)) return ctx.json({ error: "That file is not an ogygia profiler dump." }, { status: 400 });
+			return ctx.json({ url: ctx.href("/report/[id]", { id: this.#store_uploaded(dump) }) });
+		} catch {
+			return ctx.json({ error: "That file isn't a profile, or it was made with a different key." }, { status: 400 });
+		}
+	}
+	/** the lines two or more profiled pages share, over the latest report of each page this server holds */
+	#site_fixes(limit = 8) {
+		return site_fixes([...this.#reports.values()].filter((r) => r.meta.trigger === "page" && r.meta.page && (r.meta.run_status ?? 200) === 200).map((r) => ({
+			id: r.meta.id,
+			page: r.meta.page,
+			created: r.meta.created,
+			runs: r.meta.runs?.length || 1,
+			patterns: r.patterns
+		})), limit);
+	}
+	/** of those, the ones this report's page is among: its fixes that make other pages faster too */
+	#shared_of(meta) {
+		if (meta.trigger !== "page" || !meta.page) return [];
+		return this.#site_fixes(Infinity).filter((f) => f.pages.some((p) => p.page === meta.page)).slice(0, 5);
+	}
+	async #report_json(stored) {
+		const since = await this.#since_for(stored, this.#prev_in_memory(stored));
+		const shared = this.#shared_of(stored.meta);
+		const body = {
+			...report_json(stored.analysis, stored.meta, this.base, this.#report_extras(stored)),
+			...since ? { since } : {},
+			...shared.length ? { shared } : {}
+		};
+		return new Response(JSON.stringify(body), { headers: {
+			"content-type": "application/json",
+			"cache-control": "no-store"
+		} });
+	}
+	/** The RAW dump JSON (`{ kind, version, meta, analysis, extras }`) the share-link viewer renders —
+	*  the same shape `.ogp` carries. Authed (only the owner mints a link); the recipient never hits it. */
+	#report_dump_json(stored) {
+		const body = report_dump(stored.analysis, stored.meta, this.#report_extras(stored));
+		return new Response(JSON.stringify(body), { headers: {
+			"content-type": "application/json",
+			"cache-control": "no-store"
+		} });
+	}
+	async #report_raw(stored) {
+		let body;
+		if (typeof stored.raw === "string") body = stored.raw;
+		else try {
+			const { gunzipSync } = await import("node:zlib");
+			body = gunzipSync(stored.raw).toString("utf8");
+		} catch {
+			return new Response(new Uint8Array(stored.raw), { headers: {
+				"content-type": "application/json",
+				"content-encoding": "gzip",
+				"content-disposition": `attachment; filename="ssr-${stored.meta.id}.cpuprofile"`,
+				"cache-control": "no-store"
+			} });
+		}
+		return new Response(body, { headers: {
+			"content-type": "application/json",
+			"content-disposition": `attachment; filename="ssr-${stored.meta.id}.cpuprofile"`,
+			"cache-control": "no-store"
+		} });
+	}
+	/**
+	* Render a report page with its dump embedded as an encrypted `.ogp` (base64), so the Export button
+	* downloads it with no server round-trip (the report may be evicted by then) and no key in the page.
+	* Encoding is async (Brotli + scrypt off-thread — never blocks the event loop) and best-effort: if
+	* Node crypto/zlib is unavailable (a stripped edge runtime), the Export button is simply omitted and
+	* the JSON / .cpuprofile links still work.
+	*/
+	async #report_view(stored) {
+		const { analysis: a, meta } = stored;
+		const extras = this.#report_extras(stored);
+		let ogpB64;
+		try {
+			const bytes = await ogp_encode(report_dump(a, meta, extras), this.secret);
+			ogpB64 = Buffer.from(bytes).toString("base64");
+		} catch {
+			ogpB64 = void 0;
+		}
+		const history = meta.trigger === "page" && meta.page ? page_history([...this.#reports.values()].map((r) => r.meta)).find((h) => h.page === meta.page) ?? null : null;
+		const i = history ? history.points.findIndex((p) => p.id === meta.id) : -1;
+		const since = await this.#since_for(stored, i > 0 ? history.points[i - 1].id : null);
+		return {
+			a,
+			meta,
+			base: this.base,
+			extras,
+			ogpB64,
+			history,
+			prev: since?.prev ?? (i > 0 ? history.points[i - 1].id : null),
+			since,
+			dev: this.dev
+		};
+	}
+	/**
+	* SINCE THE LAST PROFILE of this page: the comparison, cut to what a reader needs at the top — the
+	* render's change, the rows that really moved (inlining shifts left out), the order trap, the fix
+	* check. The previous report from this instance's memory, else (it restarted; a serverless
+	* instance is new) the configured store's newest earlier report of the same page.
+	*/
+	async #since_for(stored, prev_in_memory) {
+		const { meta } = stored;
+		let prev = prev_in_memory;
+		if (!prev && meta.trigger === "page" && meta.page) try {
+			const earlier = (await this.#list_stored(50)).filter((r) => r.page === meta.page && r.id !== meta.id && r.created < meta.created).sort((a, b) => b.created - a.created)[0];
+			if (earlier) prev = earlier.id;
+		} catch {}
+		const P = prev ? this.#reports.get(prev) ?? await this.#report_load(prev) : void 0;
+		if (!P) return null;
+		try {
+			const cmp = compare_reports(this.#pack(P), this.#pack(stored));
+			const render = cmp.summary.find((r) => r.label.startsWith("render"));
+			let score;
+			try {
+				const sa = page_score_of(P.meta, this.#report_extras(P));
+				const sb = page_score_of(stored.meta, this.#report_extras(stored));
+				const moved = sb.categories.map((c) => ({
+					key: c.key,
+					label: c.label,
+					b: c.score,
+					a: sa.categories.find((x) => x.key === c.key)?.score ?? NaN
+				})).filter((m) => Number.isFinite(m.a) && Math.abs(m.b - m.a) >= 3).sort((x, y) => Math.abs(y.b - y.a) - Math.abs(x.b - x.a)).slice(0, 3);
+				score = {
+					a: sa.score,
+					b: sb.score,
+					a_grade: sa.grade,
+					b_grade: sb.grade,
+					moved
+				};
+			} catch {
+				score = void 0;
+			}
+			let assets;
+			try {
+				if (P.assets && stored.assets) {
+					const d = assets_diff(P.assets, stored.assets);
+					if (d.added.length || d.removed.length || d.grew.length || d.shrank.length || d.to_start.length || d.to_later.length) assets = d;
+				}
+			} catch {
+				assets = void 0;
+			}
+			let browser;
+			try {
+				const bf = (s) => {
+					const e = this.#report_extras(s);
+					if (!e.visit) return null;
+					const names = new Map(island_rows_of(s.meta).map((r) => [r.fp, r.name]));
+					return derive_findings(s.analysis, s.meta, e).filter((f) => f.fps).map((f) => `${f.code}${f.fps.length ? ` (${[...new Set(f.fps.map((fp) => names.get(fp) ?? fp.slice(0, 6)))].sort().join(", ")})` : ""}`);
+				};
+				const was = bf(P);
+				const now = bf(stored);
+				if (was && now) {
+					const fixed = was.filter((x) => !now.includes(x));
+					const added = now.filter((x) => !was.includes(x));
+					if (fixed.length || added.length) browser = {
+						fixed,
+						added
+					};
+				}
+			} catch {
+				browser = void 0;
+			}
+			let vitals;
+			try {
+				const va = this.#report_extras(P).visit;
+				const vb = this.#report_extras(stored).visit;
+				if (va && vb) {
+					const input = (v) => ({
+						vitals: v.vitals ?? {},
+						visit: {
+							nav: v.nav,
+							paints: v.paints,
+							resources: v.resources,
+							interaction: v.interaction,
+							font_faces: v.font_faces
+						},
+						islands: [],
+						firsts: [],
+						shifts: [],
+						longtasks: []
+					});
+					const moved = vitals_moved$1(va.vitals ?? {}, vb.vitals ?? {}, (side, key) => vital_parts(input(side === "a" ? va : vb), key));
+					if (moved.length) vitals = moved;
+				}
+			} catch {
+				vitals = void 0;
+			}
+			let islands;
+			try {
+				islands = island_files_diff(island_rows_of(P.meta), island_rows_of(stored.meta), (u) => stored.weights?.[u]) ?? void 0;
+			} catch {
+				islands = void 0;
+			}
+			return {
+				prev: P.meta.id,
+				...score ? { score } : {},
+				...browser ? { browser } : {},
+				...vitals ? { vitals } : {},
+				...islands ? { islands } : {},
+				...assets ? { assets } : {},
+				...render ? {
+					a_ms: render.a,
+					b_ms: render.b
+				} : {},
+				...cmp.render_same ? { same: true } : {},
+				moved: (cmp.drill ?? []).filter((r) => r.status !== "shifted").slice(0, 3),
+				...cmp.order ? { order: cmp.order } : {},
+				...cmp.fix_check ? { fix_check: cmp.fix_check } : {}
+			};
+		} catch {
+			return null;
+		}
+	}
+	/** this page's report just before `stored`, in this instance's memory */
+	#prev_in_memory(stored) {
+		const { meta } = stored;
+		if (meta.trigger !== "page" || !meta.page) return null;
+		const h = page_history([...this.#reports.values()].map((r) => r.meta)).find((x) => x.page === meta.page);
+		const i = h ? h.points.findIndex((p) => p.id === meta.id) : -1;
+		return i > 0 ? h.points[i - 1].id : null;
+	}
+	/** Store an uploaded dump as a report so it renders (+ hydrates) at its own /report/<id> URL — an
+	*  islands page can't be swapped in via document.write. No cpuprofile in a dump, so `raw` is empty
+	*  (its /raw link just 404s; everything else works). */
+	#store_uploaded(dump) {
+		const id = Math.random().toString(36).slice(2, 10);
+		this.#reports.set(id, this.#report_from_dump({
+			...dump,
+			meta: {
+				...dump.meta,
+				id
+			}
+		}));
+		while (this.#reports.size > this.max_reports) {
+			const oldest = this.#reports.keys().next().value;
+			if (oldest === void 0) break;
+			this.#reports.delete(oldest);
+		}
+		return id;
+	}
+	/** A StoredReport rebuilt from a portable dump (an uploaded `.ogp`, or one read back from the
+	*  storage backend). No cpuprofile survives a dump, so `raw` is empty (the `/raw` link 404s). */
+	#report_from_dump(dump) {
+		const e = dump.extras;
+		return {
+			meta: dump.meta,
+			analysis: dump.analysis,
+			heap: e.heap,
+			...e.heap_components ? { heap_components: e.heap_components } : {},
+			net: e.net,
+			mem: e.mem,
+			measures: e.measures ?? [],
+			gc: e.gc ?? null,
+			io: e.io ?? [],
+			call_counts: e.call_counts ?? {},
+			raw: "",
+			...e.weights ? { weights: e.weights } : {},
+			...e.contents ? { contents: e.contents } : {},
+			...e.heavy ? { heavy: e.heavy } : {},
+			...e.barrels ? { barrels: e.barrels } : {},
+			...e.hazards ? { hazards: e.hazards } : {},
+			...e.client ? { client: e.client } : {},
+			...e.vitals ? { vitals: e.vitals } : {},
+			...e.client_marks ? { client_marks: e.client_marks } : {},
+			...e.client_cpu ? { client_cpu: e.client_cpu } : {},
+			...e.interaction_cpu ? { interaction_cpu: e.interaction_cpu } : {},
+			...e.alloc ? { alloc: e.alloc } : {},
+			...e.contention ? { contention: e.contention } : {},
+			...e.lineage ? { lineage: e.lineage } : {},
+			...e.spans ? { spans: e.spans } : {},
+			...e.visit ? { visit: e.visit } : {},
+			...e.strip ? { strip: e.strip } : {},
+			...e.assets ? { assets: e.assets } : {},
+			...e.assets_missing ? { assets_missing: e.assets_missing } : {},
+			...e.river ? { river: e.river } : {},
+			...e.gc_attr ? { gc_attr: e.gc_attr } : {},
+			...e.promises ? { promises: e.promises } : {},
+			...e.retained ? { retained: e.retained } : {},
+			...e.ledger ? { ledger: e.ledger } : {},
+			...e.patterns ? { patterns: e.patterns } : {},
+			...e.drill ? { drill: e.drill } : {},
+			...e.forecast ? { forecast: e.forecast } : {},
+			...e.growth ? { growth: e.growth } : {}
+		};
+	}
+	/** Write a finished report to the durable store, when one is configured (a store failure never
+	*  fails the recording). The dump is the same portable JSON the `.ogp` export uses. The returned
+	*  promise settles when the write did: a serverless host freezes the process once the response
+	*  is sent, so a write left running after it may never land — the page recording awaits it. */
+	#persist(stored) {
+		if (!this.#store) return Promise.resolve();
+		const meta = stored.meta;
+		const median = meta.runs?.length ? [...meta.runs].sort((a, b) => a - b)[Math.floor(meta.runs.length / 2)] : null;
+		const rec = {
+			id: meta.id,
+			created: meta.created,
+			page: meta.page ?? null,
+			trigger: meta.trigger,
+			label: meta.page ?? meta.request?.path ?? meta.id,
+			median,
+			dump: JSON.stringify(report_dump(stored.analysis, meta, this.#report_extras(stored)))
+		};
+		return Promise.resolve().then(async () => {
+			await this.#store.putReport(rec);
+			await this.#store.prune?.(Math.max(this.max_reports * 8, 200));
+		}).catch((err) => {
+			if (process.env.OGYGIA_PROFILER_DEBUG) console.error("[ogygia/profiler] store.putReport failed:", err);
+		});
+	}
+	/** Memory first, then the durable store: read the dump back, reconstruct, cache in memory. */
+	async #report_load(id) {
+		if (!id) return void 0;
+		const hit = this.#reports.get(id);
+		if (hit) return hit;
+		if (!this.#store) return void 0;
+		try {
+			const json = await this.#store.getReport(id);
+			if (!json) return void 0;
+			const dump = JSON.parse(json);
+			if (!dump?.meta || !dump.analysis) return void 0;
+			const stored = this.#report_from_dump({
+				...dump,
+				meta: {
+					...dump.meta,
+					id
+				}
+			});
+			this.#reports.set(id, stored);
+			return stored;
+		} catch (err) {
+			if (process.env.OGYGIA_PROFILER_DEBUG) console.error("[ogygia/profiler] store.getReport failed:", err);
+			return;
+		}
+	}
+	/** The reports the durable store holds (summaries), newest first — the sidebar's shared list. */
+	async #list_stored(limit = 20) {
+		if (!this.#store) return [];
+		try {
+			return (await this.#store.listReports(limit)).map((r) => ({
+				id: r.id,
+				label: r.label,
+				page: r.page ?? void 0,
+				created: r.created
+			}));
+		} catch {
+			return [];
+		}
+	}
+	/** The full profile as an encrypted `.ogp` download (Brotli + AES-GCM, async — never blocks). */
+	async #ogp_response(id, stored) {
+		const bytes = await ogp_encode(report_dump(stored.analysis, stored.meta, this.#report_extras(stored)), this.secret);
+		return new Response(new Uint8Array(bytes), { headers: {
+			"content-type": "application/octet-stream",
+			"content-disposition": `attachment; filename="profile-${id}.ogp"`,
+			"cache-control": "no-store"
+		} });
+	}
+	#report_extras(stored) {
+		const client = stored.client ?? this.#client_for(stored);
+		const browser_page = stored.meta.page?.split("?")[0];
+		const vitals = stored.vitals ?? this.#vitals_for(browser_page);
+		const client_marks = stored.client_marks ?? this.#marks_for(browser_page);
+		const client_cpu = stored.client_cpu ?? (browser_page ? this.#client_cpus.get(browser_page) : void 0);
+		const own_visit = () => {
+			const created = stored.meta.created - 1e3;
+			if (stored.visit && stored.visit.at >= created) return stored.visit;
+			const list = browser_page ? this.#visits.get(browser_page) ?? [] : [];
+			let first;
+			for (const v of list) if (v.at >= created && (!first || v.at < first.at)) first = v;
+			return first ?? stored.visit ?? list.at(-1);
+		};
+		const visit = own_visit();
+		const answered = new Set((visit?.holes_answered ?? []).map((h) => h.id));
+		const hole_requests = answered.size ? this.#ring.filter((e) => e.hole && answered.has(e.hole.id) && e.ts >= visit.at - 1e3 && e.ts <= visit.at + 6e4).map((e) => ({
+			id: e.hole.id,
+			ms: Math.max(0, e.ms - (e.hole.queue_ms ?? 0)),
+			...e.hole.name ? { name: e.hole.name } : {},
+			...e.hole.p ? { p: e.hole.p } : {}
+		})) : [];
+		const nav_requests = (visit?.navs ?? []).map((n) => {
+			const lo = visit.at + n.t - 1e4;
+			const hi = visit.at + n.fetched + 50;
+			let hit;
+			for (const e of this.#ring) {
+				if (e.internal || e.method !== "GET" || e.path + (e.search ?? "") !== n.to || e.ts < lo || e.ts > hi) continue;
+				if (!hit || e.ts > hit.ts) hit = e;
+			}
+			return hit ? {
+				t: n.t,
+				ms: Math.round(hit.ms),
+				cpu_ms: Math.round(hit.cpu_ms),
+				net_ms: Math.round(hit.net_ms),
+				net_count: hit.net_count,
+				...hit.inflight ? { inflight: hit.inflight } : {}
+			} : null;
+		}).filter((x) => !!x);
+		let doc_request;
+		if (visit?.nav && stored.meta.page) {
+			const path = stored.meta.page.split("?")[0];
+			for (const e of this.#ring) {
+				if (e.internal || e.method !== "GET" || e.path !== path) continue;
+				if (e.ts < visit.at - 500 || e.ts > visit.at + visit.nav.res_start + 500) continue;
+				doc_request = { ms: Math.round(e.ms) };
+			}
+		}
+		const icpu = stored.interaction_cpu ?? (browser_page ? this.#interaction_cpus.get(browser_page) : void 0);
+		const interaction_cpu = icpu && visit?.interaction && Math.abs(icpu.t - visit.interaction.t) < 2 ? icpu : void 0;
+		const narrow = (v) => (v.viewport?.[0] ?? 0) < NARROW_SCREEN_PX;
+		const other_screen_visit = visit?.viewport && browser_page ? (this.#visits.get(browser_page) ?? []).filter((v) => v !== visit && v.viewport && narrow(v) !== narrow(visit)).at(-1) : void 0;
+		const engine = engine_of(visit?.ua);
+		const other_engine_visit = engine && browser_page ? (this.#visits.get(browser_page) ?? []).filter((v) => v !== visit && engine_of(v.ua) && engine_of(v.ua) !== engine).at(-1) : void 0;
+		const dupes = chunkDuplicates();
+		return {
+			...visit ? { visit } : {},
+			...other_screen_visit ? { other_screen_visit } : {},
+			...other_engine_visit ? { other_engine_visit } : {},
+			...dupes ? { dupes } : {},
+			...interaction_cpu ? { interaction_cpu } : {},
+			...hole_requests.length ? { hole_requests } : {},
+			...nav_requests.length ? { nav_requests } : {},
+			...doc_request ? { doc_request } : {},
+			...stored.strip ? { strip: stored.strip } : {},
+			...stored.assets ? { assets: stored.assets } : {},
+			...stored.assets_missing ? { assets_missing: stored.assets_missing } : {},
+			...stored.river ? { river: stored.river } : {},
+			...stored.gc_attr ? { gc_attr: stored.gc_attr } : {},
+			...stored.promises ? { promises: stored.promises } : {},
+			...stored.retained ? { retained: stored.retained } : {},
+			...stored.alloc ? { alloc: stored.alloc } : {},
+			...stored.contention ? { contention: stored.contention } : {},
+			...stored.lineage ? { lineage: stored.lineage } : {},
+			...stored.ledger ? { ledger: stored.ledger } : {},
+			...stored.patterns ? { patterns: stored.patterns } : {},
+			...stored.drill ? { drill: stored.drill } : {},
+			...stored.forecast ? { forecast: stored.forecast } : {},
+			...stored.growth ? { growth: stored.growth } : {},
+			net: stored.net,
+			spans: stored.spans ?? [],
+			heap: stored.heap,
+			...stored.heap_components ? { heap_components: stored.heap_components } : {},
+			mem: stored.mem,
+			measures: stored.measures,
+			gc: stored.gc,
+			io: stored.io,
+			call_counts: stored.call_counts,
+			...stored.weights ? { weights: stored.weights } : {},
+			...stored.contents ? { contents: stored.contents } : {},
+			...stored.heavy ? { heavy: stored.heavy } : {},
+			...stored.barrels ? { barrels: stored.barrels } : {},
+			...stored.hazards ? { hazards: stored.hazards } : {},
+			...client.length ? { client } : {},
+			...vitals ? { vitals } : {},
+			...client_marks?.length ? { client_marks } : {},
+			...client_cpu ? { client_cpu } : {},
+			...stored.replay ? { replay: stored.replay } : {}
+		};
+	}
+	/** The app's own browser marks for the page, per name (p50 / max over the visits). */
+	#marks_for(page) {
+		if (!page) return void 0;
+		const by_name = this.#marks.get(page);
+		if (!by_name?.size) return void 0;
+		const out = [];
+		for (const [name, a] of by_name) {
+			const ms = [...a.ms].sort((x, y) => x - y);
+			out.push({
+				name,
+				n: ms.length,
+				p50_ms: round2(percentile(ms, .5)),
+				max_ms: round2(ms[ms.length - 1] ?? 0),
+				errors: a.errors,
+				attr_keys: [...a.attr_keys].sort()
+			});
+		}
+		return out.sort((x, y) => y.p50_ms - x.p50_ms);
+	}
+	/** The page's web vitals as the profiler user's browser reported them (p50 over the visits). */
+	#vitals_for(page) {
+		if (!page) return void 0;
+		const e = this.#vitals.get(page);
+		if (!e || !e.samples.length) return void 0;
+		const p50 = (k) => {
+			const xs = e.samples.map((s) => s[k]).filter((x) => x !== void 0).sort((a, b) => a - b);
+			return xs.length ? round2(percentile(xs, .5)) : null;
+		};
+		return {
+			n: e.samples.length,
+			ttfb: p50("ttfb"),
+			fcp: p50("fcp"),
+			lcp: p50("lcp"),
+			cls: p50("cls"),
+			inp: p50("inp")
+		};
+	}
+	/** The browser's hydration timings for THIS report's islands: the beacon ring joined by
+	*  fingerprint (the same props → the same fingerprint, so a visit after the recording matches),
+	*  then merged per island — a list of 48 cards is 48 fingerprints and one row. */
+	#client_for(stored) {
+		const per_entry = /* @__PURE__ */ new Map();
+		const by_entry = /* @__PURE__ */ new Map();
+		for (const b of this.#beacons.values()) if (b.entry && b.ms.length) by_entry.set(entry_path(b.entry), b);
+		for (const r of island_rows_of(stored.meta)) {
+			const b = this.#beacons.get(r.fp) ?? by_entry.get(entry_path(r.entry));
+			if (!b || !b.ms.length) continue;
+			let e = per_entry.get(r.entry);
+			if (!e) per_entry.set(r.entry, e = {
+				fp: r.fp,
+				name: r.name,
+				ms: [],
+				load: [],
+				recovered: 0
+			});
+			e.ms.push(...b.ms);
+			e.load.push(...b.load);
+			e.recovered += b.recovered;
+			if (b.reason) e.reason = b.reason;
+		}
+		const out = [];
+		for (const [entry, e] of per_entry) {
+			const ms = e.ms.sort((x, y) => x - y);
+			const load = e.load.sort((x, y) => x - y);
+			out.push({
+				fp: e.fp,
+				entry,
+				name: e.name,
+				n: ms.length,
+				p50_ms: round2(percentile(ms, .5)),
+				max_ms: round2(ms[ms.length - 1]),
+				load_p50_ms: round2(percentile(load, .5)),
+				recovered: e.recovered,
+				...e.reason ? { reason: e.reason } : {}
+			});
+		}
+		return out;
+	}
+	/** `/replay/[id]`: profile a caught (or header-profiled) request again, in full page mode, with
+	*  the inputs it was caught with — its path and query, and the headers the trap config kept. */
+	async #replay(id, ctx) {
+		const stored = this.#reports.get(id ?? "");
+		if (!stored?.meta.request) return new Response("Nothing to replay: that report has no request.", { status: 404 });
+		const replay = stored.replay ?? {
+			path: stored.meta.request.path,
+			headers: {}
+		};
+		return this.#record_page(ctx, replay);
+	}
+	/** The browser's CPU profile (Chromium's JS Self-Profiling trace) → the same analysis as the
+	*  server's: components, functions, flame. Categories come from the chunk contents the build
+	*  recorded, since a client chunk's URL says nothing about what it holds. */
+	async #ingest_client_cpu(page, trace, origin, interaction) {
+		const profile = self_profile_to_cpuprofile(trace);
+		if (!profile) return false;
+		const find = await this.#client_file_finder(origin);
+		let rewritten = 0;
+		if (find) for (const n of profile.nodes) {
+			const file = find(n.callFrame.url);
+			if (file) {
+				n.callFrame.url = file;
+				rewritten++;
+			}
+		}
+		if (this.dev && origin) for (const n of profile.nodes) {
+			const u = n.callFrame.url;
+			if (u.startsWith(origin + "/")) {
+				n.callFrame.url = u.slice(origin.length);
+				rewritten++;
+			}
+		}
+		const resolver = rewritten || !this.dev ? await this.#make_resolver() : void 0;
+		const url_hint = (url, name) => {
+			let path;
+			try {
+				const u = new URL(url, "http://x");
+				path = u.pathname;
+				if (origin && u.host !== "x" && u.origin !== origin) return {
+					category: "dependency",
+					pkg: CDN_PKG_RE.exec(path)?.[1] ?? u.host
+				};
+			} catch {
+				return;
+			}
+			const rel = app_asset_rel(path);
+			if (rel) path = "/" + rel;
+			const inside = chunkContents(path);
+			if (inside) {
+				if (inside.every((s) => s === "svelte runtime")) return "svelte";
+				if (!inside.some((s) => s.startsWith("src/") || s.endsWith(".svelte") || s.startsWith("+"))) {
+					const pkgs = inside.map((s) => s.replace(/ runtime$/, "")).filter((s) => !s.startsWith("+"));
+					return {
+						category: "dependency",
+						pkg: pkgs.length > 2 ? `${pkgs[0]} +${pkgs.length - 1}` : pkgs.join(" + ")
+					};
+				}
+				return;
+			}
+			return SVELTE_CLIENT_FN_RE.test(name) ? "svelte" : void 0;
+		};
+		const served = (p) => {
+			const rel = app_asset_rel(p);
+			return rel ? "/" + rel : p;
+		};
+		const renamer = chunk_component_renamer((p) => chunkContents(served(p)));
+		const run = (p) => analyze(p, resolver, void 0, void 0, renamer, url_hint);
+		if (interaction) {
+			if (this.#interaction_cpus.size >= 50 && !this.#interaction_cpus.has(page)) this.#interaction_cpus.delete(this.#interaction_cpus.keys().next().value);
+			this.#interaction_cpus.set(page, {
+				...interaction_windows(profile, interaction, run),
+				at: Date.now()
+			});
+			return true;
+		}
+		const analysis = run(profile);
+		const visit = this.#visits.get(page)?.at(-1);
+		const windows = visit && Date.now() - visit.at < 12e4 ? client_windows(profile, visit, run) : void 0;
+		const i = visit && Date.now() - visit.at < 12e4 ? visit.interaction : void 0;
+		if (i && i.ms >= 200 && i.t * 1e3 >= profile.startTime && (i.t + i.ms) * 1e3 <= profile.endTime) {
+			const at = i.t + i.delay;
+			if (this.#interaction_cpus.size >= 50 && !this.#interaction_cpus.has(page)) this.#interaction_cpus.delete(this.#interaction_cpus.keys().next().value);
+			this.#interaction_cpus.set(page, {
+				...interaction_windows(profile, {
+					t: i.t,
+					wait: [i.t, at],
+					handler: [at, at + i.processing]
+				}, run),
+				at: Date.now()
+			});
+		}
+		if (this.#client_cpus.size >= 50 && !this.#client_cpus.has(page)) this.#client_cpus.delete(this.#client_cpus.keys().next().value);
+		this.#client_cpus.set(page, {
+			analysis,
+			at: Date.now(),
+			sample_ms: analysis.duration_ms,
+			...windows ? { windows } : {}
+		});
+		return true;
+	}
+	/** `/beacon` (POST, authed): the runtime's hydration timings — `{ islands: [{ fp, entry, ms, load }] }`.
+	*  Bounded every way (body, islands per post, fingerprints kept, samples per fingerprint). */
+	async #beacon(ctx) {
+		let body;
+		try {
+			const text = await ctx.request.text();
+			if (text.length > (text.includes("\"cpu\"") ? MAX_BEACON_CPU_BODY : text.includes("\"visit\"") ? MAX_BEACON_VISIT_BODY : MAX_BEACON_BODY)) return new Response(null, { status: 413 });
+			body = JSON.parse(text);
+		} catch {
+			return new Response(null, { status: 400 });
+		}
+		const islands = body?.islands;
+		const visit_body = body?.visit;
+		const vitals = body?.vitals ?? (visit_body && typeof visit_body === "object" ? visit_body.vitals : void 0);
+		const vitals_at_raw = Number(body?.at ?? (visit_body && typeof visit_body === "object" ? visit_body.at : void 0));
+		const vitals_at = Number.isFinite(vitals_at_raw) && vitals_at_raw > 0 ? Math.round(vitals_at_raw) : void 0;
+		const marks = body?.marks;
+		const cpu = body?.cpu;
+		const page = body?.page;
+		const visit_raw = body?.visit;
+		if (!Array.isArray(islands) && !(vitals && typeof vitals === "object") && !Array.isArray(marks) && !(cpu && typeof cpu === "object") && !(visit_raw && typeof visit_raw === "object")) return new Response(null, { status: 400 });
+		if (visit_raw && typeof visit_raw === "object") {
+			const visit = parse_visit(page, visit_raw);
+			if (!visit) return new Response(null, { status: 400 });
+			let list = this.#visits.get(visit.page);
+			if (!list) {
+				if (this.#visits.size >= MAX_VITALS_PATHS) this.#visits.delete(this.#visits.keys().next().value);
+				this.#visits.set(visit.page, list = []);
+			}
+			const same = list.findIndex((v) => v.at === visit.at);
+			if (same !== -1) list[same] = merge_visits(list[same], visit);
+			else {
+				list.push(visit);
+				if (list.length > MAX_VISITS_PER_PAGE) list.shift();
+			}
+		}
+		if (cpu && typeof cpu === "object" && typeof page === "string" && page.startsWith("/") && page.length <= 500 && this.#client_cpu) {
+			const it = body?.interaction;
+			const pair = (v) => Array.isArray(v) && v.length === 2 && v.every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0 && n < 36e5) && v[1] >= v[0] ? [v[0], v[1]] : null;
+			const wait = pair(it?.wait);
+			const handler = pair(it?.handler);
+			const spans = it && typeof it.t === "number" && Number.isFinite(it.t) && wait && handler ? {
+				t: it.t,
+				wait,
+				handler
+			} : void 0;
+			if (it && !spans) return new Response(null, { status: 400 });
+			if (!await this.#ingest_client_cpu(page, cpu, ctx.url.origin, spans)) return new Response(null, { status: 400 });
+		}
+		const now = Date.now();
+		if (Array.isArray(marks) && typeof page === "string" && page.startsWith("/") && page.length <= 500) {
+			let by_name = this.#marks.get(page);
+			if (!by_name) {
+				if (this.#marks.size >= MAX_VITALS_PATHS) this.#marks.delete(this.#marks.keys().next().value);
+				this.#marks.set(page, by_name = /* @__PURE__ */ new Map());
+			}
+			for (const m of marks.slice(0, MAX_BEACON_ISLANDS)) {
+				const name = typeof m?.name === "string" ? m.name.slice(0, 120) : "";
+				const ms = Number(m?.ms);
+				if (!name || !Number.isFinite(ms) || ms < 0 || ms > 6e5) continue;
+				let agg = by_name.get(name);
+				if (!agg) {
+					if (by_name.size >= 100) continue;
+					by_name.set(name, agg = {
+						ms: [],
+						errors: 0,
+						attr_keys: /* @__PURE__ */ new Set()
+					});
+				}
+				agg.ms.push(round2(ms));
+				if (agg.ms.length > MAX_BEACON_SAMPLES) agg.ms.shift();
+				const attrs = m?.attrs && typeof m.attrs === "object" ? m.attrs : null;
+				if (attrs?.error === true) agg.errors++;
+				for (const k of Object.keys(attrs ?? {}).slice(0, 12)) if (k !== "error") agg.attr_keys.add(k.slice(0, 40));
+			}
+		}
+		if (vitals && typeof vitals === "object" && typeof page === "string" && page.startsWith("/") && page.length <= 500) {
+			const v = vitals;
+			const num = (k, max) => {
+				const n = Number(v[k]);
+				return Number.isFinite(n) && n >= 0 && n <= max ? round2(n) : void 0;
+			};
+			const sample = vitals_at !== void 0 ? { at: vitals_at } : {};
+			const ttfb = num("ttfb", 6e5);
+			const fcp = num("fcp", 6e5);
+			const lcp = num("lcp", 6e5);
+			const cls = num("cls", 100);
+			const inp = num("inp", 6e5);
+			if (ttfb !== void 0) sample.ttfb = ttfb;
+			if (fcp !== void 0) sample.fcp = fcp;
+			if (lcp !== void 0) sample.lcp = lcp;
+			if (cls !== void 0) sample.cls = cls;
+			if (inp !== void 0) sample.inp = inp;
+			if (Object.keys(sample).some((k) => k !== "at")) {
+				let e = this.#vitals.get(page);
+				if (!e) {
+					if (this.#vitals.size >= MAX_VITALS_PATHS) {
+						let oldest;
+						let t = Infinity;
+						for (const [k, x] of this.#vitals) if (x.last < t) {
+							t = x.last;
+							oldest = k;
+						}
+						if (oldest !== void 0) this.#vitals.delete(oldest);
+					}
+					this.#vitals.set(page, e = {
+						samples: [],
+						last: now
+					});
+				}
+				e.last = now;
+				const same = sample.at !== void 0 ? e.samples.findIndex((s) => s.at === sample.at) : -1;
+				if (same !== -1) e.samples[same] = {
+					...e.samples[same],
+					...sample
+				};
+				else e.samples.push(sample);
+				if (e.samples.length > MAX_VITALS_SAMPLES) e.samples.shift();
+			}
+		}
+		for (const it of Array.isArray(islands) ? islands.slice(0, MAX_BEACON_ISLANDS) : []) {
+			const fp = typeof it?.fp === "string" ? it.fp : "";
+			const ms = Number(it?.ms);
+			const load = Number(it?.load);
+			if (!is_hex_id(fp) || !Number.isFinite(ms) || ms < 0 || ms > 6e5) continue;
+			let agg = this.#beacons.get(fp);
+			if (!agg) {
+				if (this.#beacons.size >= MAX_BEACON_FPS) {
+					let oldest;
+					let t = Infinity;
+					for (const [k, v] of this.#beacons) if (v.last < t) {
+						t = v.last;
+						oldest = k;
+					}
+					if (oldest !== void 0) this.#beacons.delete(oldest);
+				}
+				this.#beacons.set(fp, agg = {
+					entry: typeof it?.entry === "string" ? it.entry.slice(0, 300) : "",
+					ms: [],
+					load: [],
+					recovered: 0,
+					last: now
+				});
+			}
+			agg.last = now;
+			if (it?.recovered === true) agg.recovered++;
+			if (typeof it?.reason === "string" && it.reason) agg.reason = it.reason.slice(0, 300);
+			agg.ms.push(round2(ms));
+			agg.load.push(Number.isFinite(load) && load >= 0 ? round2(Math.min(load, ms)) : 0);
+			if (agg.ms.length > MAX_BEACON_SAMPLES) {
+				agg.ms.shift();
+				agg.load.shift();
+			}
+		}
+		return new Response(null, {
+			status: 204,
+			headers: { "cache-control": "no-store" }
+		});
+	}
+	/** The page the profiler's own user is about to view gets the beacon tag: the runtime posts its
+	*  hydration timings to `/beacon` when it sees it, and does nothing otherwise. The flag cookie
+	*  (set at login, site-wide, no secret) or the key header says it is that user; dev is open. The
+	*  tag goes at the end of `<head>` so the runtime bootstrap stays the first script. A visitor
+	*  never sees it; a stray flag with no session posts to a guarded route and gets nothing. */
+	async #beacon_tag(event) {
+		if (!this.ui_enabled) return null;
+		if (event.request.headers.get("x-og-profiler-internal") === "1") return null;
+		const dest = event.request.headers.get("sec-fetch-dest");
+		if (dest ? dest !== "document" : !(event.request.headers.get("accept") ?? "").includes("text/html")) return null;
+		if (!this.dev) {
+			const key = event.request.headers.get("x-profiler-key");
+			if (key ? !await this.#key_matches(key) : event.cookies.get("og_profiler_beacon") !== "1") return null;
+		}
+		return `<meta name="${BEACON_META}" content="${this.base}/beacon">${BEACON_STANDALONE_TAG}`;
+	}
+	handle = async ({ event, resolve }) => {
+		if (this.#disabled) return resolve(event);
+		this.#first_request_pt ??= performance.now();
+		this.#requests_seen++;
+		await this.#init();
+		const on_ui_path = event.url.pathname === this.base || event.url.pathname.startsWith(this.base + "/");
+		if (this.ui_enabled && on_ui_path) return this.#ui(event);
+		if (!this.#disabled && !this.ui_enabled && !this.dev && this.secret === "" && on_ui_path) return new Response("ogygia profiler is installed but disabled: set OGYGIA_PROFILER_SECRET (or `ogygia({ profiler: { secret } })`) to enable the UI in production.", {
+			status: 404,
+			headers: {
+				"content-type": "text/plain; charset=utf-8",
+				"cache-control": "no-store"
+			}
+		});
+		const remote = event.isRemoteRequest === true;
+		let remote_url = null;
+		if (remote) try {
+			remote_url = new URL(event.request.url);
+		} catch {
+			remote_url = null;
+		}
+		const entry = {
+			ts: Date.now(),
+			method: event.request.method,
+			path: remote_url ? remote_url.pathname : event.url.pathname,
+			...remote ? { remote: true } : {},
+			route: event.route?.id ?? null,
+			status: 0,
+			ms: 0,
+			cpu_ms: 0,
+			inflight: this.#inflight,
+			net_ms: 0,
+			net_count: 0,
+			internal: event.request.headers.get("x-og-profiler-internal") === "1" || void 0
+		};
+		try {
+			const search = remote_url ? remote_url.search : event.url.search;
+			if (search) entry.search = search;
+		} catch {}
+		if (this.#trap?.replay?.length) {
+			const kept = {};
+			for (const h of this.#trap.replay) {
+				const v = event.request.headers.get(h);
+				if (v !== null) kept[h.toLowerCase()] = v.slice(0, 2048);
+			}
+			if (Object.keys(kept).length) entry.replay_headers = kept;
+		}
+		const profile_header = event.request.headers.get("x-profile");
+		const header_profile = !!profile_header && this.ui_enabled && await this.#key_matches(profile_header) && this.#try_acquire_recorder();
+		const ctx = !!this.#als && (this.dev || this.#recording_active() && !this.#trap_running || header_profile) ? this.#request_ctx(entry) : null;
+		const answers = this.#answers;
+		if (ctx && answers && this.#kept && event.request.headers.get(ANSWERS_HEADER) === answers.token) {
+			const kept = this.#kept;
+			ctx.answer = (method, url) => {
+				const key = `${method} ${url}`;
+				return answers.keys.has(key) ? kept.get(key) : void 0;
+			};
+		}
+		const start = performance.now();
+		entry.pt = start;
+		const cpu0 = process.cpuUsage();
+		this.#inflight++;
+		if (ctx && this.#wrap_event_fetch && typeof event.fetch === "function") try {
+			event.fetch = this.#wrap_event_fetch(event.fetch);
+		} catch {}
+		const beacon_tag = await this.#beacon_tag(event);
+		const resolve_page = () => beacon_tag ? resolve(event, { transformPageChunk: ({ html }) => {
+			let at = html.indexOf("</head>");
+			if (at === -1) at = html.indexOf("</HEAD>");
+			return at === -1 ? html : html.slice(0, at) + beacon_tag + html.slice(at);
+		} }) : resolve(event);
+		const run = async () => {
+			const res = ctx && this.#als ? await this.#als.run(ctx, resolve_page) : await resolve_page();
+			entry.status = res.status;
+			if (beacon_tag && this.#client_cpu) try {
+				res.headers.set("document-policy", "js-profiling");
+			} catch {}
+			if (beacon_tag && !this.dev) mark_personal(res);
+			if (this.want_server_timing) try {
+				const ms = performance.now() - start;
+				res.headers.append("Server-Timing", `ssr;desc="SvelteKit render";dur=${ms.toFixed(1)}`);
+				try {
+					const c = process.cpuUsage(cpu0);
+					res.headers.append("Server-Timing", `cpu;desc="process CPU while it ran";dur=${((c.user + c.system) / 1e3).toFixed(1)}`);
+				} catch {}
+				if (ctx?.net.length) {
+					const net_ms = ctx.net.reduce((a, c) => a + Math.max(c.ms, 0) + (c.body_ms ?? 0), 0);
+					res.headers.append("Server-Timing", `net;desc="outbound (${ctx.net.length})";dur=${net_ms.toFixed(1)}`);
+					[...ctx.net].sort((x, y) => y.ms + (y.body_ms ?? 0) - (x.ms + (x.body_ms ?? 0))).slice(0, 3).forEach((x, i) => {
+						let where = x.url.split("?")[0].split("#")[0];
+						try {
+							const u = new URL(x.url, "http://relative.invalid");
+							where = (u.host === "relative.invalid" ? "" : u.host) + u.pathname;
+						} catch {}
+						const desc = `${x.method ?? "GET"} ${where}`.slice(0, 120).split("\"").join("'").split("\\").join("/");
+						res.headers.append("Server-Timing", `up${i + 1};desc="${desc}";dur=${(Math.max(x.ms, 0) + (x.body_ms ?? 0)).toFixed(1)}`);
+					});
+				}
+				if (event.request.headers.get("x-og-trace")) {
+					const c = process.cpuUsage(cpu0);
+					const net = ctx?.net ?? [];
+					res.headers.set(TRACE_HEADER, encode_trace({
+						ms: round2(ms),
+						cpu_ms: round2((c.user + c.system) / 1e3),
+						wait_ms: round2(net.reduce((a, x) => a + Math.max(x.ms, 0) + (x.body_ms ?? 0), 0)),
+						calls: net.length,
+						route: event.route?.id ?? null,
+						top: [...net].sort((x, y) => y.ms - x.ms).slice(0, 5).map((x) => ({
+							url: x.url.slice(0, 200),
+							ms: round2(x.ms + (x.body_ms ?? 0))
+						})),
+						profiler: this.base
+					}));
+				}
+			} catch {}
+			return res;
+		};
+		if (header_profile) {
+			this.#recording_since = Date.now();
+			const watchdog = setTimeout(() => {
+				this.#recording_since = 0;
+				this.#release_als();
+			}, 32e3);
+			watchdog.unref?.();
+			try {
+				let res;
+				const cap = await this.#capture_window(100, async () => {
+					res = await run();
+				});
+				this.#finalize(entry, start, cpu0, ctx, event.request);
+				cap.window = {
+					start,
+					end: start + entry.ms
+				};
+				const id = await this.#finish_report(cap, {
+					trigger: "request",
+					request: {
+						method: entry.method,
+						path: entry.path,
+						route: entry.route,
+						ms: entry.ms
+					}
+				});
+				const stored = this.#reports.get(id);
+				if (stored) stored.replay = {
+					path: entry.path + (entry.search ?? ""),
+					headers: entry.replay_headers ?? {}
+				};
+				try {
+					res?.headers.append("x-profile-report", `${this.base}/report/${id}`);
+				} catch {}
+				return res;
+			} finally {
+				clearTimeout(watchdog);
+				this.#recording_since = 0;
+				this.#release_als();
+				this.#release_recorder();
+			}
+		}
+		try {
+			return await run();
+		} finally {
+			this.#finalize(entry, start, cpu0, ctx, event.request);
+			if (event.request.headers.has(WINDOW_HEADER)) await this.#window_note(entry, event.request);
+		}
+	};
+	#finalize(entry, start, cpu0, ctx, request) {
+		this.#inflight--;
+		entry.ms = round2(performance.now() - start);
+		const c = process.cpuUsage(cpu0);
+		entry.cpu_ms = round2((c.user + c.system) / 1e3);
+		const og = request ? request_stats_of(request) : void 0;
+		if (og) entry.og = og;
+		const hole = request ? hole_stats_of(request) : void 0;
+		if (hole) entry.hole = hole;
+		if (ctx) {
+			entry.net_count = ctx.net.length;
+			entry.net_ms = round2(ctx.net.reduce((a, c) => a + Math.max(c.ms, 0) + (c.body_ms ?? 0), 0));
+			if (ctx.spans.length) {
+				entry.span_count = ctx.spans.length;
+				entry.span_ms = round2(ctx.spans.filter((s) => s.parent === void 0 && s.ms >= 0).reduce((a, s) => a + s.ms, 0));
+			}
+		}
+		this.#ring.push(entry);
+		if (this.#ring.length > this.ring_size) this.#ring.shift();
+		if (request) {
+			this.#logged.set(request, entry);
+			const early = this.#early_holes.get(request);
+			if (early) {
+				this.#early_holes.delete(request);
+				for (const s of early) this.#batch_hole(request, s);
+			}
+		}
+		if (this.#sink_url && !entry.internal) {
+			this.#sink.push({
+				k: "req",
+				t: entry.ts,
+				path: entry.path,
+				route: entry.route,
+				ms: entry.ms,
+				cpu: entry.cpu_ms,
+				wait: entry.net_ms,
+				status: entry.status,
+				...entry.og ? { og: entry.og.seed_bytes + entry.og.tail_bytes } : {}
+			});
+			if (Number.isFinite(serverless_work_budget_ms())) this.#sink_flush();
+		}
+	}
+	/** Post the buffered rows as NDJSON to the sink. One post in flight at a time; a failure keeps
+	*  the rows for the next try (the buffer drops its oldest request rows when full). */
+	async #sink_flush() {
+		if (this.#sink_timer && this.#superseded()) {
+			clearInterval(this.#sink_timer);
+			this.#sink_timer = null;
+		}
+		if (!this.#sink_url || this.#sink_inflight || !this.#sink.size) return;
+		this.#sink_inflight = true;
+		const rows = this.#sink.size;
+		const body = this.#sink.drain();
+		try {
+			const res = await fetch(this.#sink_url, {
+				method: "POST",
+				body,
+				headers: {
+					"content-type": "application/x-ndjson",
+					"x-og-profiler-internal": "1",
+					...this.#sink_key ? { authorization: `Bearer ${this.#sink_key}` } : {}
+				},
+				signal: AbortSignal.timeout(5e3)
+			});
+			this.#sink_last = {
+				at: Date.now(),
+				ok: res.ok,
+				rows,
+				...res.ok ? {} : { error: `the sink answered ${res.status}` }
+			};
+			if (!res.ok) {
+				for (const line of body.split("\n")) if (line) this.#sink.push(JSON.parse(line));
+			}
+		} catch (e) {
+			this.#sink_last = {
+				at: Date.now(),
+				ok: false,
+				rows,
+				error: e instanceof Error ? e.message : String(e)
+			};
+			for (const line of body.split("\n")) if (line) this.#sink.push(JSON.parse(line));
+		} finally {
+			this.#sink_inflight = false;
+		}
+	}
+	/** The site view's rows from THIS instance: the request ring and the sampler's windows — what a
+	*  long-lived host has without a sink. */
+	#site_rows() {
+		const rows = [];
+		for (const e of this.#ring) if (!e.internal) rows.push({
+			k: "req",
+			t: e.ts,
+			path: e.path,
+			route: e.route,
+			ms: e.ms,
+			cpu: e.cpu_ms,
+			wait: e.net_ms,
+			status: e.status,
+			...e.og ? { og: e.og.seed_bytes + e.og.tail_bytes } : {}
+		});
+		for (const w of this.#sampled) rows.push({
+			k: "win",
+			t0: w.at,
+			t1: w.at + w.ms,
+			fns: w.functions.slice(0, 40).map((f) => ({
+				name: f.name,
+				file: f.url,
+				self_ms: f.self_ms,
+				category: f.category
+			}))
+		});
+		for (const r of this.#reports.values()) if (r.meta.trigger === "trap" && r.meta.request) rows.push({
+			k: "trap",
+			t: r.meta.created,
+			path: r.meta.request.path,
+			ms: r.meta.request.ms,
+			id: r.meta.id
+		});
+		return rows;
+	}
+	/** `/site`: the whole-site pictures (the request cloud, the layer cake) from this instance's
+	*  rows, or from a sink the browser reads (`?from=<url>`, or the configured sink). */
+	#site(ctx) {
+		const from = ctx.url.searchParams.get("from");
+		return {
+			base: this.base,
+			rows: this.#site_rows(),
+			sink: this.#sink_url ? {
+				url: this.#sink_url,
+				last: this.#sink_last,
+				buffered: this.#sink.size
+			} : null,
+			from: from && /^https?:\/\//.test(from) ? from.slice(0, 2e3) : null,
+			ephemeral: Number.isFinite(serverless_work_budget_ms())
+		};
+	}
+};
+/**
+* Build a profiler handle. INTERNAL — the profiler is configured in vite.config.ts
+* (`ogygia({ profiler: true })`) and `ogygia.handle()` constructs + mounts this itself.
+* Kept as a named export only so the handle's lazy import can reach it; it is not a
+* public entry point.
+*
+* See the class doc and README for what it captures. Visit `<path>` (default
+* /__profiler) — in prod, log in (or send the x-profiler-key header).
+*/
+function profiler(options = {}) {
+	const instance = new Profiler(options);
+	return (args) => instance.handle(args);
+}
+function route_aggregates(ring, by = null) {
+	const by_route = /* @__PURE__ */ new Map();
+	for (const e of ring) {
+		if (e.internal) continue;
+		const key = (e.route ?? "(no route)") + (by ? ` · ${by}=${e.tags?.[by] ?? "—"}` : "");
+		let list = by_route.get(key);
+		if (!list) by_route.set(key, list = []);
+		list.push(e);
+	}
+	const aggs = [];
+	for (const [route, list] of by_route) {
+		const sorted = list.map((e) => e.ms).sort((a, b) => a - b);
+		const net = list.map((e) => e.net_ms).sort((a, b) => a - b);
+		aggs.push({
+			route,
+			count: list.length,
+			p50: pct(sorted, 50),
+			p95: pct(sorted, 95),
+			max: sorted.at(-1) ?? 0,
+			avg: round2(sorted.reduce((a, c) => a + c, 0) / (sorted.length || 1)),
+			net_p50: pct(net, 50)
+		});
+	}
+	return aggs.sort((a, b) => b.p95 - a.p95);
+}
+function pct(sorted, p) {
+	if (!sorted.length) return 0;
+	return sorted[Math.min(sorted.length - 1, Math.floor(p / 100 * sorted.length))];
+}
+function clamp(n, lo, hi) {
+	return Math.max(lo, Math.min(hi, Number.isFinite(n) ? n : lo));
+}
+/** Race a promise against a wall-time so a hung render can never pin a recording (and, through the
+*  attribution AsyncLocalStorage, the whole site). Rejects with `label` on timeout; the underlying work
+*  is left to settle on its own — the caller has already moved on. */
+function with_timeout(p, ms, label) {
+	if (!Number.isFinite(ms) || ms <= 0) return p;
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new Error(label)), ms);
+		timer.unref?.();
+	});
+	return Promise.race([p.finally(() => clearTimeout(timer)), timeout]);
+}
+/** OGYGIA_PROFILER_DEBUG: the process's memory at a step of a recording (what the profiler itself
+*  holds on a small serverless instance) */
+function mem_mark(step) {
+	if (!process.env.OGYGIA_PROFILER_DEBUG) return;
+	const m = process.memoryUsage();
+	const mb = (n) => Math.round(n / 1048576);
+	console.error(`[ogygia/profiler] memory ${step} @${Math.round(performance.now())} ms: rss ${mb(m.rss)} heap ${mb(m.heapUsed)} external ${mb(m.external)} buffers ${mb(m.arrayBuffers)} MB`);
+}
+function round2(n) {
+	return Math.round(n * 100) / 100;
+}
+/** What names a report: kept whatever `fields` asks for. */
+const REPORT_IDENTITY = [
+	"schema",
+	"version",
+	"engine",
+	"kind",
+	"id",
+	"created",
+	"target",
+	"links"
+];
+/** `report` with only the top-level keys in `fields` (comma-separated) and its identity; whole when unset. */
+function pick_fields(report, fields) {
+	if (!fields) return report;
+	const want = /* @__PURE__ */ new Set([...REPORT_IDENTITY, ...fields.split(",").map((f) => f.trim()).filter(Boolean)]);
+	const out = {};
+	for (const k in report) if (want.has(k)) out[k] = report[k];
+	return out;
+}
+/**
+* The module (src-relative, no extension: `lib/inferno/catalog`) a file imports `name` from — its
+* `import { name } from '$lib/…'` or `'./…'` — or the file itself when it declares it. Undefined for
+* a package import, or a name it cannot place. Plain text, no regex.
+*/
+/**
+* Is the route in `dir` prerendered? Kit takes the NEAREST `export const prerender`: the page's own
+* files first (`+page.server`, `+page`), then each layout up the tree. `true` and `'auto'` prerender;
+* `false` (or none found) does not. String search over the files (no regex, no parse).
+*/
+function route_prerendered(read, dir) {
+	let at = dir;
+	let first = true;
+	while (at) {
+		const names = [
+			...first ? [
+				"+page.server.ts",
+				"+page.server.js",
+				"+page.ts",
+				"+page.js"
+			] : [],
+			"+layout.server.ts",
+			"+layout.server.js",
+			"+layout.ts",
+			"+layout.js"
+		];
+		for (const n of names) {
+			const src = read(`${at}/${n}`);
+			if (!src) continue;
+			const k = src.indexOf("export const prerender");
+			if (k === -1) continue;
+			const eq = src.indexOf("=", k);
+			const v = eq === -1 ? "" : src.slice(eq + 1, eq + 12).trim();
+			return v.startsWith("true") || v.startsWith("'auto'") || v.startsWith("\"auto\"");
+		}
+		first = false;
+		const up = at.lastIndexOf("/");
+		if (up === -1) break;
+		at = at.slice(0, up);
+	}
+	return false;
+}
+/** An island entry as a path, however it was written (`./_app/x.js`, `/_app/x.js`, an absolute URL). */
+function entry_path(entry) {
+	try {
+		return new URL(entry, "http://x/").pathname;
+	} catch {
+		return entry;
+	}
+}
+function imported_from(src, name, file) {
+	const self = file.slice(0, file.lastIndexOf("."));
+	for (const line of src.split("\n")) {
+		const l = line.trim();
+		if (!l.startsWith("import")) {
+			if ((l.startsWith(`function ${name}(`) || l.startsWith(`export function ${name}(`) || l.startsWith(`async function ${name}(`) || l.startsWith(`export async function ${name}(`) || l.startsWith(`const ${name} =`)) && !l.startsWith("import")) return self;
+			continue;
+		}
+		const open = l.indexOf("{");
+		const close = l.indexOf("}");
+		if (!(open !== -1 && close > open ? l.slice(open + 1, close).split(",").map((x) => x.trim().split(" as ").pop().trim()) : []).includes(name)) continue;
+		const q = Math.max(l.lastIndexOf("'"), l.lastIndexOf("\""));
+		const q0 = Math.max(l.lastIndexOf("'", q - 1), l.lastIndexOf("\"", q - 1));
+		const spec = q0 !== -1 && q > q0 ? l.slice(q0 + 1, q) : "";
+		const bare = (p) => p.endsWith(".ts") || p.endsWith(".js") ? p.slice(0, -3) : p;
+		if (spec.startsWith("$lib/")) return bare(`lib/${spec.slice(5)}`);
+		if (spec.startsWith(".")) {
+			const parts = file.split("/").slice(0, -1);
+			for (const seg of spec.split("/")) if (seg === "..") parts.pop();
+			else if (seg !== ".") parts.push(seg);
+			return bare(parts.join("/"));
+		}
+		return;
+	}
+}
+export { pick_fields, profiler, route_prerendered, self_profile_to_cpuprofile };