@ogygia/devtools 0.0.0-stage → 0.11.0

package/dist/devtools/testing-engine.js

@@ -0,0 +1,220 @@
+import { read_page, unmeasured } from "./page.js";
+import { hydration_report, hydration_rows } from "./hydration.js";
+import { recording, session_names, set_last_session, start_session } from "./session.js";
+import { region_name_by_fp } from "./regions.js";
+import { ensure_region_names } from "./names.js";
+import { TESTING_ENGINE_VERSION, analyze_session, apply_attr_rules, session_timeline, testing_lean } from "@ogygia/core/insights";
+import { charge, nearest_attr, own_cost } from "@ogygia/core/internal/instruments";
+import { snapshot } from "@ogygia/core/events";
+// src/devtools/testing-engine.ts
+/**
+* What `window.__ogygia_testing` answers (ogygia/playwright calls it through `page.evaluate`). Loaded
+* on the first call, like the dock: plain JSON out (no elements, no WeakRefs), so a test can assert
+* on it and attach it to its report.
+*/
+/** Which engine answered, and whether in lean testing (switch.ts): on every report. */
+const engine = () => ({
+	version: TESTING_ENGINE_VERSION,
+	lean: testing_lean()
+});
+/** The decoded size of the engine's own files: what the page fetched while its import ran (ui.ts). */
+let engine_bytes = 0;
+function note_engine_files(from, to) {
+	for (const r of performance.getEntriesByType("resource")) if (r.startTime >= from && r.startTime <= to && (r.initiatorType === "script" || r.initiatorType === "link" || r.initiatorType === "other")) engine_bytes += r.decodedBodySize || 0;
+}
+/** What ogygia's measuring cost this page, for a test to subtract: the main-thread time of its own work
+*  (checking islands as they hydrate, building the visit, the testing reports — runtime/own-cost.ts)
+*  and the decoded bytes of the testing engine's files. No visitor with devtools off pays either. */
+function self_cost() {
+	const c = own_cost();
+	return {
+		script_ms: c.ms,
+		bytes: engine_bytes,
+		phases: c.phases
+	};
+}
+async function page_json(cpu_fns = 15) {
+	await ensure_region_names();
+	const c0 = performance.now();
+	const v = read_page();
+	charge("report", c0);
+	if (!v) return null;
+	let route = null;
+	try {
+		route = performance.getEntriesByType("navigation")[0]?.serverTiming?.find((s) => s.name === "og-route")?.description || null;
+	} catch {
+		route = null;
+	}
+	return {
+		url: location.pathname,
+		route,
+		nav: v.nav,
+		vitals: v.report.vitals,
+		islands: v.report.rows,
+		findings: v.report.findings.map((f) => ({
+			...f,
+			names: f.fps.map((fp) => region_name_by_fp(fp))
+		})),
+		blocking: v.report.blocking,
+		bytes: v.report.bytes,
+		longtask_ms: v.report.longtask_ms,
+		cpu: v.cpu ? {
+			busy_ms: v.cpu.busy_ms,
+			by_kind: v.cpu.by_kind,
+			fns: v.cpu.fns.slice(0, Math.max(1, Math.min(500, cpu_fns)))
+		} : null,
+		cpu_state: v.page.cpu.state,
+		cpu_off: v.page.cpu.off ?? null,
+		unmeasured: v.unmeasured,
+		self: self_cost(),
+		engine: engine()
+	};
+}
+/** Each island's report, keyed per INSTANCE: the value of `key_attr` on the island or its NEAREST
+*  ancestor that has it, across shadow roots (an id the app renders, e.g. its CMS block's), else
+*  `Name#n`, the n-th island of that name in document order. Two islands under the same keyed
+*  element are told apart as `key`, `key#2`, … in document order. */
+async function hydration_json(key_attr, ignore = []) {
+	await ensure_region_names();
+	const base = hydration_report();
+	const report = {
+		...base,
+		islands: base.islands.map((i) => {
+			if (!i.attributesOnly || !ignore.length || !i.attributes) return i;
+			const { left, ignored } = apply_attr_rules(i.attributes, ignore);
+			if (!ignored.length) return i;
+			return left.length ? {
+				...i,
+				attributes: left,
+				ignored
+			} : {
+				...i,
+				status: "clean",
+				attributesOnly: false,
+				attributes: null,
+				diff: null,
+				ignored
+			};
+		})
+	};
+	const els = new Map(hydration_rows().rows.map((r) => [r.fp, r.el]));
+	const in_order = report.islands.map((i) => ({
+		i,
+		el: els.get(i.fp)
+	})).sort((a, b) => a.el && b.el && a.el.compareDocumentPosition(b.el) & Node.DOCUMENT_POSITION_PRECEDING ? 1 : -1);
+	const keys = /* @__PURE__ */ new Map();
+	const count = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Map();
+	for (const { i, el } of in_order) {
+		const n = (count.get(i.name) ?? 0) + 1;
+		count.set(i.name, n);
+		const own = key_attr && el ? nearest_attr(el, key_attr) : null;
+		if (own) {
+			const k = (used.get(own) ?? 0) + 1;
+			used.set(own, k);
+			keys.set(i.fp, k === 1 ? own : `${own}#${k}`);
+		} else keys.set(i.fp, `${i.name}#${n}`);
+	}
+	return {
+		...report,
+		engine: engine(),
+		islands: report.islands.map((i) => ({
+			...i,
+			key: keys.get(i.fp)
+		}))
+	};
+}
+function record_start() {
+	if (recording()) return false;
+	start_session();
+	return true;
+}
+async function record_stop(blocked = []) {
+	const rec = recording();
+	if (!rec) return null;
+	const data = await rec.stop();
+	await ensure_region_names();
+	const names = session_names(data, (fp) => region_name_by_fp(fp));
+	const report = analyze_session(data, names, location.href);
+	const inputs = [...data.clicks, ...data.interactions].sort((a, b) => a.t - b.t);
+	const seen = [...data.navs ?? []];
+	const navigations = blocked.map((n) => {
+		let best = -1;
+		for (let k = 0; k < seen.length; k++) {
+			if (seen[k].url !== n.url) continue;
+			if (best === -1 || n.t !== null && Math.abs(seen[k].t - n.t) < Math.abs(seen[best].t - n.t)) best = k;
+		}
+		if (best !== -1) {
+			const [nav] = seen.splice(best, 1);
+			return {
+				url: n.url,
+				t: nav.t,
+				after: nav.source,
+				island: nav.fp ? names(nav.fp) : null,
+				approx: false
+			};
+		}
+		const before = n.t === null ? void 0 : inputs.filter((x) => x.t <= n.t).at(-1);
+		return {
+			url: n.url,
+			t: n.t,
+			after: before?.target ?? null,
+			island: before?.fp ? names(before.fp) : null,
+			approx: true
+		};
+	});
+	for (const n of navigations) report.findings.push({
+		code: "navigation-blocked",
+		severity: "warn",
+		message: `The page tried to load another document (${n.url})${n.after ? ` after ${n.after}${n.island ? ` in ${n.island}` : ""}` : ""}; it was blocked, so the recording kept going.`,
+		fix: "If that input should keep the page, find what navigates: a link, a form, or a reload in a handler.",
+		refs: []
+	});
+	set_last_session({
+		data,
+		report
+	});
+	window.__ogygia_session = report;
+	const fp_of = (ref) => ref.kind === "island" ? ref.fp : (ref.kind === "interaction" ? data.interactions : ref.kind === "click" ? data.clicks : data.shifts)[ref.i]?.fp ?? null;
+	let nav_i = 0;
+	return {
+		...report,
+		findings: report.findings.map((f) => {
+			const named = f.refs.map(fp_of).filter((fp) => !!fp).map(names);
+			if (f.code === "navigation-blocked") {
+				const island = navigations[nav_i++]?.island;
+				if (island) named.push(island);
+			}
+			return {
+				...f,
+				names: [...new Set(named)]
+			};
+		}),
+		navigations,
+		engine: engine(),
+		timeline: session_timeline(data, names).map((l) => ({
+			...l,
+			items: l.items.map(({ ref: _ref, ...it }) => it)
+		})),
+		unmeasured: unmeasured(data.cpu_off)
+	};
+}
+/** Resolves when no island is mid-hydration and nothing woke for `quiet` ms (or `timeout` passed). */
+async function settled(quiet = 300, timeout = 1e4) {
+	const until = performance.now() + timeout;
+	for (;;) {
+		const ev = snapshot();
+		const started = /* @__PURE__ */ new Set();
+		let last = 0;
+		for (const e of ev) {
+			if (e.realm !== "client") continue;
+			if (e.name === "region.hydrate.start" && e.fp) started.add(e.fp);
+			if ((e.name === "region.hydrate.done" || e.name === "region.hydrate.failed") && e.fp) started.delete(e.fp);
+			if (e.name === "region.hydrate.start" || e.name === "region.hydrate.done" || e.name === "wake.fired") last = Math.max(last, e.t);
+		}
+		if (!started.size && performance.now() - last >= quiet && document.readyState === "complete") return true;
+		if (performance.now() > until) return false;
+		await new Promise((r) => setTimeout(r, 50));
+	}
+}
+export { hydration_json, note_engine_files, page_json, record_start, record_stop, settled };

package/dist/devtools/ui-app.d.ts

@@ -0,0 +1,5 @@
+export declare function mount_app(root: ShadowRoot, opts: {
+  csr_true: boolean;
+  start_open: boolean;
+  hide?: () => void;
+}): void;

package/dist/devtools/ui-app.js

@@ -0,0 +1,69 @@
+import { install_page_hook } from "./page.js";
+import { set_highlight_root } from "./highlight.js";
+import { names } from "virtual:ogygia/devtools-meta";
+import { mount } from "svelte";
+import Devtools from "./Devtools.svelte";
+// src/devtools/ui-app.ts
+/**
+* The devtools DOCK — one `mount()` of the {@link ./Devtools.svelte root app} into the shadow root
+* the launcher (ui.ts) made. Its own module so a build with devtools (`devtools: 'always'`) ships
+* only the launcher in the runtime chunk: this file, the components and their CSS load when someone
+* opens the dock (a dynamic import the bundler splits off). On the dev server it loads at once.
+*/
+function mount_app(root, opts) {
+	install_page_hook();
+	set_highlight_root(root);
+	if (names && Object.keys(names).length && typeof window !== "undefined") window.__ogygia_region_names = {
+		...names,
+		...window.__ogygia_region_names
+	};
+	mount(Devtools, {
+		target: root,
+		props: {
+			csrTrue: opts.csr_true,
+			startOpen: opts.start_open,
+			hide: opts.hide
+		}
+	});
+	adopt_scoped_styles(root);
+	const mo = new MutationObserver(() => adopt_scoped_styles(root));
+	mo.observe(document.head, { childList: true });
+	mo.observe(root, {
+		childList: true,
+		subtree: true
+	});
+}
+/** the dock's `<style>`s a page's Content-Security-Policy refused, already re-made as sheets */
+const remade = /* @__PURE__ */ new WeakSet();
+/** A page whose Content-Security-Policy has no `'unsafe-inline'` for styles refuses every `<style>`
+*  element — the dock's own among them (the element stays, with its text, but no sheet). A sheet made
+*  through the CSSOM is not an inline style: the same text, adopted into the shadow root, applies. */
+function remake_refused_styles(root) {
+	if (typeof CSSStyleSheet === "undefined" || !("adoptedStyleSheets" in root)) return;
+	const add = [];
+	for (const style of root.querySelectorAll("style")) {
+		if (style.sheet || remade.has(style) || !style.textContent) continue;
+		remade.add(style);
+		try {
+			const sheet = new CSSStyleSheet();
+			sheet.replaceSync(style.textContent);
+			add.push(sheet);
+		} catch {}
+	}
+	if (add.length) root.adoptedStyleSheets = [...root.adoptedStyleSheets, ...add];
+}
+function adopt_scoped_styles(root) {
+	remake_refused_styles(root);
+	const hashes = /* @__PURE__ */ new Set();
+	for (const el of root.querySelectorAll("[class*=\"svelte-\"]")) for (const c of el.classList) if (c.startsWith("svelte-")) hashes.add(c);
+	if (hashes.size === 0) return;
+	for (const style of document.querySelectorAll("style")) {
+		if (style.getRootNode() === root) continue;
+		const css = style.textContent || "";
+		for (const h of hashes) if (css.includes(h)) {
+			root.appendChild(style);
+			break;
+		}
+	}
+}
+export { mount_app };

package/dist/devtools/ui.d.ts

@@ -0,0 +1,50 @@
+export declare function install_devtools_ui(opts?: {
+  csr_true?: boolean;
+}): void;
+/**
+ * `window.__ogygia_testing` — what ogygia/playwright drives through `page.evaluate`: the page report,
+ * each island's hydration, a recorded session, "settled". Tiny here: each call loads the engine
+ * (testing-engine.ts) on first use, like the dock. Version-stamped so the fixture can refuse a
+ * mismatch.
+ */
+export interface OgygiaTestingApi {
+  /** the report shape (testing-version.ts) */
+  version: number;
+  /** `cpu_fns`: how many of the page load's hottest functions (default 15) */
+  page(cpu_fns?: number): Promise<unknown>;
+  /** `key_attr`: the attribute that names an island instance; `ignore`: attribute changes to leave out
+   *  (see testing-engine.ts) */
+  hydration(key_attr?: string, ignore?: unknown[]): Promise<unknown>;
+  record_start(): Promise<boolean>;
+  /** `blocked`: the navigations the test's driver held back during the recording */
+  record_stop(blocked?: {
+    url: string;
+    t: number | null;
+  }[]): Promise<unknown>;
+  settled(quiet?: number, timeout?: number): Promise<boolean>;
+}
+declare global {
+  interface Window {
+    __ogygia_testing?: OgygiaTestingApi;
+  }
+}
+/** Turn devtools on in this browser, now: the launcher shows (measuring starts with the next load). */
+export declare function devtools_on(): void;
+/** Turn devtools off in this browser, now: the launcher and the dock go, and nothing is measured from
+ *  the next load on. */
+export declare function devtools_off(): void;
+/**
+ * `ogygia.devtools.on()` / `.off()` in the console (and `.status()`). On the dev server devtools is
+ * always on, and they say so.
+ */
+declare global {
+  interface Window {
+    ogygia?: {
+      devtools?: {
+        on(): string;
+        off(): string;
+        status(): string;
+      };
+    };
+  }
+}

package/dist/devtools/ui.js

@@ -0,0 +1,175 @@
+import { TESTING_ENGINE_VERSION, devtools_switched_on, switch_in_url, testing_lean, without_switch, write_switch } from "@ogygia/core/insights";
+// src/devtools/ui.ts
+/**
+* The devtools LAUNCHER — the only part of devtools the runtime chunk carries. Called from the runtime
+* boot on a devtools build (behind the `__OGYGIA_DEVTOOLS__` gate: off, all of it tree-shakes away).
+* It makes the shadow host and, in a build, one small plain-DOM button: the dock itself (ui-app.ts,
+* Svelte, every tab, their CSS) loads when someone opens it — a dynamic import the bundler splits
+* off. In a build even the button waits for the browser's DEVTOOLS SWITCH (switch.ts: `?og-devtools=on`,
+* `ogygia.devtools.on()`): a QA or preview deploy's visitors see nothing and pay nothing. On the dev
+* server the button is always there and the dock loads at once.
+*
+* The panel mounts on the LIVE page (not an iframe), so its host element carries a **shadow root** for
+* total CSS isolation: host-page globals can't reach in (a stray `.spacer { height: 140vh }` once
+* ballooned the header) and the devtools' own styles can't leak out. The host is attached to
+* `<html>` (not `<body>`) so a full-body SPA swap never tears the panel out.
+*
+* The switch's cookie also starts the rest, for that browser only: the server writes its event
+* side-channel and the page is measured from the start (runtime/beacon.ts).
+*/
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+const LAZY = typeof __OGYGIA_DEVTOOLS_LAZY__ !== "undefined" ? __OGYGIA_DEVTOOLS_LAZY__ : false;
+const LAYOUT_KEY = "ogygia:devtools:layout:v4";
+let mounted = false;
+let launch_opts;
+function install_devtools_ui(opts) {
+	if (!DEVTOOLS || typeof document === "undefined" || mounted) return;
+	if (document.querySelector("meta[name=\"ogygia-devtools\"][content=\"off\"]")) return;
+	launch_opts = opts;
+	install_testing_api();
+	install_console_api();
+	if (LAZY) {
+		apply_url_switch();
+		if (!devtools_switched_on()) return;
+	}
+	if (testing_lean()) return;
+	mount_launcher(opts);
+}
+/** The launcher (and, on the dev server or for a dock left open, the dock). */
+function mount_launcher(opts) {
+	if (mounted || document.querySelector("[data-ogygia-devtools-host]")) return;
+	mounted = true;
+	try {
+		if (sessionStorage.getItem("ogygia:devtools:session")) import("./session.js").then((m) => m.resume_session_if_any());
+	} catch {}
+	const host = document.createElement("div");
+	host.setAttribute("data-ogygia-devtools-host", "");
+	host.style.cssText = "position:fixed;top:0;left:0;width:0;height:0;z-index:2147483647";
+	document.documentElement.appendChild(host);
+	const root = host.attachShadow({ mode: "open" });
+	const csr_true = opts?.csr_true ?? false;
+	let loading = false;
+	let want_open = false;
+	let button = null;
+	let on_key = null;
+	const load = () => {
+		if (loading) return;
+		loading = true;
+		import("./ui-app.js").then((m) => {
+			button?.remove();
+			if (on_key) removeEventListener("keydown", on_key);
+			m.mount_app(root, {
+				csr_true,
+				start_open: want_open,
+				...LAZY ? { hide: devtools_off } : {}
+			});
+		});
+	};
+	button = document.createElement("button");
+	button.setAttribute("data-og-panel-toggle", "");
+	button.title = "ogygia devtools (Alt+O)";
+	button.textContent = "og devtools";
+	button.style.cssText = "position:fixed;right:24px;bottom:8px;padding:7px 12px;border-radius:999px;border:1px solid rgba(148,163,184,.35);background:#0b1220;color:#e2e8f0;font:600 12px/1 ui-monospace,SFMono-Regular,Menlo,monospace;cursor:pointer;opacity:.55;box-shadow:0 4px 16px rgba(0,0,0,.4)";
+	const b = button;
+	b.onmouseenter = () => b.style.opacity = "1";
+	b.onmouseleave = () => b.style.opacity = ".55";
+	const open = () => {
+		want_open = true;
+		b.textContent = "loading…";
+		load();
+	};
+	b.onclick = open;
+	on_key = (e) => {
+		if (e.altKey && (e.key === "o" || e.key === "O")) {
+			e.preventDefault();
+			open();
+		}
+	};
+	addEventListener("keydown", on_key);
+	root.appendChild(b);
+	if (was_open()) load();
+	else if (!LAZY) after_load_idle(load);
+}
+function after_load_idle(fn) {
+	const idle = () => {
+		const ric = globalThis.requestIdleCallback;
+		if (ric) ric(fn, { timeout: 3e3 });
+		else setTimeout(fn, 1e3);
+	};
+	if (document.readyState === "complete") setTimeout(idle, 500);
+	else addEventListener("load", () => setTimeout(idle, 500), { once: true });
+}
+function install_testing_api() {
+	if (window.__ogygia_testing) return;
+	let loading = null;
+	const engine = () => loading ??= (async () => {
+		const from = performance.now();
+		const m = await import("./testing-engine.js");
+		m.note_engine_files(from, performance.now());
+		return m;
+	})();
+	window.__ogygia_testing = {
+		version: TESTING_ENGINE_VERSION,
+		page: async (cpu_fns) => (await engine()).page_json(cpu_fns),
+		hydration: async (key_attr, ignore) => (await engine()).hydration_json(key_attr, ignore),
+		record_start: async () => (await engine()).record_start(),
+		record_stop: async (blocked) => (await engine()).record_stop(blocked),
+		settled: async (quiet, timeout) => (await engine()).settled(quiet, timeout)
+	};
+}
+/** Has this browser opened the dock before (from then on the page is measured from the start). */
+/** `?og-devtools=on|off` on this page: flip the switch and drop the param from the address. */
+function apply_url_switch() {
+	try {
+		const url = new URL(location.href);
+		const want = switch_in_url(url);
+		if (want === null) return;
+		write_switch(want);
+		history.replaceState(history.state, "", without_switch(url).href);
+	} catch {}
+}
+/** Turn devtools on in this browser, now: the launcher shows (measuring starts with the next load). */
+function devtools_on() {
+	if (!LAZY) return;
+	write_switch(true);
+	mount_launcher(launch_opts);
+}
+/** Turn devtools off in this browser, now: the launcher and the dock go, and nothing is measured from
+*  the next load on. */
+function devtools_off() {
+	if (!LAZY) return;
+	write_switch(false);
+	try {
+		localStorage.removeItem(LAYOUT_KEY);
+	} catch {}
+	document.querySelector("[data-ogygia-devtools-host]")?.remove();
+	mounted = false;
+}
+function install_console_api() {
+	const say = (on) => on ? "ogygia devtools: on in this browser (stays on; ogygia.devtools.off() to hide it)" : "ogygia devtools: off in this browser";
+	const g = window.ogygia ??= {};
+	if (g.devtools) return;
+	g.devtools = {
+		on() {
+			if (!LAZY) return "ogygia devtools: always on on the dev server";
+			devtools_on();
+			return say(true);
+		},
+		off() {
+			if (!LAZY) return "ogygia devtools: always on on the dev server";
+			devtools_off();
+			return say(false);
+		},
+		status() {
+			return !LAZY ? "ogygia devtools: always on on the dev server" : say(devtools_switched_on());
+		}
+	};
+}
+function was_open() {
+	try {
+		return !!JSON.parse(localStorage.getItem(LAYOUT_KEY) || "{}")?.open;
+	} catch {
+		return false;
+	}
+}
+export { devtools_off, devtools_on, install_devtools_ui };

package/dist/profiler/alloc.d.ts

@@ -0,0 +1,75 @@
+/**
+ * ALLOCATION ON THE TIMELINE — the heap's size sampled finely while the recording ran, turned
+ * into bursts: the stretches where the heap grew fastest, each joined to what the CPU was
+ * running at that moment. The makers table (gc.ts) says WHO allocated over the whole window;
+ * this says WHEN, and what ran when it happened. Pure: the host supplies the samples (on the
+ * capture's clock, ms from the profiler's start), the CPU segments on the same clock, and the
+ * GC pauses (a pause inside an interval shrinks the heap, so that interval's growth is a floor,
+ * not the allocation).
+ *
+ * The samples come from a timer: a synchronous stretch cannot be sampled while it runs, so an
+ * interval is at least one yield of the event loop long — "between two awaits", never inside one.
+ */
+export interface HeapSample {
+  /** ms on the capture's clock */
+  t: number;
+  /** used heap, MB */
+  mb: number;
+}
+export interface AllocBurst {
+  t0: number;
+  t1: number;
+  /** MB the heap grew across the interval (a floor when `gc` is set) */
+  mb: number;
+  /** MB per second over the interval */
+  rate: number;
+  /** what the CPU was running across the interval, by share of its CPU time */
+  running: {
+    label: string;
+    category: string;
+    file?: string;
+    share: number;
+  }[];
+  /** a GC pause fell inside the interval: the growth is what survived it, the allocation was more */
+  gc: boolean;
+}
+export interface AllocTimeline {
+  /** the samples on the capture's clock (kept for the chart) */
+  samples: HeapSample[];
+  /** the fastest-growing intervals, rate desc */
+  bursts: AllocBurst[];
+  /** MB the heap grew over every interval that grew (what the render put on the heap between
+   *  collections; the GC attribution's allocated bytes are the same thing measured by sampling) */
+  grown_mb: number;
+  /** ms between samples as recorded (the timer's period; longer where the loop was blocked) */
+  period_ms: number;
+  /** the longest gap between two samples: the longest synchronous stretch the loop saw */
+  longest_gap_ms: number;
+  /** the one window the report explains, on the same clock */
+  window?: {
+    offset_ms: number;
+    ms: number;
+  };
+}
+export interface AllocInput {
+  samples: HeapSample[];
+  /** CPU segments on the capture's clock */
+  running?: {
+    t0: number;
+    t1: number;
+    label: string;
+    category: string;
+    file?: string;
+  }[];
+  /** GC pauses on the capture's clock */
+  gc?: {
+    t: number;
+    ms: number;
+  }[];
+  window?: {
+    offset_ms: number;
+    ms: number;
+  };
+  limit?: number;
+}
+export declare function alloc_timeline(input: AllocInput): AllocTimeline | undefined;

package/dist/profiler/alloc.js

@@ -0,0 +1,76 @@
+// src/profiler/alloc.ts
+const round1 = (n) => Math.round(n * 10) / 10;
+const round2 = (n) => Math.round(n * 100) / 100;
+function alloc_timeline(input) {
+	const s = input.samples;
+	if (s.length < 3) return void 0;
+	const running = input.running ?? [];
+	const gc = input.gc ?? [];
+	let ri = 0;
+	let gi = 0;
+	let grown = 0;
+	let longest = 0;
+	let period_sum = 0;
+	const raw = [];
+	for (let i = 1; i < s.length; i++) {
+		const t0 = s[i - 1].t;
+		const t1 = s[i].t;
+		const len = t1 - t0;
+		if (len <= 0) continue;
+		period_sum += len;
+		if (len > longest) longest = len;
+		const mb = s[i].mb - s[i - 1].mb;
+		while (gi < gc.length && gc[gi].t + gc[gi].ms < t0) gi++;
+		let had_gc = false;
+		for (let g = gi; g < gc.length && gc[g].t <= t1; g++) had_gc = true;
+		if (mb <= 0) continue;
+		grown += mb;
+		while (ri < running.length && running[ri].t1 < t0) ri++;
+		const by = /* @__PURE__ */ new Map();
+		let cpu = 0;
+		for (let r = ri; r < running.length && running[r].t0 <= t1; r++) {
+			const seg = running[r];
+			const ov = Math.min(seg.t1, t1) - Math.max(seg.t0, t0);
+			if (ov <= 0) continue;
+			cpu += ov;
+			const k = seg.label + "\0" + (seg.file ?? "");
+			const hit = by.get(k);
+			if (hit) hit.ms += ov;
+			else by.set(k, {
+				label: seg.label,
+				category: seg.category,
+				...seg.file ? { file: seg.file } : {},
+				ms: ov
+			});
+		}
+		const top = [...by.values()].sort((a, b) => b.ms - a.ms).slice(0, 4);
+		raw.push({
+			t0: round2(t0),
+			t1: round2(t1),
+			mb: round1(mb),
+			rate: round1(mb / len * 1e3),
+			running: top.map((x) => ({
+				label: x.label,
+				category: x.category,
+				...x.file ? { file: x.file } : {},
+				share: cpu > 0 ? round2(x.ms / cpu) : 0
+			})),
+			gc: had_gc
+		});
+	}
+	const limit = input.limit ?? 12;
+	const floor = Math.max(.5, grown * .02);
+	const bursts = raw.filter((b) => b.mb >= floor).sort((a, b) => b.rate - a.rate).slice(0, limit);
+	return {
+		samples: s.map((x) => ({
+			t: round2(x.t),
+			mb: round1(x.mb)
+		})),
+		bursts,
+		grown_mb: round1(grown),
+		period_ms: round1(period_sum / Math.max(1, s.length - 1)),
+		longest_gap_ms: round1(longest),
+		...input.window ? { window: input.window } : {}
+	};
+}
+export { alloc_timeline };