@ogygia/devtools 0.12.0 → 0.13.0

package/dist/messages/runtime.js

@@ -0,0 +1,122 @@
+import { define_messages, dev_or_prerender, prose } from "@ogygia/core/internal/messages";
+// src/messages/runtime.ts
+/**
+* EVERY MESSAGE THE PROFILER'S SERVER HALF AND THE DOCK PRINT, in one place: its code, its wording,
+* what to do about it (core's `@ogygia/core/internal/messages` says how the system works).
+*
+*   console.error(new OgygiaError('devtools_profiler_store_init_failed'), e);
+*   warn('devtools_profiler_session_rejected', { path, diagnosis, reason });
+*
+* It runs in the app's server build (and the dock's launcher in its browser bundle), so the wording is
+* only passed in dev: a production build prints the code's page alone. The Vite plugin's messages are
+* in ./build.ts.
+*/
+/** The errors: `throw new OgygiaError(code, args)`, or `console.error(new OgygiaError(…), err)` for a
+*  failure that is caught. */
+const DEVTOOLS_ERRORS = {
+	devtools_profiler_store_init_failed: {
+		text: () => "store init failed; falling back to in-memory:",
+		details: () => prose`
+			The profiler's \`store\` threw while it initialized (a missing driver, a bad path, a
+			database it cannot reach; the error follows the message). The profiler keeps its reports
+			in memory instead, so they are gone when the server restarts.
+		`
+	},
+	devtools_profiler_mount_failed: {
+		text: () => "the profiler could not start; requests are served without it:",
+		details: () => prose`
+			The profiler (\`devtools({ profiler })\`) loads on the first request, and loading it
+			failed (the error follows the message): a runtime without \`node:inspector\` (an edge
+			runtime), or a dev server in the middle of an edit. Every request is still answered,
+			unprofiled, and the next request tries to start it again. Said once per server.
+		`
+	},
+	devtools_profiler_alloc_sampling_unavailable: {
+		text: () => "allocation sampling unavailable, GC attribution off:",
+		details: () => prose`
+			Printed with \`OGYGIA_PROFILER_DEBUG\` set. The runtime refused the heap sampling the
+			profiler asked for (the error follows the message), so this recording does not say which
+			code caused its garbage collection.
+		`
+	},
+	devtools_profiler_gc_attribution_failed: {
+		text: () => "GC attribution failed:",
+		details: () => prose`
+			Printed with \`OGYGIA_PROFILER_DEBUG\` set. Working out which code caused the recording's
+			garbage collection threw (the error follows the message); the report leaves that part
+			out.
+		`
+	},
+	devtools_profiler_put_report_failed: {
+		text: () => "store.putReport failed:",
+		details: () => prose`
+			Printed with \`OGYGIA_PROFILER_DEBUG\` set. The profiler's \`store\` failed to save a
+			report (the error follows the message). The report stays in memory, but is gone when the
+			server restarts.
+		`
+	},
+	devtools_profiler_get_report_failed: {
+		text: () => "store.getReport failed:",
+		details: () => prose`
+			Printed with \`OGYGIA_PROFILER_DEBUG\` set. The profiler's \`store\` failed to read a
+			report back (the error follows the message), so the report is answered as not found.
+		`
+	},
+	devtools_dock_load_failed: {
+		text: () => "the devtools dock’s code failed to load (click its button to try again):",
+		details: () => prose`
+			The browser could not download the devtools dock's code (the network failed, or a deploy
+			removed the file; the error follows the message). The page is not affected, and the
+			dock's button stays: a click, or Alt+O, asks for the code again under a fresh URL.
+		`
+	}
+};
+/** The warnings: `warn(code, args, ...rest)`. */
+const DEVTOOLS_WARNINGS = {
+	devtools_profiler_session_rejected: {
+		text: (a) => `session not accepted on ${a.path}: ${a.diagnosis} — ${a.reason}`,
+		details: () => prose`
+			A browser sent a profiler session cookie, or had just logged in, and the profiler still
+			did not accept it. \`diagnosis\` counts what the request carried (never a cookie's value)
+			and \`reason\` reads it: no cookie reached the server (a proxy or CDN in front of the app
+			drops it), the browser sent several session cookies, or the session is not valid (the
+			profiler secret differs between server instances).
+
+			Forward cookies to the profiler's path, clear the site's cookies and log in again, or
+			give every instance the same secret.
+		`
+	},
+	devtools_profiler_sink_undelivered: {
+		text: (a) => `the sink never took a post of ${a.rows} rows, after every try; they are dropped:`,
+		details: () => prose`
+			The profiler posts the rows it reads (\`sink: { url }\`) one post at a time, in order, and
+			tries a failed post again a few times before the next one goes. This post failed every
+			time (the last error follows the message), so its rows are not at the sink and the site
+			view misses those requests. The site page shows the sink's last answer.
+
+			Check the sink's URL, its key, and that it answers 2xx once it stored a post. A post
+			carries an \`idempotency-key\` header: a sink that stored a post already can answer ok
+			for its copy.
+		`
+	},
+	devtools_profiler_background_stopped: {
+		text: (a) => `the profiler's ${a.loop} stopped: a background window failed:`,
+		details: () => prose`
+			The trap (\`trap\`) and the always-on sampler (\`sample\`) record short windows in the
+			background with the process's inspector. One of those windows failed (the error follows
+			the message): most often the inspector is held by another debugger, or the host has none.
+			That loop records no more windows in this process; the dashboard says so under "In the
+			background", with what the trap caught before it stopped.
+
+			Detach the other debugger and restart the server, or turn \`trap\` / \`sample\` off on this
+			host.
+		`
+	}
+};
+const own = /* @__PURE__ */ define_messages(import.meta.env?.DEV || import.meta.env?.SSR ? DEVTOOLS_ERRORS : null, import.meta.env?.DEV || import.meta.env?.SSR ? DEVTOOLS_WARNINGS : null, dev_or_prerender);
+/** `throw new OgygiaError(code, args)`; `warn(code, args, ...rest)` logs; `line(code, args)` is the
+*  line as a string. Wording and link in dev and while prerendering, the link alone otherwise. */
+const OgygiaError = own.OgygiaError;
+const warn = own.warn;
+const line = own.line;
+export { DEVTOOLS_ERRORS, DEVTOOLS_WARNINGS, OgygiaError, line, warn };

package/dist/profiler/async-io.d.ts

@@ -26,8 +26,17 @@ export interface IoOp {
    *  across the runs, before the io is scoped to one) — a timer each render starts and never ends */
   left_each_run?: true;
 }
-export interface IoRecorder {
-  stop(): IoOp[];
+/** `fn (dir/file:line)` from a generated position: what a promise origin reads as when no
+ *  sourcemap maps it */
+export declare function short_site(s: CallerSite): string;
+/** Times I/O resources over one recording window: `IoRecorder.start()` at its start, `stop()` at
+ *  its end. */
+export declare class IoRecorder {
+  #private;
+  /** Start timing I/O resources; null without `async_hooks` (edge) — the fetch patch and wall/CPU
+   *  split still work there. */
+  static start(): Promise<IoRecorder | null>;
+  constructor(async_hooks: typeof import("node:async_hooks"));
   /** promises created while the recorder ran, and who created them (one stack per
    *  PROMISE_SAMPLE_EVERY promises — a counter otherwise) */
   promises(): {
@@ -38,12 +47,8 @@ export interface IoRecorder {
       site?: CallerSite;
     }[];
   };
+  stop(): IoOp[];
 }
-/** `fn (dir/file:line)` from a generated position: what a promise origin reads as when no
- *  sourcemap maps it */
-export declare function short_site(s: CallerSite): string;
-/** Start timing I/O resources. Call `stop()` at the end of the window. */
-export declare function record_async_io(): Promise<IoRecorder | null>;
 /**
  * A timer a render starts and never ends: an interval (or a timeout of a second or more) still open
  * after every render, started from the same line in each of them. One per render is the proof it is

package/dist/profiler/async-io.js

@@ -61,91 +61,103 @@ function short_site(s) {
 	const clean = q === -1 ? s.file : s.file.slice(0, q);
 	return `${s.fn} (${clean.split("/").slice(-2).join("/")}:${s.line})`;
 }
-/** Start timing I/O resources. Call `stop()` at the end of the window. */
-async function record_async_io() {
-	let async_hooks;
-	try {
-		async_hooks = await import("node:async_hooks");
-	} catch {
-		return null;
-	}
-	const open = /* @__PURE__ */ new Map();
-	const ops = [];
-	let promise_count = 0;
+/** Times I/O resources over one recording window: `IoRecorder.start()` at its start, `stop()` at
+*  its end. */
+var IoRecorder = class IoRecorder {
+	#open = /* @__PURE__ */ new Map();
+	#ops = [];
+	#promise_count = 0;
 	/** generated `fn\0file\0line` → how many sampled promises it made, and the site itself */
-	const promise_sites = /* @__PURE__ */ new Map();
-	const hook = async_hooks.createHook({
-		init(asyncId, type, _trigger, resource) {
-			if (type === "PROMISE") {
-				if (++promise_count % PROMISE_SAMPLE_EVERY === 0 && promise_sites.size < 200) {
-					const site = nearest_own_or_dep_site() ?? null;
-					const k = site ? site.fn + "\0" + site.file + "\0" + site.line : "";
-					const hit = promise_sites.get(k);
-					if (hit) hit.n++;
-					else promise_sites.set(k, {
-						n: 1,
-						site
-					});
-				}
-				return;
-			}
-			if (open.size >= MAX || !TRACK.has(type)) return;
-			const s = {
-				t: performance.now(),
-				type,
-				site: nearest_app_site()
-			};
-			if (type === "Timeout") {
-				const r = resource;
-				if (typeof r._repeat === "number" && r._repeat > 0) s.repeat = r._repeat;
-				else if (typeof r._idleTimeout === "number" && r._idleTimeout >= 0) s.delay = r._idleTimeout;
-				s.timer = r;
+	#promise_sites = /* @__PURE__ */ new Map();
+	#hook;
+	/** Start timing I/O resources; null without `async_hooks` (edge) — the fetch patch and wall/CPU
+	*  split still work there. */
+	static async start() {
+		let async_hooks;
+		try {
+			async_hooks = await import("node:async_hooks");
+		} catch {
+			return null;
+		}
+		return new IoRecorder(async_hooks);
+	}
+	constructor(async_hooks) {
+		this.#hook = async_hooks.createHook({
+			init: (asyncId, type, _trigger, resource) => this.#init(asyncId, type, resource),
+			destroy: (asyncId) => this.#destroy(asyncId)
+		});
+		this.#hook.enable();
+	}
+	/** promises created while the recorder ran, and who created them (one stack per
+	*  PROMISE_SAMPLE_EVERY promises — a counter otherwise) */
+	promises() {
+		const sampled = [...this.#promise_sites.values()].reduce((a, b) => a + b.n, 0) || 1;
+		return {
+			count: this.#promise_count,
+			top: [...this.#promise_sites.values()].sort((a, b) => b.n - a.n).slice(0, 8).map(({ n, site }) => ({
+				caller: site ? short_site(site) : "(no frame outside node)",
+				share: Math.round(n / sampled * 100) / 100,
+				...site ? { site } : {}
+			}))
+		};
+	}
+	stop() {
+		this.#hook.disable();
+		const ops = this.#ops;
+		const now = performance.now();
+		for (const s of this.#open.values()) if (ops.length < MAX) ops.push({
+			type: s.type,
+			caller_site: s.site,
+			ms: round2(now - s.t),
+			start: s.t,
+			open: true,
+			...s.repeat !== void 0 ? { repeat: s.repeat } : {},
+			...s.delay !== void 0 ? { delay: s.delay } : {},
+			...s.timer?.hasRef?.() === false ? { unref: true } : {}
+		});
+		this.#open.clear();
+		return ops;
+	}
+	#init(asyncId, type, resource) {
+		if (type === "PROMISE") {
+			if (++this.#promise_count % PROMISE_SAMPLE_EVERY === 0 && this.#promise_sites.size < 200) {
+				const site = nearest_own_or_dep_site() ?? null;
+				const k = site ? site.fn + "\0" + site.file + "\0" + site.line : "";
+				const hit = this.#promise_sites.get(k);
+				if (hit) hit.n++;
+				else this.#promise_sites.set(k, {
+					n: 1,
+					site
+				});
 			}
-			open.set(asyncId, s);
-		},
-		destroy(asyncId) {
-			const s = open.get(asyncId);
-			if (!s) return;
-			open.delete(asyncId);
-			if (ops.length < MAX) ops.push({
-				type: s.type,
-				caller_site: s.site,
-				ms: round2(performance.now() - s.t),
-				start: s.t
-			});
+			return;
 		}
-	});
-	hook.enable();
-	return {
-		promises() {
-			const sampled = [...promise_sites.values()].reduce((a, b) => a + b.n, 0) || 1;
-			return {
-				count: promise_count,
-				top: [...promise_sites.values()].sort((a, b) => b.n - a.n).slice(0, 8).map(({ n, site }) => ({
-					caller: site ? short_site(site) : "(no frame outside node)",
-					share: Math.round(n / sampled * 100) / 100,
-					...site ? { site } : {}
-				}))
-			};
-		},
-		stop() {
-			hook.disable();
-			const now = performance.now();
-			for (const s of open.values()) if (ops.length < MAX) ops.push({
-				type: s.type,
-				caller_site: s.site,
-				ms: round2(now - s.t),
-				start: s.t,
-				open: true,
-				...s.repeat !== void 0 ? { repeat: s.repeat } : {},
-				...s.delay !== void 0 ? { delay: s.delay } : {},
-				...s.timer?.hasRef?.() === false ? { unref: true } : {}
-			});
-			open.clear();
-			return ops;
+		if (this.#open.size >= MAX || !TRACK.has(type)) return;
+		const s = {
+			t: performance.now(),
+			type,
+			site: nearest_app_site()
+		};
+		if (type === "Timeout") {
+			const r = resource;
+			if (typeof r._repeat === "number" && r._repeat > 0) s.repeat = r._repeat;
+			else if (typeof r._idleTimeout === "number" && r._idleTimeout >= 0) s.delay = r._idleTimeout;
+			s.timer = r;
 		}
-	};
-}
+		this.#open.set(asyncId, s);
+	}
+	#destroy(asyncId) {
+		const s = this.#open.get(asyncId);
+		if (!s) return;
+		this.#open.delete(asyncId);
+		if (this.#ops.length < MAX) this.#ops.push({
+			type: s.type,
+			caller_site: s.site,
+			ms: round2(performance.now() - s.t),
+			start: s.t
+		});
+	}
+};
 /**
 * A timer a render starts and never ends: an interval (or a timeout of a second or more) still open
 * after every render, started from the same line in each of them. One per render is the proof it is
@@ -184,4 +196,4 @@ function io_kind(type) {
 function round2(n) {
 	return Math.round(n * 100) / 100;
 }
-export { io_kind, mark_left_each_run, record_async_io, short_site };
+export { IoRecorder, io_kind, mark_left_each_run, short_site };

package/dist/profiler/beacon-standalone.js

@@ -34,7 +34,7 @@ function standalone_beacon() {
 	const seen = [];
 	let off = false;
 	let cls = 0;
-	let sent = false;
+	let visit_state = "open";
 	let resend;
 	/** visits sent while the page lives (the early one, then re-sends): at most 8 */
 	let early_sends = 0;
@@ -147,7 +147,7 @@ function standalone_beacon() {
 	function send(body, slim) {
 		const room = 6e4 - queued;
 		if (body.length > room) {
-			if (!sent && document.visibilityState === "visible") return post(body, false);
+			if (visit_state !== "sent" && document.visibilityState === "visible") return post(body, false);
 			const smaller = slim?.();
 			if (!smaller || smaller.length > room) return;
 			body = smaller;
@@ -333,8 +333,9 @@ function standalone_beacon() {
 	}
 	/** the page is going away: the vitals (final only now), the visit, the CPU trace */
 	function hide() {
-		if (runtime_claimed() || sent) return;
-		sent = true;
+		if (runtime_claimed() || visit_state === "sent") return;
+		visit_state = "sent";
+		clearTimeout(resend);
 		if (Object.keys(vitals).length) send(JSON.stringify({
 			page: location.pathname,
 			at: Math.round(performance.timeOrigin),
@@ -353,6 +354,10 @@ function standalone_beacon() {
 		}));
 		cpu(true);
 	}
+	/** the page is shown again (its tab, or a back/forward cache restore): the visit goes on */
+	function show() {
+		if (visit_state === "sent") visit_state = "reopened";
+	}
 	/** a later paint or shift: the visit again a moment later (debounced), once one has gone */
 	function again() {
 		if (!early_sends || early_sends >= 8) return;
@@ -371,7 +376,7 @@ function standalone_beacon() {
 	}
 	/** the visit while the page lives: the early one, and each re-send */
 	function early() {
-		if (runtime_claimed() || early_sends >= 8) return;
+		if (runtime_claimed() || visit_state === "sent" || early_sends >= 8) return;
 		early_sends++;
 		const v = visit();
 		if (v) send(JSON.stringify({
@@ -387,7 +392,7 @@ function standalone_beacon() {
 		} catch {}
 		if (profiler) {
 			try {
-				profiler.stop();
+				profiler.stop().catch(() => {});
 			} catch {}
 			profiler = null;
 		}
@@ -396,8 +401,12 @@ function standalone_beacon() {
 		if (document.querySelector("script[data-ogygia-runtime]")) return stand_down();
 		document.addEventListener("visibilitychange", () => {
 			if (document.visibilityState === "hidden") hide();
+			else show();
 		});
 		addEventListener("pagehide", hide);
+		addEventListener("pageshow", (e) => {
+			if (e.persisted) show();
+		});
 		addEventListener("load", () => setTimeout(early, 1500));
 	});
 }

package/dist/profiler/busy.d.ts

@@ -0,0 +1,13 @@
+import { Scope, Stale } from "@ogygia/machine";
+/** What a caller shows while it waits: each ask as it starts, each wait for a busy worker (with
+ *  the time waited so far). */
+export interface BusyWatch {
+  asking?: () => void;
+  busy?: (waited_ms: number) => void;
+}
+/**
+ * `fetch(url)` until the answer is not a 409, or the wait runs out (the last 409 is the answer: the
+ * caller says so). `owner` owns the asks and the waits: once it ends, the request is aborted,
+ * nothing more is asked, and the answer is `STALE`.
+ */
+export declare function fetch_when_free(owner: Scope, url: string, init?: RequestInit, { asking, busy }?: BusyWatch): Promise<Response | Stale>;

package/dist/profiler/busy.js

@@ -0,0 +1,45 @@
+import { STALE, policy } from "@ogygia/machine";
+// src/profiler/busy.ts
+/**
+* Waiting for a busy profiler. A worker records one profile at a time (the V8 profiler is
+* process-wide): one that is recording answers `/page` with a 409. There is no queue on the server
+* (a serverless worker is recycled within ~30 s), so the queue lives with the caller: ask again
+* until a worker takes it. On serverless the next ask lands on a free worker; on one server it is
+* taken once the profile ahead ends. Both the dock's tabs and the run page wait this one way.
+*/
+/** How a profile waits for a busy profiler: asked again every 2 s (or when the 409's
+*  `Retry-After` says), for up to 2 min; a profile ahead longer than that is a stuck one (Reset). */
+const PROFILER_BUSY = policy({
+	attempts: 61,
+	backoff: 2e3,
+	jitter: 0,
+	deadline: 12e4
+});
+/** The wait before the next ask, after a 409: its `Retry-After` (seconds), else the policy's. */
+function busy_wait(res) {
+	const after = Number(res.headers.get("retry-after")) * 1e3;
+	return Number.isFinite(after) && after > 0 ? after : PROFILER_BUSY.backoff;
+}
+/**
+* `fetch(url)` until the answer is not a 409, or the wait runs out (the last 409 is the answer: the
+* caller says so). `owner` owns the asks and the waits: once it ends, the request is aborted,
+* nothing more is asked, and the answer is `STALE`.
+*/
+async function fetch_when_free(owner, url, init = {}, { asking, busy } = {}) {
+	const started = Date.now();
+	for (let n = 1;; n++) {
+		asking?.();
+		const res = await owner.task((signal) => fetch(url, {
+			...init,
+			signal
+		}));
+		if (res === STALE || res.status !== 409) return res;
+		const waited = Date.now() - started;
+		if (n >= PROFILER_BUSY.attempts || waited > PROFILER_BUSY.deadline) return res;
+		busy?.(waited);
+		const wait = busy_wait(res);
+		res.body?.cancel().catch(() => {});
+		if (await owner.task(() => new Promise((r) => owner.timeout(r, wait))) === STALE) return STALE;
+	}
+}
+export { fetch_when_free };

package/dist/profiler/client.js

@@ -1,32 +1,13 @@
 // src/profiler/client.ts
 const BEACON_KEY = Symbol.for("ogygia.beacon");
-const page_beacon = () => globalThis[BEACON_KEY];
-const waiting = [];
-let retrying = false;
+const WAITING_KEY = Symbol.for("ogygia.beacon.waiting");
 function beacon_mark(...args) {
 	if (typeof document === "undefined") return;
-	const b = page_beacon();
-	if (b) {
-		for (const w of waiting.splice(0)) b.beacon_mark(...w);
-		b.beacon_mark(...args);
-		return;
-	}
+	const g = globalThis;
+	const b = g[BEACON_KEY];
+	if (b) return b.beacon_mark(...args);
+	const waiting = g[WAITING_KEY] ??= [];
 	if (waiting.length < 400) waiting.push(args);
-	if (retrying) return;
-	retrying = true;
-	let tries = 0;
-	const retry = () => {
-		const later = page_beacon();
-		if (later) {
-			retrying = false;
-			for (const w of waiting.splice(0)) later.beacon_mark(...w);
-		} else if (++tries < 40) setTimeout(retry, 250);
-		else {
-			retrying = false;
-			waiting.length = 0;
-		}
-	};
-	setTimeout(retry, 250);
 }
 const now = () => typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
 const is_thenable = (v) => !!v && typeof v.then === "function";

package/dist/profiler/embedded-maps.js

@@ -1,9 +1,14 @@
+import { STALE, flights } from "@ogygia/machine";
 import { PROFILER_MAPS_GZ_PREFIX } from "@ogygia/core/internal/compiler-ids";
 // src/profiler/embedded-maps.ts
-let loaded;
 let ready = null;
 function load_embedded_maps() {
-	loaded ??= import("virtual:ogygia/profiler-maps").then(async (m) => {
+	return loaded.get().then((maps) => maps === STALE ? null : maps);
+}
+/** The read, once for the process (it never fails: an unreadable payload is no maps). */
+const loaded = flights({
+	name: "profiler embedded maps",
+	run: () => import("virtual:ogygia/profiler-maps").then(async (m) => {
 		let raw = m.default;
 		if (typeof raw === "string" && raw.startsWith(PROFILER_MAPS_GZ_PREFIX)) raw = (await import("node:zlib")).gunzipSync(Buffer.from(raw.slice(PROFILER_MAPS_GZ_PREFIX.length), "base64")).toString("utf8");
 		if (typeof raw !== "string" || !raw.startsWith("{")) return null;
@@ -14,9 +19,8 @@ function load_embedded_maps() {
 			...p.sources && typeof p.sources === "object" ? { sources: p.sources } : {},
 			...p.chunks && typeof p.chunks === "object" ? { chunks: p.chunks } : {}
 		} : null;
-	}).catch(() => null);
-	return loaded;
-}
+	}).catch(() => null)
+});
 /** the maps once loaded (synchronous readers: the module map lookup), else null */
 const embedded_maps = () => ready;
 /** a script's key in the payload: its path under the server output (`chunks/format.js`), whether it

package/dist/profiler/gc.d.ts

@@ -127,6 +127,11 @@ export declare function gc_kind(kind: number): GcEvent["kind"];
 export declare function heap_sites(head: HeapNode, dict: Record<string, AllocSite>): Map<string, number>;
 /** What was allocated between two reads: per site, the growth of its cumulative bytes. */
 export declare function slice_delta(prev: Map<string, number>, cur: Map<string, number>): Record<string, number>;
+/**
+ * Each pause of a profiled window charged to the allocations before it, and each allocator to
+ * the pause time it caused.
+ * @heisenbench n log n in input
+ */
 export declare function attribute_gc(input: {
   slices: AllocSlice[];
   events: GcEvent[];

package/dist/profiler/gc.js

@@ -97,20 +97,58 @@ function slice_delta(prev, cur) {
 const r1 = (n) => Math.round(n * 10) / 10;
 const r2 = (n) => Math.round(n * 100) / 100;
 const mb = (b) => r1(b / 1048576);
+/**
+* What was running at each moment of `times`: the first segment (in the timeline's order) that
+* holds it, else the last to end before it, within 50 ms. A collector, idle or profiler segment is
+* not the app's own work. The moments are swept in order, so the timeline is read about once
+* instead of once per moment.
+*/
+function running_at_each(segs, times) {
+	const work = segs.filter((s) => s.category !== "gc" && s.category !== "idle" && s.category !== "profiler");
+	const at = [...new Set(times)].filter((t) => !Number.isNaN(t)).sort((a, b) => a - b);
+	const found = [];
+	const open = Array.from({ length: at.length + 1 }, (_, k) => k);
+	const next_open = (k) => {
+		while (open[k] !== k) k = open[k] = open[open[k]];
+		return k;
+	};
+	for (const s of work) {
+		if (!(s.t0 <= s.t1)) continue;
+		let lo = 0;
+		let hi = at.length;
+		while (lo < hi) {
+			const mid = lo + hi >>> 1;
+			if (at[mid] < s.t0) lo = mid + 1;
+			else hi = mid;
+		}
+		for (let k = next_open(lo); k < at.length && at[k] <= s.t1; k = next_open(k + 1)) {
+			found[k] = s;
+			open[k] = k + 1;
+		}
+	}
+	const by_end = work.map((s, i) => ({
+		s,
+		i
+	})).filter(({ s }) => !Number.isNaN(s.t1)).sort((a, b) => a.s.t1 - b.s.t1 || a.i - b.i);
+	const out = /* @__PURE__ */ new Map();
+	let best;
+	for (let k = 0, j = 0; k < at.length; k++) {
+		for (; j < by_end.length && by_end[j].s.t1 <= at[k]; j++) if (!best || by_end[j].s.t1 > best.t1) best = by_end[j].s;
+		out.set(at[k], found[k] ?? (best && at[k] - best.t1 <= 50 ? best : void 0));
+	}
+	return out;
+}
+/**
+* Each pause of a profiled window charged to the allocations before it, and each allocator to
+* the pause time it caused.
+* @heisenbench n log n in input
+*/
 function attribute_gc(input) {
 	const { slices, dict } = input;
 	const events = [...input.events].sort((a, b) => a.t - b.t);
 	const single = slices.length === 1;
-	const running_at = (t) => {
-		const segs = input.running ?? [];
-		let best;
-		for (const s of segs) {
-			if (s.category === "gc" || s.category === "idle" || s.category === "profiler") continue;
-			if (s.t0 <= t && t <= s.t1) return s;
-			if (s.t1 <= t && (!best || s.t1 > best.t1)) best = s;
-		}
-		return best && t - best.t1 <= 50 ? best : void 0;
-	};
+	const run_by_t = running_at_each(input.running ?? [], events.map((e) => e.t));
+	const running_at = (t) => run_by_t.get(t);
 	const ours = (k) => {
 		const c = dict[k]?.category;
 		return c !== "v8" && c !== "gc" && c !== "profiler";
@@ -121,10 +159,36 @@ function attribute_gc(input) {
 		return d ? `${d.name}|${d.url}|${d.line}|${d.caller ?? ""}|${d.component ?? ""}` : k;
 	};
 	const first_key = {};
+	const by_t0 = slices.map((s, i) => ({
+		s,
+		i
+	})).filter(({ s }) => s.t1 - s.t0 > 0).sort((a, b) => a.s.t0 - b.s.t0 || a.i - b.i);
+	const reach = [];
+	for (const { s } of by_t0) reach.push(Math.max(reach[reach.length - 1] ?? -Infinity, s.t1));
+	const read_in_order = by_t0.every((x, j) => j === 0 || by_t0[j - 1].i < x.i);
+	const first_where = (holds) => {
+		let lo = 0;
+		let hi = by_t0.length;
+		while (lo < hi) {
+			const mid = lo + hi >>> 1;
+			if (holds(mid)) hi = mid;
+			else lo = mid + 1;
+		}
+		return lo;
+	};
 	const between = (from, to) => {
 		const acc = {};
 		let profiler_bytes = 0;
-		for (const s of slices) {
+		if (!(from < to)) return {
+			app: acc,
+			profiler_bytes
+		};
+		const hits = [];
+		const end = first_where((j) => by_t0[j].s.t0 >= to);
+		for (let j = first_where((j) => reach[j] > from); j < end; j++) if (by_t0[j].s.t1 > from) hits.push(by_t0[j].i);
+		if (!read_in_order) hits.sort((a, b) => a - b);
+		for (const i of hits) {
+			const s = slices[i];
 			const len = s.t1 - s.t0;
 			if (len <= 0 || s.t1 <= from || s.t0 > to) continue;
 			const w = Math.max(0, Math.min(1, (Math.min(s.t1, to) - Math.max(s.t0, from)) / len));