@ogygia/devtools 0.0.0 → 0.11.1

package/dist/profiler/score.d.ts

@@ -0,0 +1,109 @@
+export type ScoreKey = "js" | "weight" | "blocking" | "html" | "data" | "hydration" | "server" | "loading" | "stability" | "responsiveness";
+/** A category's contribution: its own 0–100 score, the weight it carries, and why. */
+export interface ScoreCategory {
+  key: ScoreKey;
+  label: string;
+  /** 0–100 */
+  score: number;
+  /** relative weight BEFORE renormalization */
+  weight: number;
+  /** the measured value behind the score, already formatted */
+  value: string;
+  /** one line: what this measures and, when it lost points, why */
+  note: string;
+  /** the biggest contributors (files, islands, metrics), already formatted */
+  detail?: string[];
+  /** the points it cost the total (its weight share × the gap to 100), filled at the end */
+  lost?: number;
+}
+export interface PageScore {
+  /** 0–100, weighted over the categories that had data */
+  score: number;
+  /** A ≥90, B ≥75, C ≥60, D ≥40, else F */
+  grade: "A" | "B" | "C" | "D" | "F";
+  categories: ScoreCategory[];
+  /** the single biggest point loss — what to fix first, or null at a top score */
+  worst: ScoreCategory | null;
+  /** categories left out for want of a measurement, with why */
+  missing: {
+    key: ScoreKey;
+    label: string;
+    why: string;
+  }[];
+}
+export interface ScoreAssets {
+  /** JS run at start (document scripts, modulepreloads, their static imports, at-start islands), decoded */
+  js: number;
+  js_wire: number;
+  js_files: number;
+  /** JS loaded later, on demand (lazy islands), decoded */
+  lazy_js: number;
+  css: number;
+  /** every byte at start on the wire, HTML included */
+  wire: number;
+  /** stylesheets + classic sync scripts in <head>, decoded */
+  blocking: number;
+  blocking_count: number;
+  /** the biggest files, formatted `name size` */
+  top?: string[];
+}
+export interface ScoreInputs {
+  /** the page's measured weight (page-assets.ts), or null when it could not be weighed (a dev
+   *  server serves modules one by one: its graph says nothing about a build) */
+  assets: ScoreAssets | null;
+  /** why `assets` is null, for the report */
+  assets_missing?: string;
+  /** the HTML document, decoded bytes (null: not captured) */
+  htmlBytes: number | null;
+  /** what a browser visit fetched for nothing: pixels past what each image's box shows, preloads
+   *  nothing used (said in the page weight's note; the score stays the weighed bytes') */
+  wasted?: {
+    bytes: number;
+    images: number;
+    preloads: number;
+  };
+  /** does the page have islands at all (hydration integrity is about islands) */
+  hasIslands: boolean;
+  /** hydrations that discarded the server DOM and re-rendered */
+  recovered: number;
+  /** islands that should have woken but never reported */
+  neverWoke: number;
+  /** islands whose markup changed on hydration without a recovery */
+  changed?: number;
+  /** has the browser reported at all (no visits: integrity unknown) */
+  browserSeen: boolean;
+  /** data shipped for hydration: the page seed + props + remote seed + inline script text, bytes */
+  dataBytes: number;
+  dataDetail?: string[];
+  /** SSR render time, ms (p50). null when not measured */
+  serverMs: number | null;
+  /** the browser's vitals over the visits, or null when none reported */
+  vitals: {
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+    fcp?: number | null;
+    ttfb?: number | null;
+  } | null;
+  /** total blocking time from the visits' long tasks (Σ over each task of ms − 50), or null */
+  tbt: number | null;
+  /** measures the visiting browser could not take, with why (`tbt`, `cls`): named in `missing`,
+   *  never scored as a clean zero */
+  unmeasured?: {
+    tbt?: string;
+    cls?: string;
+  };
+}
+/** 0–100 on a log-normal curve through (p10 → 90) and (median → 50). Lower values score higher. */
+export declare function curve(value: number, p10: number, median: number): number;
+export declare function fmt_bytes(bytes: number): string;
+type CurveKey = "js" | "weight" | "blocking" | "html" | "data" | "server" | "lcp" | "fcp" | "ttfb" | "cls" | "inp" | "tbt";
+/** The control points, in one place: [p10 (scores 90), median (scores 50)]. */
+export declare const CURVES: { readonly [K in CurveKey]: readonly [p10: number, median: number]; };
+/**
+ * Weights (before renormalization): JS 30 · server 15 · hydration 15 · loading 10 · data 10 ·
+ * weight 10 · responsiveness 10 · blocking 5 · HTML 5 · stability 5. What a visitor pays first —
+ * JS to run, time to first byte, a page that works as it wakes — carries the most.
+ */
+export declare function page_score(inp: ScoreInputs): PageScore;
+export {};

package/dist/profiler/score.js

@@ -0,0 +1,261 @@
+// src/profiler/score.ts
+/**
+* THE PAGE SCORE — one 0–100 number for a page, scored on what a visitor pays for, whatever built
+* the page: every byte of JS it runs at start (islands or not — a Kit-hydrated page's whole start
+* graph counts), the weight on the wire, what blocks the first paint, the HTML, the data shipped for
+* hydration, the server's render time, hydration integrity, and the browser's own vitals. A page
+* built with ogygia wins by shipping less, not because the score only looks at islands.
+*
+* CURVES, NOT CLIFFS: each metric maps to 0–100 on a log-normal curve (the one Lighthouse uses): a
+* control point where it scores 90 (`p10`) and one where it scores 50 (`median`). Twice the median
+* still scores a little, half the p10 is near 100 — every byte and millisecond moves the number.
+*
+* Pure and inputs-only so it unit-tests trivially and the curves are one place to tune. A category
+* with no measurement is DROPPED (never a free 100) and the weights renormalize — the report says
+* which were left out and why.
+*/
+const KB = 1024;
+const MB = 1048576;
+/** erf, Abramowitz–Stegun 7.1.26 (|error| < 1.5e-7) — as Lighthouse's statistics module. */
+function erf(x) {
+	const sign = Math.sign(x);
+	x = Math.abs(x);
+	const a1 = .254829592;
+	const a2 = -.284496736;
+	const a3 = 1.421413741;
+	const a4 = -1.453152027;
+	const a5 = 1.061405429;
+	const t = 1 / (1 + .3275911 * x);
+	return sign * (1 - t * (a1 + t * (a2 + t * (a3 + t * (a4 + t * a5)))) * Math.exp(-x * x));
+}
+/** 0–100 on a log-normal curve through (p10 → 90) and (median → 50). Lower values score higher. */
+function curve(value, p10, median) {
+	if (!(value > 0)) return 100;
+	const INVERSE_ERFC_ONE_FIFTH = .9061938024368232;
+	const x = Math.log(value / median);
+	const p10_log = -Math.log(p10 / median);
+	const s = (1 - erf(x * INVERSE_ERFC_ONE_FIFTH / p10_log)) / 2;
+	const n = Math.round(s * 100);
+	return Math.max(0, Math.min(100, s >= .899999 ? n : Math.min(89, n)));
+}
+function grade_of(score) {
+	if (score >= 90) return "A";
+	if (score >= 75) return "B";
+	if (score >= 60) return "C";
+	if (score >= 40) return "D";
+	return "F";
+}
+function fmt_bytes(bytes) {
+	if (bytes >= MB) return `${(bytes / MB).toFixed(bytes >= 10 * MB ? 0 : 1)} MB`;
+	if (bytes >= KB) return `${Math.round(bytes / KB)} KB`;
+	return `${bytes} B`;
+}
+const ms = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)} s` : `${Math.round(n)} ms`;
+/** The control points, in one place: [p10 (scores 90), median (scores 50)]. */
+const CURVES = {
+	js: [150 * KB, 700 * KB],
+	weight: [400 * KB, 1.6 * MB],
+	blocking: [25 * KB, 150 * KB],
+	html: [80 * KB, 500 * KB],
+	data: [15 * KB, 150 * KB],
+	server: [50, 300],
+	lcp: [1200, 2500],
+	fcp: [900, 1800],
+	ttfb: [200, 800],
+	cls: [.05, .2],
+	inp: [100, 300],
+	tbt: [100, 400]
+};
+/**
+* Weights (before renormalization): JS 30 · server 15 · hydration 15 · loading 10 · data 10 ·
+* weight 10 · responsiveness 10 · blocking 5 · HTML 5 · stability 5. What a visitor pays first —
+* JS to run, time to first byte, a page that works as it wakes — carries the most.
+*/
+function page_score(inp) {
+	const cats = [];
+	const missing = [];
+	const a = inp.assets;
+	if (a) {
+		const [p10, med] = CURVES.js;
+		const js = curve(a.js, p10, med);
+		cats.push({
+			key: "js",
+			label: "JS at start",
+			score: js,
+			weight: 30,
+			value: `${fmt_bytes(a.js)} in ${a.js_files} file${a.js_files === 1 ? "" : "s"}`,
+			note: js >= 90 ? `The browser runs ${fmt_bytes(a.js)} of JS to start the page${a.lazy_js ? `; ${fmt_bytes(a.lazy_js)} more loads only when an island needs it` : ""}.` : `The browser downloads, parses and runs ${fmt_bytes(a.js)} of JS before the page is ready (${fmt_bytes(a.js_wire)} on the wire)${a.lazy_js ? `, plus ${fmt_bytes(a.lazy_js)} on demand` : ""}. Every script counts, not only islands: make static parts plain HTML (a lake), move heavy imports to the server, wake islands when visible or on interaction.`,
+			...a.top?.length ? { detail: a.top } : {}
+		});
+		const wt = curve(a.wire, CURVES.weight[0], CURVES.weight[1]);
+		cats.push({
+			key: "weight",
+			label: "Page weight",
+			score: wt,
+			weight: 10,
+			value: `${fmt_bytes(a.wire)} on the wire`,
+			note: (wt >= 90 ? "Light on the wire." : `${fmt_bytes(a.wire)} crosses the network before the page is complete (HTML, scripts, styles, fonts, images at start). Slow connections pay for every one.`) + (inp.wasted ? ` A visit fetched ${fmt_bytes(inp.wasted.bytes)} for nothing: ${[inp.wasted.images ? `${fmt_bytes(inp.wasted.images)} of image pixels bigger than their boxes` : "", inp.wasted.preloads ? `${fmt_bytes(inp.wasted.preloads)} of preloads nothing used` : ""].filter(Boolean).join(" and ")}.` : "")
+		});
+		const bl = curve(a.blocking + a.blocking_count * 8 * KB, CURVES.blocking[0], CURVES.blocking[1]);
+		cats.push({
+			key: "blocking",
+			label: "Render-blocking",
+			score: bl,
+			weight: 5,
+			value: `${a.blocking_count} file${a.blocking_count === 1 ? "" : "s"}, ${fmt_bytes(a.blocking)}`,
+			note: bl >= 90 ? "Little stands between the HTML and the first paint." : `${a.blocking_count} stylesheet(s) or sync script(s) in <head> (${fmt_bytes(a.blocking)}) must arrive before anything paints. Inline small CSS, merge the rest, load scripts as modules.`
+		});
+	} else missing.push({
+		key: "js",
+		label: "JS, page weight, render-blocking",
+		why: inp.assets_missing ?? "the page could not be weighed"
+	});
+	if (inp.htmlBytes !== null) {
+		const h = curve(inp.htmlBytes, CURVES.html[0], CURVES.html[1]);
+		cats.push({
+			key: "html",
+			label: "HTML document",
+			score: h,
+			weight: 5,
+			value: fmt_bytes(inp.htmlBytes),
+			note: h >= 90 ? "A compact document." : `The HTML is ${fmt_bytes(inp.htmlBytes)}: the browser parses all of it before it is interactive. The byte strip shows which part (markup, shadow roots, props, seed) is the bulk.`
+		});
+	}
+	{
+		const d = curve(inp.dataBytes, CURVES.data[0], CURVES.data[1]);
+		cats.push({
+			key: "data",
+			label: "Data shipped",
+			score: d,
+			weight: 10,
+			value: fmt_bytes(inp.dataBytes),
+			note: d >= 90 ? "Little data rides along for hydration." : `${fmt_bytes(inp.dataBytes)} of data (page seed, island props, inline script) ships so the browser can wake the page — serialized per request, parsed in the browser. Read fewer page.data keys in islands, pass smaller props.`,
+			...inp.dataDetail?.length ? { detail: inp.dataDetail } : {}
+		});
+	}
+	if (inp.hasIslands && inp.browserSeen) {
+		const changed = inp.changed ?? 0;
+		const h = Math.round(100 * Math.exp(-(inp.recovered * .45 + inp.neverWoke * .35 + changed * .12)));
+		cats.push({
+			key: "hydration",
+			label: "Hydration integrity",
+			score: h,
+			weight: 15,
+			value: `${inp.recovered} recovered · ${inp.neverWoke} never woke${changed ? ` · ${changed} changed` : ""}`,
+			note: h >= 99 ? "Every island woke cleanly from its server markup." : `${inp.recovered} island(s) threw away their server HTML and rendered again (a flash + a double render), ${inp.neverWoke} never woke${changed ? `, ${changed} changed their markup as they woke` : ""}. The Islands table names each and why.`
+		});
+	} else if (inp.hasIslands) missing.push({
+		key: "hydration",
+		label: "Hydration integrity",
+		why: "no browser visit reported yet (open the page with the profiler on)"
+	});
+	if (inp.serverMs !== null) {
+		const s = curve(inp.serverMs, CURVES.server[0], CURVES.server[1]);
+		cats.push({
+			key: "server",
+			label: "Server render",
+			score: s,
+			weight: 15,
+			value: ms(inp.serverMs),
+			note: s >= 90 ? "The server renders the page quickly." : `${ms(inp.serverMs)} of server work before the first byte leaves. The forecast and findings above name what to cut.`
+		});
+	} else missing.push({
+		key: "server",
+		label: "Server render",
+		why: "no server timing in this report"
+	});
+	const v = inp.vitals;
+	const loading = [];
+	if (v?.lcp != null) loading.push({
+		s: curve(v.lcp, CURVES.lcp[0], CURVES.lcp[1]),
+		w: 60,
+		t: `LCP ${ms(v.lcp)}`
+	});
+	if (v?.fcp != null) loading.push({
+		s: curve(v.fcp, CURVES.fcp[0], CURVES.fcp[1]),
+		w: 25,
+		t: `FCP ${ms(v.fcp)}`
+	});
+	if (v?.ttfb != null) loading.push({
+		s: curve(v.ttfb, CURVES.ttfb[0], CURVES.ttfb[1]),
+		w: 15,
+		t: `TTFB ${ms(v.ttfb)}`
+	});
+	if (loading.length) {
+		const w = loading.reduce((x, p) => x + p.w, 0);
+		const s = Math.round(loading.reduce((x, p) => x + p.s * p.w, 0) / w);
+		cats.push({
+			key: "loading",
+			label: "Loading",
+			score: s,
+			weight: 10,
+			value: loading.map((p) => p.t).join(" · "),
+			note: s >= 90 ? "The page paints its main content quickly." : "The main content took long to paint in the visits measured. A slow first byte, blocking files, or a late-loading hero image are the usual causes.",
+			detail: loading.map((p) => `${p.t} → ${p.s}`)
+		});
+	} else missing.push({
+		key: "loading",
+		label: "Loading (LCP/FCP/TTFB)",
+		why: "no browser visit reported vitals"
+	});
+	if (v?.cls != null) {
+		const s = curve(v.cls, CURVES.cls[0], CURVES.cls[1]);
+		cats.push({
+			key: "stability",
+			label: "Visual stability",
+			score: s,
+			weight: 5,
+			value: `CLS ${v.cls}`,
+			note: s >= 90 ? "Nothing jumps around." : `Content moved as the page loaded (CLS ${v.cls}). Reserve space for images and islands; render islands at their final size on the server.`
+		});
+	} else missing.push({
+		key: "stability",
+		label: "Visual stability (CLS)",
+		why: inp.unmeasured?.cls ?? "no browser visit reported layout shifts"
+	});
+	const resp = [];
+	if (v?.inp != null) resp.push({
+		s: curve(v.inp, CURVES.inp[0], CURVES.inp[1]),
+		t: `INP ${ms(v.inp)}`
+	});
+	if (inp.tbt !== null) resp.push({
+		s: curve(inp.tbt, CURVES.tbt[0], CURVES.tbt[1]),
+		t: `blocking time ${ms(inp.tbt)}`
+	});
+	if (resp.length && inp.tbt === null && inp.unmeasured?.tbt) missing.push({
+		key: "responsiveness",
+		label: "Blocking time (part of responsiveness)",
+		why: inp.unmeasured.tbt
+	});
+	if (resp.length) {
+		const s = Math.round(resp.reduce((x, p) => x + p.s, 0) / resp.length);
+		cats.push({
+			key: "responsiveness",
+			label: "Responsiveness",
+			score: s,
+			weight: 10,
+			value: resp.map((p) => p.t).join(" · "),
+			note: (s >= 90 ? "The main thread stayed free to answer input in the visits measured." : "Long tasks held the main thread in the visits measured: input waited. Less JS at start, and lighter hydration, free it.") + " (Measured on the machine that visited: a slower phone pays more for the same JS — which JS at start scores.)",
+			detail: resp.map((p) => `${p.t} → ${p.s}`)
+		});
+	} else missing.push({
+		key: "responsiveness",
+		label: "Responsiveness (INP/blocking time)",
+		why: inp.unmeasured?.tbt ?? "no browser visit reported long tasks or interactions"
+	});
+	const total_weight = cats.reduce((s, c) => s + c.weight, 0);
+	const score = total_weight ? Math.round(cats.reduce((s, c) => s + c.score * c.weight, 0) / total_weight) : 0;
+	let worst = null;
+	for (const c of cats) {
+		c.lost = Math.round(c.weight / (total_weight || 1) * (100 - c.score) * 10) / 10;
+		if (c.lost > 0 && (!worst || c.lost > (worst.lost ?? 0))) worst = c;
+	}
+	return {
+		score,
+		grade: grade_of(score),
+		categories: cats,
+		worst,
+		missing
+	};
+}
+export { CURVES, curve, fmt_bytes, page_score };

package/dist/profiler/session-cookie.d.ts

@@ -0,0 +1,28 @@
+import { RequestEvent } from "@sveltejs/kit";
+export declare const SESSION_COOKIE = "og_profiler";
+/** Marks the navigation the login page makes right after a successful unlock: if THAT request still
+ *  carries no session, the guard explains instead of sending the browser back to the login page. It
+ *  carries no secret — only "a login just succeeded". */
+export declare const AFTER_LOGIN_PARAM = "og-after-login";
+/** What a request that failed auth carried (profiler/index.ts `#cookie_diagnosis`). */
+export interface CookieDiagnosis {
+  /** a `Cookie` header arrived at all */
+  header: boolean;
+  /** its length in bytes (characters; cookie headers are ASCII) */
+  bytes: number;
+  /** how many `og_profiler=` pairs the raw header holds */
+  pairs: number;
+  /** whether Kit's own parser (`event.cookies.get`) found one */
+  parsed: boolean;
+}
+/**
+ * Every value of the cookie `name` in a raw `Cookie` header, in order — duplicates included (a
+ * browser sends two same-named cookies when their paths or domains differ; a parser that keeps one
+ * may keep the stale one). Percent-decoded where it decodes; kept raw where it does not, so one
+ * malformed neighbour cannot hide the session.
+ */
+export declare function raw_cookie_values(header: string, name: string): string[];
+/** Every candidate session value on a request: Kit's parsed cookie first, then every raw pair. */
+export declare function session_cookie_values(event: RequestEvent): string[];
+/** The one-line account of a failed session, for the server log and the login page. */
+export declare function describe_cookie_diagnosis(d: CookieDiagnosis): string;

package/dist/profiler/session-cookie.js

@@ -0,0 +1,45 @@
+// src/profiler/session-cookie.ts
+const SESSION_COOKIE = "og_profiler";
+/** Marks the navigation the login page makes right after a successful unlock: if THAT request still
+*  carries no session, the guard explains instead of sending the browser back to the login page. It
+*  carries no secret — only "a login just succeeded". */
+const AFTER_LOGIN_PARAM = "og-after-login";
+/**
+* Every value of the cookie `name` in a raw `Cookie` header, in order — duplicates included (a
+* browser sends two same-named cookies when their paths or domains differ; a parser that keeps one
+* may keep the stale one). Percent-decoded where it decodes; kept raw where it does not, so one
+* malformed neighbour cannot hide the session.
+*/
+function raw_cookie_values(header, name) {
+	const out = [];
+	for (const part of header.split(";")) {
+		const eq = part.indexOf("=");
+		if (eq === -1 || part.slice(0, eq).trim() !== name) continue;
+		let value = part.slice(eq + 1).trim();
+		if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+		try {
+			value = decodeURIComponent(value);
+		} catch {}
+		out.push(value);
+	}
+	return out;
+}
+/** Every candidate session value on a request: Kit's parsed cookie first, then every raw pair. */
+function session_cookie_values(event) {
+	const out = [];
+	const parsed = event.cookies.get(SESSION_COOKIE);
+	if (parsed) out.push(parsed);
+	const raw = event.request.headers.get("cookie");
+	if (raw) {
+		for (const v of raw_cookie_values(raw, SESSION_COOKIE)) if (v && !out.includes(v)) out.push(v);
+	}
+	return out;
+}
+/** The one-line account of a failed session, for the server log and the login page. */
+function describe_cookie_diagnosis(d) {
+	if (!d.header) return "Logged in, but no Cookie header reached the server at all — a proxy or CDN in front of the app is not forwarding cookies to this path.";
+	if (d.pairs === 0) return `Logged in, but your browser’s session cookie didn’t reach the server (Cookie header: ${d.bytes} bytes, no ${SESSION_COOKIE} in it) — a proxy or CDN dropped it, or the browser did not send it.`;
+	if (d.pairs > 1) return `Logged in, but your browser sent ${d.pairs} ${SESSION_COOKIE} cookies (Cookie header: ${d.bytes} bytes) and none is the current session — clear this site’s cookies for the profiler path and log in again.`;
+	return `Logged in, but the ${SESSION_COOKIE} cookie that arrived (Cookie header: ${d.bytes} bytes${d.parsed ? "" : ", not found by the cookie parser"}) is not a valid session — the profiler secret may differ between server instances.`;
+}
+export { AFTER_LOGIN_PARAM, SESSION_COOKIE, describe_cookie_diagnosis, raw_cookie_values, session_cookie_values };

package/dist/profiler/sink.d.ts

@@ -0,0 +1,81 @@
+/**
+ * THE SINK — how an ephemeral host keeps a picture of the whole site. A serverless instance lives
+ * for seconds; nothing it measures survives it. With `sink: { url }` each instance posts what it
+ * saw (one small row per request, one summary per sampler window, a caught request's dump) as
+ * NDJSON to a URL the app owns — an endpoint, a bucket — and the site view reads those rows back in
+ * the browser. Pure here: the rows, the buffer, and the aggregations the site view draws (the
+ * request cloud, the layer cake per route, the hot functions of a brushed selection).
+ */
+export type SinkRow = {
+  k: "req";
+  t: number;
+  path: string;
+  route: string | null;
+  ms: number;
+  cpu: number;
+  wait: number;
+  status: number;
+  og?: number;
+} | {
+  k: "win";
+  t0: number;
+  t1: number;
+  fns: {
+    name: string;
+    file: string;
+    self_ms: number;
+    category: string;
+  }[];
+  reqs?: number;
+} | {
+  k: "trap";
+  t: number;
+  path: string;
+  ms: number;
+  id: string;
+  dump?: unknown;
+};
+export declare class SinkBuffer {
+  #private;
+  readonly max_bytes: number;
+  constructor(max_bytes?: number);
+  push(row: SinkRow): void;
+  get size(): number;
+  /** everything buffered as NDJSON, and the buffer emptied */
+  drain(): string;
+}
+/** NDJSON (one or many posts concatenated) → rows; a bad line is skipped. */
+export declare function parse_sink(text: string): SinkRow[];
+export interface CloudPoint {
+  t: number;
+  ms: number;
+  route: string;
+  path: string;
+  status: number;
+  cpu: number;
+  wait: number;
+}
+export declare function cloud_points(rows: SinkRow[]): CloudPoint[];
+export interface CakeRow {
+  route: string;
+  n: number;
+  /** ms summed over the route's requests */
+  cpu: number;
+  wait: number;
+  rest: number;
+  total: number;
+  p50: number;
+  p95: number;
+}
+/** Where the site's time goes, per route: CPU, waiting on calls, and the rest (the event loop,
+ *  other requests in flight, the platform), summed and sorted by total. */
+export declare function layer_cake(rows: SinkRow[]): CakeRow[];
+/** The hot functions of the sampler windows that overlap [t0, t1] (a brushed selection of the
+ *  cloud), merged by name + file and weighted by how much of each window is inside the range. */
+export declare function hot_for_range(rows: SinkRow[], t0: number, t1: number, limit?: number): {
+  name: string;
+  file: string;
+  category: string;
+  self_ms: number;
+  windows: number;
+}[];

package/dist/profiler/sink.js

@@ -0,0 +1,124 @@
+// src/profiler/sink.ts
+var SinkBuffer = class {
+	#rows = [];
+	#bytes = 0;
+	max_bytes;
+	constructor(max_bytes = 524288) {
+		this.max_bytes = max_bytes;
+	}
+	push(row) {
+		const line = JSON.stringify(row);
+		while (this.#bytes + line.length > this.max_bytes && this.#rows.length) {
+			const i = this.#rows.findIndex((r) => r.k === "req");
+			const [gone] = this.#rows.splice(i === -1 ? 0 : i, 1);
+			this.#bytes -= JSON.stringify(gone).length + 1;
+		}
+		this.#rows.push(row);
+		this.#bytes += line.length + 1;
+	}
+	get size() {
+		return this.#rows.length;
+	}
+	/** everything buffered as NDJSON, and the buffer emptied */
+	drain() {
+		const out = this.#rows.map((r) => JSON.stringify(r)).join("\n");
+		this.#rows = [];
+		this.#bytes = 0;
+		return out;
+	}
+};
+/** NDJSON (one or many posts concatenated) → rows; a bad line is skipped. */
+function parse_sink(text) {
+	const out = [];
+	for (const line of text.split("\n")) {
+		const s = line.trim();
+		if (!s) continue;
+		try {
+			const r = JSON.parse(s);
+			if (r && (r.k === "req" || r.k === "win" || r.k === "trap")) out.push(r);
+		} catch {}
+	}
+	return out;
+}
+function cloud_points(rows) {
+	const out = [];
+	for (const r of rows) if (r.k === "req") out.push({
+		t: r.t,
+		ms: r.ms,
+		route: r.route ?? r.path,
+		path: r.path,
+		status: r.status,
+		cpu: r.cpu,
+		wait: r.wait
+	});
+	return out.sort((a, b) => a.t - b.t);
+}
+/** Where the site's time goes, per route: CPU, waiting on calls, and the rest (the event loop,
+*  other requests in flight, the platform), summed and sorted by total. */
+function layer_cake(rows) {
+	const by = /* @__PURE__ */ new Map();
+	for (const r of rows) {
+		if (r.k !== "req") continue;
+		const key = r.route ?? r.path;
+		let e = by.get(key);
+		if (!e) by.set(key, e = {
+			ms: [],
+			cpu: 0,
+			wait: 0
+		});
+		e.ms.push(r.ms);
+		e.cpu += r.cpu;
+		e.wait += Math.min(r.wait, r.ms);
+	}
+	const pct = (xs, p) => {
+		const s = [...xs].sort((a, b) => a - b);
+		return s[Math.min(s.length - 1, Math.floor(s.length * p))] ?? 0;
+	};
+	return [...by.entries()].map(([route, e]) => {
+		const total = e.ms.reduce((a, b) => a + b, 0);
+		const cpu = Math.min(e.cpu, total);
+		const wait = Math.min(e.wait, total - cpu);
+		return {
+			route,
+			n: e.ms.length,
+			cpu: r1(cpu),
+			wait: r1(wait),
+			rest: r1(total - cpu - wait),
+			total: r1(total),
+			p50: r1(pct(e.ms, .5)),
+			p95: r1(pct(e.ms, .95))
+		};
+	}).sort((a, b) => b.total - a.total);
+}
+const r1 = (n) => Math.round(n * 10) / 10;
+/** The hot functions of the sampler windows that overlap [t0, t1] (a brushed selection of the
+*  cloud), merged by name + file and weighted by how much of each window is inside the range. */
+function hot_for_range(rows, t0, t1, limit = 40) {
+	const by = /* @__PURE__ */ new Map();
+	for (const r of rows) {
+		if (r.k !== "win" || r.t1 < t0 || r.t0 > t1) continue;
+		const span = Math.max(r.t1 - r.t0, 1);
+		const inside = Math.min(r.t1, t1) - Math.max(r.t0, t0);
+		const w = Math.max(0, Math.min(1, inside / span));
+		if (!w) continue;
+		for (const f of r.fns) {
+			const k = `${f.name}|${f.file}`;
+			const e = by.get(k);
+			if (e) {
+				e.self_ms += f.self_ms * w;
+				e.windows++;
+			} else by.set(k, {
+				name: f.name,
+				file: f.file,
+				category: f.category,
+				self_ms: f.self_ms * w,
+				windows: 1
+			});
+		}
+	}
+	return [...by.values()].map((f) => ({
+		...f,
+		self_ms: r1(f.self_ms)
+	})).sort((a, b) => b.self_ms - a.self_ms).slice(0, limit);
+}
+export { SinkBuffer, cloud_points, hot_for_range, layer_cake, parse_sink };

package/dist/profiler/site-fixes.d.ts

@@ -0,0 +1,25 @@
+import { Pattern, PatternKind } from "./patterns.js";
+export interface SiteFix {
+  kind: PatternKind;
+  /** the pattern's title, without its "(N places)" */
+  title: string;
+  /** the line: its source module when the build had no sourcemap, else its file */
+  where: string;
+  line: number;
+  code: string;
+  /** per render on each page it slows, ms (biggest first) */
+  pages: {
+    page: string;
+    ms: number;
+    report: string;
+  }[];
+  /** the sum over those pages, ms per render (one render of each) */
+  total_ms: number;
+}
+export declare function site_fixes(reports: readonly {
+  id: string;
+  page: string;
+  created: number;
+  runs: number;
+  patterns?: readonly Pattern[];
+}[], limit?: number): SiteFix[];