@ogygia/devtools 0.0.0 → 0.11.0

package/dist/profiler/app-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AN APP FILE, NAMED FROM THE APP'S FOLDER: `src/lib/x.ts` and `src/routes/a/b/c/+page.svelte`
+ * alike, whatever the depth (a cut to the last few segments named one app's files four different
+ * ways). Undefined outside the app's folder, and for the build's output (its chunks read by their
+ * own short form).
+ */
+export declare function app_relative(path: string): string | undefined;

package/dist/profiler/app-path.js

@@ -0,0 +1,26 @@
+// src/profiler/app-path.ts
+/** the app's folder (the server's working directory, with a trailing slash), read once */
+let app_root;
+function root_of_app() {
+	if (app_root === void 0) try {
+		const cwd = globalThis.process?.cwd?.();
+		app_root = cwd ? cwd.split("\\").join("/") : null;
+		if (app_root && !app_root.endsWith("/")) app_root += "/";
+	} catch {
+		app_root = null;
+	}
+	return app_root;
+}
+/**
+* AN APP FILE, NAMED FROM THE APP'S FOLDER: `src/lib/x.ts` and `src/routes/a/b/c/+page.svelte`
+* alike, whatever the depth (a cut to the last few segments named one app's files four different
+* ways). Undefined outside the app's folder, and for the build's output (its chunks read by their
+* own short form).
+*/
+function app_relative(path) {
+	const root = root_of_app();
+	if (!root || !path.startsWith(root)) return void 0;
+	const rel = path.slice(root.length);
+	return rel.startsWith(".svelte-kit") || rel.startsWith("node_modules/") ? void 0 : rel;
+}
+export { app_relative };

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

@@ -0,0 +1,58 @@
+import { CallerSite } from "./net.js";
+export interface IoOp {
+  /** async resource type: Timeout, FSREQCALLBACK, GETADDRINFOREQWRAP, TCPWRAP, … */
+  type: string;
+  /** resolved caller, filled in at report time */
+  caller?: string;
+  /** raw caller location (bundled), resolved to source at report time */
+  caller_site?: CallerSite;
+  /** the caller's source position, for reading the call site's code */
+  caller_at?: {
+    path: string;
+    line: number;
+  };
+  /** init → destroy duration in ms — the time the code waited on this resource */
+  ms: number;
+  /** performance.now() at init — lets page mode window ops to a single representative render */
+  start: number;
+  /** still open when the window ended (long-lived socket, watcher) */
+  open?: boolean;
+  /** a timer's period, when it repeats (`setInterval`), else its delay (ms) */
+  repeat?: number;
+  delay?: number;
+  /** an open timer that does not hold the process (`.unref()`; Node's own `AbortSignal.timeout`) */
+  unref?: true;
+  /** page mode: every render left one of these open, from the same line (index.ts reads it
+   *  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[];
+  /** promises created while the recorder ran, and who created them (one stack per
+   *  PROMISE_SAMPLE_EVERY promises — a counter otherwise) */
+  promises(): {
+    count: number;
+    top: {
+      caller: string;
+      share: number;
+      site?: CallerSite;
+    }[];
+  };
+}
+/** `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
+ * per render (a cache's single refresh timer, started on the first request, is one in all). Marked
+ * on the ops themselves (`left_each_run`), so the run kept for the waterfall carries it.
+ */
+export declare function mark_left_each_run(ops: IoOp[], windows: Array<{
+  start: number;
+  end: number;
+}>): void;
+/** A friendly bucket for a resource type, for the report. */
+export declare function io_kind(type: string): "timer" | "file" | "dns" | "socket" | "zlib" | "other";

package/dist/profiler/async-io.js

@@ -0,0 +1,187 @@
+import { nearest_app_site } from "./net.js";
+import { call_sites, file_of, is_profiler_file, register_profiler_file } from "./frames.js";
+// src/profiler/async-io.ts
+/**
+* The general I/O-wait tracker (Tier 3).
+*
+* The CPU sampler can't see waiting, and the fetch/http patch only covers HTTP.
+* This uses `async_hooks` to time the underlying I/O *primitives* — timers,
+* file reads, DNS lookups, raw sockets — and blames the app function that
+* started each one, with no wrapping of anyone's code. That is how we attribute
+* a slow `load`'s database or `setTimeout` wait to a function even though it
+* never appears on the CPU stack.
+*
+* Enabled ONLY during a recording (a stack is captured per tracked resource).
+* HTTP/TLS resources are deliberately skipped — the fetch/http patch already
+* reports those with URL + status, and undici keep-alive would inflate socket
+* lifetimes here anyway.
+*/
+register_profiler_file();
+const TRACK = /* @__PURE__ */ new Set([
+	"Timeout",
+	"Immediate",
+	"TickObject",
+	"FSREQCALLBACK",
+	"FSREQPROMISE",
+	"STATWATCHER",
+	"FSEVENTWRAP",
+	"GETADDRINFOREQWRAP",
+	"GETNAMEINFOREQWRAP",
+	"QUERYWRAP",
+	"TCPWRAP",
+	"TCPCONNECTWRAP",
+	"PIPEWRAP",
+	"PIPECONNECTWRAP",
+	"UDPWRAP",
+	"ZLIB"
+]);
+const MAX = 2e4;
+/** a promise storm is counted, not stacked: one stack capture per this many promises */
+const PROMISE_SAMPLE_EVERY = 256;
+/** the nearest frame that belongs to the app OR a dependency (not Node, not the profiler): its
+*  generated position in full, so the report can map it back to the source (a short `dir/file`
+*  of a built chunk named `_page.server.ts.js`, which is no line anyone can open) — no regex,
+*  this runs once per sampled promise */
+function nearest_own_or_dep_site() {
+	for (const site of call_sites(nearest_own_or_dep_site)) {
+		const file = file_of(site);
+		if (!file || file.startsWith("node:") || file.includes("node:internal") || is_profiler_file(file)) continue;
+		return {
+			fn: site.getFunctionName() || "(anonymous)",
+			file,
+			line: site.getLineNumber() ?? 0,
+			column: site.getColumnNumber() ?? 0
+		};
+	}
+}
+/** `fn (dir/file:line)` from a generated position: what a promise origin reads as when no
+*  sourcemap maps it */
+function short_site(s) {
+	const q = s.file.indexOf("?");
+	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;
+	/** 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;
+			}
+			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
+			});
+		}
+	});
+	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;
+		}
+	};
+}
+/**
+* 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
+* per render (a cache's single refresh timer, started on the first request, is one in all). Marked
+* on the ops themselves (`left_each_run`), so the run kept for the waterfall carries it.
+*/
+function mark_left_each_run(ops, windows) {
+	if (windows.length < 2) return;
+	const by_site = /* @__PURE__ */ new Map();
+	for (const o of ops) {
+		if (!o.open || o.type !== "Timeout" || !o.caller_site) continue;
+		if (o.repeat === void 0 && ((o.delay ?? 0) < 1e3 || o.unref)) continue;
+		const ri = windows.findIndex((w) => o.start >= w.start && o.start <= w.end);
+		if (ri === -1) continue;
+		const s = o.caller_site;
+		const k = s.file + "\0" + s.line + "\0" + s.column;
+		const g = by_site.get(k) ?? {
+			runs: /* @__PURE__ */ new Set(),
+			ops: []
+		};
+		g.runs.add(ri);
+		g.ops.push(o);
+		by_site.set(k, g);
+	}
+	for (const g of by_site.values()) if (g.runs.size === windows.length) for (const o of g.ops) o.left_each_run = true;
+}
+/** A friendly bucket for a resource type, for the report. */
+function io_kind(type) {
+	if (type === "Timeout" || type === "Immediate") return "timer";
+	if (type.startsWith("FS") || type === "STATWATCHER") return "file";
+	if (type.startsWith("GETADDR") || type.startsWith("GETNAME") || type === "QUERYWRAP") return "dns";
+	if (type.includes("TCP") || type.includes("PIPE") || type === "UDPWRAP") return "socket";
+	if (type === "ZLIB") return "zlib";
+	return "other";
+}
+function round2(n) {
+	return Math.round(n * 100) / 100;
+}
+export { io_kind, mark_left_each_run, record_async_io, short_site };

package/dist/profiler/beacon-standalone.d.ts

@@ -0,0 +1,4 @@
+/** The beacon itself. Runs in the browser, as an inline classic script. */
+export declare function standalone_beacon(): void;
+/** The inline tag the profiler puts in its own user's document, beside the beacon meta tag. */
+export declare const BEACON_STANDALONE_TAG: string;

package/dist/profiler/beacon-standalone.js

@@ -0,0 +1,409 @@
+import { script } from "@ogygia/core";
+// src/profiler/beacon-standalone.ts
+/**
+* THE BEACON FOR A PAGE WITHOUT THE OGYGIA RUNTIME — a Kit-hydrated (`csr = true`) page, or any
+* page with no island. The runtime's beacon (runtime/beacon.ts) lives in the runtime, so without
+* this such a page would never report its vitals, long tasks or CPU — and the page score would
+* measure it on less than an islands page (the unfairness the score rework removed).
+*
+* An inline script the profiler adds for ITS OWN user only (next to the beacon meta tag; never a
+* visitor), made with ogygia's own `script()`: `standalone_beacon` is inlined through
+* `Function.prototype.toString`, so it is SELF-CONTAINED — browser globals only, every helper inside
+* it. It steps aside at once when the ogygia runtime's script is already in the head (the usual
+* order), else watches and checks again at DOMContentLoaded. It must never hold the JS sampler the
+* runtime's beacon needs: the browser runs one at a time. Same payloads as the runtime's:
+* `{page, vitals}`, `{page, visit}` (no islands), `{page, cpu}`. No regex. Like the runtime's, a later
+* largest paint, a shift or a worse interaction re-sends the visit (debounced, at most 8 times): the
+* hide-time message is the one most often lost.
+*/
+/** The beacon itself. Runs in the browser, as an inline classic script. */
+function standalone_beacon() {
+	const w = window;
+	if (w.__og_beacon_standalone) return;
+	w.__og_beacon_standalone = 1;
+	const url = document.querySelector("meta[name=\"ogygia-profiler-beacon\"]")?.getAttribute("content");
+	if (!url || typeof PerformanceObserver === "undefined") return;
+	if (document.querySelector("script[data-ogygia-runtime]")) return;
+	const r2 = (n) => Math.round(n * 100) / 100;
+	const vitals = {};
+	const paints = {};
+	const shifts = [];
+	const longtasks = [];
+	const observers = [];
+	/** every resource entry (the observer sees past the browser's buffer) */
+	const seen = [];
+	let off = false;
+	let cls = 0;
+	let sent = false;
+	let resend;
+	/** visits sent while the page lives (the early one, then re-sends): at most 8 */
+	let early_sends = 0;
+	let profiler = null;
+	const watch = (type, on) => {
+		try {
+			const po = new PerformanceObserver((list) => {
+				if (!off) on(list.getEntries());
+			});
+			po.observe(type === "event" ? {
+				type,
+				buffered: true,
+				durationThreshold: 16
+			} : {
+				type,
+				buffered: true
+			});
+			observers.push(po);
+		} catch {}
+	};
+	try {
+		const nav = performance.getEntriesByType("navigation")[0];
+		if (nav && nav.responseStart > 0) vitals.ttfb = r2(nav.responseStart);
+	} catch {}
+	watch("paint", (es) => {
+		for (const e of es) if (e.name === "first-contentful-paint") vitals.fcp = paints.fcp = r2(e.startTime);
+	});
+	watch("largest-contentful-paint", (es) => {
+		const e = es[es.length - 1];
+		if (!e) return;
+		vitals.lcp = paints.lcp = r2(e.startTime);
+		paints.lcp_url = e.url || void 0;
+		paints.lcp_tag = e.element?.tagName ? e.element.tagName.toLowerCase() : void 0;
+		paints.lcp_lazy = e.element?.getAttribute?.("loading") === "lazy" ? true : void 0;
+		again();
+	});
+	try {
+		if (PerformanceObserver.supportedEntryTypes?.includes("layout-shift")) vitals.cls = 0;
+	} catch {}
+	watch("layout-shift", (es) => {
+		for (const e of es) {
+			if (e.hadRecentInput || typeof e.value !== "number") continue;
+			cls += e.value;
+			if (shifts.length < 60) shifts.push({
+				t: r2(e.startTime),
+				value: Math.round(e.value * 1e4) / 1e4
+			});
+		}
+		vitals.cls = Math.round(cls * 1e3) / 1e3;
+		again();
+	});
+	watch("event", (es) => {
+		for (const e of es) {
+			if (!e.interactionId) continue;
+			const d = r2(e.duration);
+			if (vitals.inp === void 0 || d > vitals.inp) {
+				vitals.inp = d;
+				clearTimeout(resend);
+				resend = setTimeout(early, 1500);
+			}
+		}
+	});
+	try {
+		performance.setResourceTimingBufferSize(3e3);
+	} catch {}
+	watch("resource", (es) => {
+		for (const e of es) if (seen.length < 3e3) seen.push(e);
+	});
+	watch("longtask", (es) => {
+		for (const e of es) if (longtasks.length < 100) longtasks.push({
+			t: r2(e.startTime),
+			ms: r2(e.duration)
+		});
+	});
+	try {
+		if (w.Profiler) {
+			profiler = new w.Profiler({
+				sampleInterval: 10,
+				maxBufferSize: 3e4
+			});
+			setTimeout(() => cpu(false), 8e3);
+		}
+	} catch {
+		profiler = null;
+	}
+	/** keepalive bytes still queued: the 64 KB cap is shared by every beacon and keepalive fetch the
+	*  page has queued at once (a hide sends several), not each's — held until a fetch settles, a
+	*  beacon (which says nothing back) for the task that sent it: the hide's burst is what overflows */
+	let queued = 0;
+	function hold(bytes, settled) {
+		queued += bytes;
+		const release = () => queued = Math.max(0, queued - bytes);
+		if (settled) settled.finally(release);
+		else setTimeout(release, 0);
+	}
+	function post(body, keepalive) {
+		try {
+			const settled = fetch(url, {
+				method: "POST",
+				body,
+				keepalive,
+				credentials: "same-origin",
+				headers: { "content-type": "text/plain" }
+			}).catch(() => {});
+			if (keepalive) hold(body.length, settled);
+		} catch {}
+	}
+	/** a beacon when it fits (what is left of the 64 KB the queued requests share); a big body as a
+	*  plain POST while the page lives, else its slim form (`slim`), else nothing */
+	function send(body, slim) {
+		const room = 6e4 - queued;
+		if (body.length > room) {
+			if (!sent && document.visibilityState === "visible") return post(body, false);
+			const smaller = slim?.();
+			if (!smaller || smaller.length > room) return;
+			body = smaller;
+		}
+		try {
+			if (navigator.sendBeacon?.(url, body)) return hold(body.length);
+		} catch {}
+		post(body, true);
+	}
+	/** a URL's extension, lowercased (`''` for none), with no regex */
+	function ext(name) {
+		const q = name.indexOf("?");
+		const path = q < 0 ? name : name.slice(0, q);
+		const dot = path.lastIndexOf(".");
+		return dot > path.lastIndexOf("/") ? path.slice(dot + 1).toLowerCase() : "";
+	}
+	/** what each <link> fetched as (a preload's `as`, a modulepreload's script), and its crossorigin;
+	*  read once per visit */
+	let link_as = null;
+	let link_co = {};
+	function links() {
+		if (link_as) return link_as;
+		link_as = {};
+		link_co = {};
+		try {
+			for (const l of document.querySelectorAll("link[href][as],link[rel=\"modulepreload\"][href]")) {
+				link_as[l.href] = l.getAttribute("as") || "script";
+				link_co[l.href] = l.getAttribute("crossorigin");
+			}
+		} catch {}
+		return link_as;
+	}
+	const LINK_AS = {
+		style: "css",
+		script: "script",
+		font: "font",
+		image: "img",
+		fetch: "fetch"
+	};
+	/** a resource's type, the way the runtime's beacon types it */
+	function kind(r) {
+		const x = ext(r.name);
+		const by = r.initiatorType;
+		if (x === "woff" || x === "woff2" || x === "ttf" || x === "otf") return "font";
+		if (x === "css") return "css";
+		if (x === "js" || x === "mjs") return "script";
+		if (x === "png" || x === "jpg" || x === "jpeg" || x === "gif" || x === "webp" || x === "avif" || x === "svg") return "img";
+		if (by === "link") {
+			const as = links()[r.name];
+			return as ? LINK_AS[as] || "other" : "css";
+		}
+		if (by === "css" || by === "script" || by === "img") return by;
+		if (by === "fetch" || by === "xmlhttprequest" || by === "beacon") return "fetch";
+		return "other";
+	}
+	/** PRELOADED, THEN DOWNLOADED AGAIN: one URL fetched by a preload link and again by something
+	*  else, its body over the network the second time (the preload's crossorigin or credentials did
+	*  not match). The runtime's beacon makes the same list. */
+	function preload_misses(all) {
+		const out = [];
+		try {
+			const as = links();
+			const by_url = /* @__PURE__ */ new Map();
+			for (const r of all) if (!r.name.includes("/__profiler/")) (by_url.get(r.name) ?? by_url.set(r.name, []).get(r.name)).push(r);
+			for (const [u, list] of by_url) {
+				if (list.length < 2 || out.length >= 20) continue;
+				const pre = list.find((r) => r.initiatorType === "link");
+				if (!pre) continue;
+				const again = list.find((r) => r !== pre && r.initiatorType !== "link" && r.encodedBodySize > 0 && r.transferSize >= r.encodedBodySize);
+				if (again) out.push({
+					url: u.slice(0, 500),
+					type: kind(pre),
+					bytes: again.transferSize,
+					as: as[u] || "",
+					crossorigin: typeof link_co[u] === "string" ? link_co[u] : null
+				});
+			}
+		} catch {}
+		return out;
+	}
+	/** the visit as one object (the runtime's shape, with no islands) */
+	function visit() {
+		link_as = null;
+		let nav;
+		try {
+			nav = performance.getEntriesByType("navigation")[0];
+		} catch {}
+		if (!nav || !(nav.responseStart > 0)) return null;
+		const resources = [];
+		const totals = {};
+		let count = 0;
+		const all = seen.length ? seen : performance.getEntriesByType("resource");
+		try {
+			for (const r of all) {
+				if (r.name.includes("/__profiler/")) continue;
+				count++;
+				const type = kind(r);
+				const t = totals[type] ??= {
+					type,
+					count: 0,
+					transfer: 0,
+					size: 0
+				};
+				t.count++;
+				t.transfer += r.transferSize || 0;
+				t.size += r.decodedBodySize || 0;
+			}
+			for (const r of all) {
+				if (resources.length >= 200) break;
+				if (r.name.includes("/__profiler/")) continue;
+				const o = {
+					url: r.name.slice(0, 500),
+					type: kind(r),
+					start: r2(r.startTime),
+					end: r2(r.responseEnd || r.startTime + r.duration)
+				};
+				if (r.requestStart) o.req_start = r2(r.requestStart);
+				if (r.responseStart) o.res_start = r2(r.responseStart);
+				if (r.transferSize) o.transfer = r.transferSize;
+				if (r.decodedBodySize) o.size = r.decodedBodySize;
+				if (r.renderBlockingStatus === "blocking") o.blocking = true;
+				resources.push(o);
+			}
+		} catch {}
+		const n = {
+			req_start: r2(nav.requestStart),
+			res_start: r2(nav.responseStart),
+			res_end: r2(nav.responseEnd)
+		};
+		if (nav.domInteractive) n.dom_interactive = r2(nav.domInteractive);
+		if (nav.domContentLoadedEventEnd) n.dcl = r2(nav.domContentLoadedEventEnd);
+		if (nav.loadEventEnd) n.load = r2(nav.loadEventEnd);
+		if (nav.transferSize) n.transfer = nav.transferSize;
+		if (nav.decodedBodySize) n.size = nav.decodedBodySize;
+		if (nav.nextHopProtocol) n.protocol = nav.nextHopProtocol;
+		const out = {
+			at: Math.round(performance.timeOrigin),
+			nav: n,
+			paints,
+			resources,
+			longtasks,
+			islands: [],
+			firsts: [],
+			shifts,
+			viewport: [innerWidth, innerHeight],
+			ua: navigator.userAgent.slice(0, 200)
+		};
+		if (count > resources.length) {
+			out.resource_totals = Object.values(totals);
+			out.resources_all = count;
+		}
+		const misses = preload_misses(all);
+		if (misses.length) out.preload_misses = misses;
+		out.origin = location.origin;
+		try {
+			const types = PerformanceObserver.supportedEntryTypes || [];
+			const missing = [
+				"layout-shift",
+				"longtask",
+				"event",
+				"largest-contentful-paint",
+				"long-animation-frame"
+			].filter((t) => !types.includes(t));
+			if (missing.length) out.unsupported = missing;
+		} catch {}
+		if (Object.keys(vitals).length) out.vitals = { ...vitals };
+		return out;
+	}
+	/** the load's CPU trace: once, after 8 s, or as the page hides (only when it fits a beacon) */
+	function cpu(hiding) {
+		if (runtime_claimed() || !profiler) return;
+		const p = profiler;
+		profiler = null;
+		p.stop().then((trace) => {
+			if (off || !trace) return;
+			const body = JSON.stringify({
+				page: location.pathname,
+				cpu: trace
+			});
+			if (hiding && body.length > 6e4 - queued) return;
+			post(body, hiding);
+		}, () => {});
+	}
+	/** 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 (Object.keys(vitals).length) send(JSON.stringify({
+			page: location.pathname,
+			at: Math.round(performance.timeOrigin),
+			vitals
+		}));
+		const v = visit();
+		if (v) send(JSON.stringify({
+			page: location.pathname,
+			visit: v
+		}), () => JSON.stringify({
+			page: location.pathname,
+			visit: {
+				...v,
+				resources: []
+			}
+		}));
+		cpu(true);
+	}
+	/** 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;
+		clearTimeout(resend);
+		resend = setTimeout(early, 1500);
+	}
+	/** the runtime's beacon claimed the page after all — it came without the runtime's script tag (the
+	*  devtools carry it onto a Kit page): it reports, this one hands back its observers and sampler.
+	*  Both sent the same visit, and their two bodies together passed the 64 KB a page's queued
+	*  keepalive requests share — Safari refused the second */
+	function runtime_claimed() {
+		if (off) return true;
+		if (!w[Symbol.for("ogygia.beacon")]) return false;
+		stand_down();
+		return true;
+	}
+	/** the visit while the page lives: the early one, and each re-send */
+	function early() {
+		if (runtime_claimed() || early_sends >= 8) return;
+		early_sends++;
+		const v = visit();
+		if (v) send(JSON.stringify({
+			page: location.pathname,
+			visit: v
+		}));
+	}
+	/** hand back the observers and the sampler: another beacon reports */
+	function stand_down() {
+		off = true;
+		for (const o of observers) try {
+			o.disconnect();
+		} catch {}
+		if (profiler) {
+			try {
+				profiler.stop();
+			} catch {}
+			profiler = null;
+		}
+	}
+	document.addEventListener("DOMContentLoaded", () => {
+		if (document.querySelector("script[data-ogygia-runtime]")) return stand_down();
+		document.addEventListener("visibilitychange", () => {
+			if (document.visibilityState === "hidden") hide();
+		});
+		addEventListener("pagehide", hide);
+		addEventListener("load", () => setTimeout(early, 1500));
+	});
+}
+/** The inline tag the profiler puts in its own user's document, beside the beacon meta tag. */
+const BEACON_STANDALONE_TAG = script({
+	run: standalone_beacon,
+	"data-ogygia-beacon": true
+});
+export { BEACON_STANDALONE_TAG, standalone_beacon };