@ogygia/devtools 0.0.0 → 0.11.1

package/dist/profiler/net.js

@@ -0,0 +1,586 @@
+import { may_be_chunk, module_category, module_lookup } from "./module-map.js";
+import { call_sites, file_of, is_profiler_file, register_profiler_file } from "./frames.js";
+// src/profiler/net.ts
+const is_internal_or_dep = (file) => file.includes("node:internal") || file.includes("/node_modules/") || file.includes("\\node_modules\\") || file.includes("/runtime/server/") || file.includes("/runtime/app/") || file.includes("\\runtime\\server\\") || file.includes("\\runtime\\app\\");
+/** a frame in a BUILT server chunk whose line the module map files under a package (Kit's runtime
+*  bundled into `output/server/index.js`, a bundled library): not the app's caller, though its file
+*  sits outside node_modules. Only chunk paths are looked up (the map is read once per folder) */
+const lookup = module_lookup();
+const in_bundled_package = (file, line) => {
+	if (!may_be_chunk(file)) return false;
+	const id = lookup(file, line);
+	return !!id && !!module_category(id);
+};
+/** the file's base name without its query (`/a/b/c.ts?x` → `c.ts`) */
+const base_name = (file) => {
+	const q = file.indexOf("?");
+	const s = q === -1 ? file : file.slice(0, q);
+	const cut = Math.max(s.lastIndexOf("/"), s.lastIndexOf("\\"));
+	return cut === -1 ? s : s.slice(cut + 1);
+};
+const MAX_TIMINGS = 12;
+/**
+* Parse a `Server-Timing` header (RFC-ish: comma-separated metrics, `;`-separated params, `dur` in
+* ms, `desc` quoted or bare). Tolerant: a malformed entry is skipped, never thrown on. Exported for
+* the tests.
+*/
+/** an HTTP token (RFC 7230 tchar), checked char by char — this runs per response header */
+function is_token(s) {
+	if (!s.length) return false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (!(c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 33 || c >= 35 && c <= 39 || c === 42 || c === 43 || c === 45 || c === 46 || c === 94 || c === 95 || c === 96 || c === 124 || c === 126)) return false;
+	}
+	return true;
+}
+function parse_server_timing(header) {
+	if (!header) return void 0;
+	const out = [];
+	for (const raw of header.split(",")) {
+		if (out.length >= MAX_TIMINGS) break;
+		const parts = raw.split(";").map((p) => p.trim());
+		const name = parts.shift();
+		if (!name || !is_token(name)) continue;
+		let ms = 0;
+		let desc;
+		for (const p of parts) {
+			const eq = p.indexOf("=");
+			const k = (eq === -1 ? p : p.slice(0, eq)).trim().toLowerCase();
+			let v = eq === -1 ? "" : p.slice(eq + 1).trim();
+			if (v.startsWith("\"") && v.endsWith("\"") && v.length >= 2) v = v.slice(1, -1);
+			if (k === "dur") {
+				const n = Number(v);
+				if (Number.isFinite(n) && n >= 0) ms = Math.round(n * 100) / 100;
+			} else if (k === "desc" && v) desc = v.slice(0, 80);
+		}
+		out.push(desc ? {
+			name: name.slice(0, 40),
+			ms,
+			desc
+		} : {
+			name: name.slice(0, 40),
+			ms
+		});
+	}
+	return out.length ? out : void 0;
+}
+const NET_STATE = Symbol.for("ogygia.profiler.net-state");
+const shared = globalThis[NET_STATE] ??= { stacks: false };
+function set_stack_capture(on) {
+	shared.stacks = on;
+}
+register_profiler_file();
+/** The nearest first-party frame that issued an I/O call — skips node internals,
+* node_modules, and the profiler's own frames, so the caller reads like your
+* code. Shared by the network patch and the async_hooks I/O tracker. */
+function nearest_app_site() {
+	for (const site of call_sites(nearest_app_site)) {
+		const file = file_of(site);
+		if (!file) continue;
+		if (is_profiler_file(file) || file.startsWith("node:") || is_internal_or_dep(file) || in_bundled_package(file, site.getLineNumber() ?? 0)) continue;
+		return {
+			fn: site.getFunctionName() || "(anonymous)",
+			file,
+			line: site.getLineNumber() ?? 0,
+			column: site.getColumnNumber() ?? 0
+		};
+	}
+}
+/** The first-party CALL PATH above an I/O call — the nearest app frame and the ones that called it
+*  (`fetchStock` ← `load`), skipping the same internals as `nearest_app_site`. Read off the one
+*  stack that call already captured, so it costs nothing extra beyond a few more frames. */
+function app_call_chain(limit = 5) {
+	const out = [];
+	for (const site of call_sites(app_call_chain)) {
+		const file = file_of(site);
+		if (!file) continue;
+		if (is_profiler_file(file) || file.startsWith("node:") || is_internal_or_dep(file) || in_bundled_package(file, site.getLineNumber() ?? 0)) continue;
+		out.push({
+			fn: site.getFunctionName() || "(anonymous)",
+			file,
+			line: site.getLineNumber() ?? 0,
+			column: site.getColumnNumber() ?? 0
+		});
+		if (out.length >= limit) break;
+	}
+	return out;
+}
+/** Best-effort caller string with no sourcemap (fallback before resolution). */
+function nearest_app_frame() {
+	const s = nearest_app_site();
+	if (!s) return void 0;
+	return `${s.fn} (${base_name(s.file)}:${s.line})`;
+}
+let installed = false;
+let net_emit = null;
+/** the current request's kept-answer lookup (its context's `answer`), set by install */
+let net_answer = null;
+const KEEP_ONE = 1048576;
+const KEEP_ALL = 8388608;
+let keep_bodies = false;
+let kept_bytes = 0;
+const kept = /* @__PURE__ */ new Map();
+/** each GET's FIRST answer in the recording too: against the last, what changed between renders */
+const kept_first = /* @__PURE__ */ new Map();
+/** start (clearing what was kept) or stop keeping answers */
+function keep_answers(on) {
+	keep_bodies = on;
+	if (on) {
+		kept.clear();
+		kept_first.clear();
+		kept_bytes = 0;
+	}
+}
+/** drop every kept answer */
+function drop_answers() {
+	kept.clear();
+	kept_first.clear();
+	kept_bytes = 0;
+}
+/**
+* WHAT CHANGED IN AN ANSWER between the first render and the last: the one stretch that differs
+* (the bytes before it and after it are the same), and that stretch as text with a little around
+* it — a timestamp, a request id. Undefined when either answer was not kept, or they are the same.
+*/
+function answer_diff(key) {
+	const a = kept_first.get(key);
+	const b = kept.get(key)?.body;
+	if (!a || !b) return void 0;
+	let pre = 0;
+	const min = Math.min(a.length, b.length);
+	while (pre < min && a[pre] === b[pre]) pre++;
+	if (pre === a.length && pre === b.length) return void 0;
+	let suf = 0;
+	while (suf < min - pre && a[a.length - 1 - suf] === b[b.length - 1 - suf]) suf++;
+	const bytes = Math.max(a.length, b.length) - pre - suf;
+	const from = Math.max(0, pre - 24);
+	const to = Math.min(b.length, b.length - suf + 8);
+	let text = new TextDecoder().decode(b.subarray(from, to));
+	if (text.length > 90) text = text.slice(0, 89) + "…";
+	return {
+		bytes,
+		size: Math.max(a.length, b.length),
+		text
+	};
+}
+/** a kept answer as a fresh Response, or undefined */
+function kept_answer(key) {
+	const k = kept.get(key);
+	if (!k) return void 0;
+	return new Response(k.body.slice(), {
+		status: k.status,
+		headers: k.headers
+	});
+}
+const OG_FETCH_PATCH = Symbol.for("ogygia.profiler.net.fetch-patch");
+/**
+* Install the patches. `fallback` receives calls made outside any request
+* context (startup work, background jobs) so window recordings still see them.
+* Idempotent: a second call just re-asserts the fetch patch (see `ensure_fetch_patched`).
+*/
+async function install_net_capture(als, fallback) {
+	net_answer = (method, url) => als.getStore()?.answer?.(method, url);
+	net_emit = (call) => {
+		const ctx = als.getStore();
+		if (ctx) {
+			call.route = ctx.route;
+			call.path = ctx.path;
+			ctx.on_net(call);
+		} else fallback(call);
+	};
+	if (installed) {
+		ensure_fetch_patched();
+		return;
+	}
+	installed = true;
+	patch_fetch(net_emit);
+	await patch_http(net_emit);
+}
+/**
+* Re-assert the `globalThis.fetch` patch. `globalThis.fetch` can be REPLACED out from under us after
+* install — a late undici init, a framework fetch polyfill, an HMR reload of this module — which
+* silently kills capture, so reports "sometimes catch network, sometimes don't". Call this before every
+* profile: if the live fetch isn't ours (identified by the brand symbol, so we never wrap our own
+* wrapper) re-wrap whatever is there now with the same sink. One property read, idempotent — safe to
+* call every request/run.
+*/
+function ensure_fetch_patched() {
+	if (!net_emit) return;
+	const cur = globalThis.fetch;
+	if (typeof cur === "function" && cur[OG_FETCH_PATCH]) return;
+	patch_fetch(net_emit);
+}
+const INTERNAL_HEADER = "x-og-profiler-internal";
+function is_internal(input, init) {
+	if (input instanceof Request && input.headers.has(INTERNAL_HEADER)) return true;
+	const h = init?.headers;
+	if (!h) return false;
+	if (h instanceof Headers) return h.has(INTERNAL_HEADER);
+	if (Array.isArray(h)) return h.some(([k]) => k.toLowerCase() === INTERNAL_HEADER);
+	return Object.keys(h).some((k) => k.toLowerCase() === INTERNAL_HEADER);
+}
+function host_of(url) {
+	try {
+		return new URL(url).host;
+	} catch {
+		return "";
+	}
+}
+function patch_fetch(emit) {
+	const orig = globalThis.fetch;
+	if (typeof orig !== "function") return;
+	if (orig[OG_FETCH_PATCH]) return;
+	globalThis.fetch = wrap_fetch(orig, emit);
+}
+/**
+* KIT'S OWN `event.fetch` never reaches the global one for a same-origin call: it dispatches the
+* request to the app's `respond()` in-process. A load that calls its own API through it is
+* invisible to the global patch — so the profiler wraps `event.fetch` per attributed request with
+* the same recorder. Idempotent (the brand), nothing when capture is not installed.
+*/
+function wrap_event_fetch(f) {
+	if (!net_emit || typeof f !== "function" || f[OG_FETCH_PATCH]) return f;
+	return wrap_fetch(f, net_emit);
+}
+/** the request header that asks, and the response header that answers */
+const TRACE_HEADER = "x-og-trace";
+const MAX_TRACE_CHARS = 4e3;
+function encode_trace(t) {
+	let top = t.top ?? [];
+	let s = "";
+	for (;;) {
+		s = Buffer.from(JSON.stringify({
+			...t,
+			...top.length ? { top } : {}
+		}), "utf8").toString("base64");
+		if (s.length <= MAX_TRACE_CHARS || !top.length) break;
+		top = top.slice(0, -1);
+	}
+	return s;
+}
+function decode_trace(h) {
+	if (!h || h.length > MAX_TRACE_CHARS * 2) return void 0;
+	try {
+		const t = JSON.parse(Buffer.from(h, "base64").toString("utf8"));
+		if (typeof t?.ms !== "number" || !Number.isFinite(t.ms)) return void 0;
+		const out = {
+			ms: t.ms,
+			cpu_ms: Number(t.cpu_ms) || 0,
+			wait_ms: Number(t.wait_ms) || 0,
+			calls: Number(t.calls) || 0
+		};
+		if (typeof t.route === "string" || t.route === null) out.route = t.route;
+		if (Array.isArray(t.top)) out.top = t.top.filter((x) => x && typeof x.url === "string" && typeof x.ms === "number").slice(0, 8).map((x) => ({
+			url: x.url.slice(0, 200),
+			ms: x.ms
+		}));
+		if (typeof t.profiler === "string") out.profiler = t.profiler.slice(0, 200);
+		return out;
+	} catch {
+		return;
+	}
+}
+/** The recording wrapper around a fetch-shaped function: one NetCall per call, timed to headers
+*  and body, the caller captured while a recording runs. */
+function wrap_fetch(orig, emit) {
+	const patched = async function fetch(input, init) {
+		if (is_internal(input, init)) return orig(input, init);
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input?.url ?? "";
+		const method = init?.method ?? (input?.method || "GET");
+		const canned = net_answer?.(method.toUpperCase(), url);
+		if (canned) return canned;
+		const call = {
+			start: performance.now(),
+			epoch: Date.now(),
+			ms: -1,
+			method: method.toUpperCase(),
+			url,
+			host: host_of(url),
+			status: 0,
+			kind: "fetch",
+			route: null,
+			path: null
+		};
+		if (shared.stacks) {
+			const chain = app_call_chain();
+			call.caller_site = chain[0];
+			if (chain.length > 1) call.caller_chain = chain;
+		}
+		capture_req_payload(init, call);
+		try {
+			const h = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+			if (h.has("cookie") || h.has("authorization")) call.personal = true;
+		} catch {}
+		emit(call);
+		try {
+			let init2 = init;
+			if (shared.stacks) try {
+				const h = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+				h.set(TRACE_HEADER, "1");
+				init2 = {
+					...init,
+					headers: h
+				};
+			} catch {
+				init2 = init;
+			}
+			const res = await orig(input, init2);
+			call.ms = round2(performance.now() - call.start);
+			call.status = res.status;
+			call.type = short_ct(res.headers.get("content-type"));
+			call.encoding = res.headers.get("content-encoding") || void 0;
+			const len = res.headers.get("content-length");
+			if (len) call.transfer_bytes = Number(len) || void 0;
+			call.headers = headers_of(res.headers);
+			call.timings = parse_server_timing(res.headers.get("server-timing"));
+			const trace = decode_trace(res.headers.get(TRACE_HEADER));
+			if (trace) call.trace = trace;
+			count_decoded(res, call);
+			wrap_body(res, call);
+			return res;
+		} catch (e) {
+			call.ms = round2(performance.now() - call.start);
+			call.error = e instanceof Error ? e.message : String(e);
+			throw e;
+		}
+	};
+	patched[OG_FETCH_PATCH] = true;
+	return patched;
+}
+/** time json()/text()/arrayBuffer() so "slow API" vs "slow body download" is visible */
+function wrap_body(res, call) {
+	for (const name of [
+		"json",
+		"text",
+		"arrayBuffer"
+	]) {
+		const orig = res[name]?.bind(res);
+		if (!orig) continue;
+		try {
+			Object.defineProperty(res, name, {
+				configurable: true,
+				writable: true,
+				value: async function() {
+					const t = performance.now();
+					const v = await orig();
+					call.body_ms = round2((call.body_ms ?? 0) + (performance.now() - t));
+					if (call.bytes === void 0) {
+						if (typeof v === "string") call.bytes = v.length;
+						else if (v instanceof ArrayBuffer) call.bytes = v.byteLength;
+					}
+					return v;
+				}
+			});
+		} catch {}
+	}
+}
+/** Strip params from a content-type: "application/json; charset=utf-8" → "application/json". */
+function short_ct(ct) {
+	if (!ct) return void 0;
+	const i = ct.indexOf(";");
+	return (i === -1 ? ct : ct.slice(0, i)).trim() || void 0;
+}
+/** Snapshot response headers for the request side panel. Capped (≤40 entries, ≤512 chars each) so a
+*  rogue header value can't bloat the `.ogp`. Returns undefined when there are none. */
+function headers_of(h) {
+	const out = {};
+	let n = 0;
+	for (const [k, v] of h) {
+		if (n++ >= 40) break;
+		out[k] = v.length > 512 ? v.slice(0, 512) + "…" : v;
+	}
+	return n ? out : void 0;
+}
+const MAX_PAYLOAD = 4e6;
+const utf8_len = (s) => {
+	try {
+		return new TextEncoder().encode(s).byteLength;
+	} catch {
+		return s.length;
+	}
+};
+const clip = (s) => s.length > MAX_PAYLOAD ? s.slice(0, MAX_PAYLOAD) + "\n… (truncated)" : s;
+/** Capture the request body's size (+ a preview for string / form bodies). Never consumes a stream. */
+function capture_req_payload(init, call) {
+	const body = init?.body;
+	if (body == null) return;
+	try {
+		if (typeof body === "string") {
+			call.req_bytes = utf8_len(body);
+			call.req_payload = clip(body);
+		} else if (body instanceof URLSearchParams) {
+			const s = body.toString();
+			call.req_bytes = utf8_len(s);
+			call.req_payload = clip(s);
+		} else if (body instanceof ArrayBuffer) call.req_bytes = body.byteLength;
+		else if (ArrayBuffer.isView(body)) call.req_bytes = body.byteLength;
+	} catch {}
+}
+/** a body is fingerprinted over this many bytes at most (with its full length) */
+const BODY_HASH_MAX = 4194304;
+/** Count the DECODED response body size by draining a CLONE in the background (the original is left
+*  untouched). Sets `call.bytes` when done — the render finishes first, so it's ready by report time. */
+function count_decoded(res, call) {
+	let clone;
+	try {
+		clone = res.clone();
+	} catch {
+		return;
+	}
+	const stream = clone.body;
+	if (!stream) return;
+	const keep = keep_bodies && !call.personal && call.method === "GET" && res.status >= 200 && res.status < 300;
+	const status = res.status;
+	(async () => {
+		try {
+			const reader = stream.getReader();
+			let total = 0;
+			let parts = keep ? [] : null;
+			let h = 2166136261;
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) {
+					const n = Math.min(value.byteLength, Math.max(0, BODY_HASH_MAX - total));
+					for (let i = 0; i < n; i++) h = Math.imul(h ^ value[i], 16777619);
+				}
+				total += value?.byteLength ?? 0;
+				if (parts && value) {
+					if (total > KEEP_ONE) parts = null;
+					else parts.push(value);
+				}
+			}
+			call.bytes = total;
+			call.body_hash = (h >>> 0).toString(16) + ":" + total;
+			if (parts && keep_bodies) {
+				const key = `GET ${call.url}`;
+				const before = kept.get(key)?.body.byteLength ?? 0;
+				if (kept_bytes - before + total <= KEEP_ALL) {
+					const body = new Uint8Array(total);
+					let at = 0;
+					for (const p of parts) {
+						body.set(p, at);
+						at += p.byteLength;
+					}
+					const headers = [];
+					clone.headers.forEach((v, k) => {
+						if (k !== "content-encoding" && k !== "content-length" && k !== "transfer-encoding") headers.push([k, v]);
+					});
+					kept.set(key, {
+						status,
+						headers,
+						body
+					});
+					kept_bytes += total - before;
+					if (!kept_first.has(key) && kept_bytes + total <= KEEP_ALL) {
+						kept_first.set(key, body);
+						kept_bytes += total;
+					}
+				}
+			}
+		} catch {}
+	})();
+}
+async function patch_http(emit) {
+	for (const proto of ["http", "https"]) {
+		let mod;
+		try {
+			mod = (await import(
+				/* @vite-ignore */
+				`node:${proto}`
+)).default;
+		} catch {
+			continue;
+		}
+		const orig_request = mod.request;
+		const orig_get = mod.get;
+		if (typeof orig_request !== "function") continue;
+		try {
+			mod.request = function(...args) {
+				const req = orig_request.apply(this, args);
+				instrument_client_request(req, args, proto, emit);
+				return req;
+			};
+			if (typeof orig_get === "function") mod.get = function(...args) {
+				const req = orig_get.apply(this, args);
+				instrument_client_request(req, args, proto, emit);
+				return req;
+			};
+		} catch {}
+	}
+}
+function instrument_client_request(req, args, proto, emit) {
+	const r = req;
+	if (typeof r?.on !== "function") return;
+	let url = "";
+	let method = "GET";
+	const a0 = args[0];
+	if (typeof a0 === "string") url = a0;
+	else if (a0 instanceof URL) url = a0.href;
+	const opts = typeof a0 === "object" && !(a0 instanceof URL) ? a0 : args[1];
+	if (opts && typeof opts === "object") {
+		if (typeof opts.method === "string") method = opts.method;
+		if (!url) url = `${proto}://${opts.hostname || opts.host || "localhost"}${opts.port ? `:${opts.port}` : ""}${opts.path || "/"}`;
+	}
+	if (r.method) method = r.method;
+	const call = {
+		start: performance.now(),
+		epoch: Date.now(),
+		ms: -1,
+		method: method.toUpperCase(),
+		url,
+		host: host_of(url),
+		status: 0,
+		kind: "http",
+		route: null,
+		path: null
+	};
+	if (shared.stacks) {
+		const chain = app_call_chain();
+		call.caller_site = chain[0];
+		if (chain.length > 1) call.caller_chain = chain;
+	}
+	emit(call);
+	r.on("response", (res) => {
+		call.ms = round2(performance.now() - call.start);
+		const rr = res;
+		call.status = rr.statusCode ?? 0;
+		const h = rr.headers ?? {};
+		const str_h = (v) => Array.isArray(v) ? v[0] : v;
+		const len = str_h(h["content-length"]);
+		if (len) call.transfer_bytes = Number(len) || void 0;
+		call.encoding = str_h(h["content-encoding"]) || void 0;
+		call.type = short_ct(str_h(h["content-type"]) ?? null);
+		call.timings = parse_server_timing(str_h(h["server-timing"]));
+		rr.on?.("end", () => {
+			call.body_ms = round2(performance.now() - call.start - call.ms);
+		});
+	});
+	r.on("error", (e) => {
+		if (call.ms === -1) call.ms = round2(performance.now() - call.start);
+		call.error = e instanceof Error ? e.message : String(e);
+	});
+}
+function round2(n) {
+	return Math.round(n * 100) / 100;
+}
+/**
+* How much of the wall time is explained by network calls running one after
+* another (no overlap). High sequential time with several calls = the classic
+* "await in a loop" page.
+*/
+function sequential_ms(calls) {
+	const done = calls.filter((c) => c.ms >= 0).map((c) => ({
+		s: c.start,
+		e: c.start + c.ms + (c.body_ms ?? 0)
+	})).sort((a, b) => a.s - b.s);
+	let total = 0;
+	let edge = -Infinity;
+	for (const c of done) {
+		if (c.s >= edge) total += c.e - c.s;
+		else if (c.e > edge) total += c.e - edge;
+		edge = Math.max(edge, c.e);
+	}
+	return Math.round(total * 100) / 100;
+}
+export { TRACE_HEADER, answer_diff, app_call_chain, decode_trace, drop_answers, encode_trace, ensure_fetch_patched, install_net_capture, keep_answers, kept_answer, nearest_app_frame, nearest_app_site, parse_server_timing, register_profiler_file, sequential_ms, set_stack_capture, wrap_event_fetch };

package/dist/profiler/on-demand.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DEMAND-ONLY profiler routing (`profiler: { onDemand: true }`).
+ *
+ * The whole decision the handle makes each request BEFORE it would import the profiler: skip the
+ * profiler entirely — no import, no parse, no init, no per-request wrap — when the mode is on, it has
+ * not been mounted yet this process, and this request is not for the profiler UI. Reads only plain
+ * values, so no profiler code is loaded to decide. `/__profiler` is a reserved, clash-safe path, so a
+ * substring test is safe: it can only ever mount the profiler EARLY (harmless — the same cost normal
+ * mode always pays), never MISS a real profiler request (which would break the dashboard).
+ */
+export declare function profiler_demand_skip(on_demand: boolean, profiler_mounted: boolean, pathname: string, ui_path: string): boolean;

package/dist/profiler/on-demand.js

@@ -0,0 +1,15 @@
+// src/profiler/on-demand.ts
+/**
+* DEMAND-ONLY profiler routing (`profiler: { onDemand: true }`).
+*
+* The whole decision the handle makes each request BEFORE it would import the profiler: skip the
+* profiler entirely — no import, no parse, no init, no per-request wrap — when the mode is on, it has
+* not been mounted yet this process, and this request is not for the profiler UI. Reads only plain
+* values, so no profiler code is loaded to decide. `/__profiler` is a reserved, clash-safe path, so a
+* substring test is safe: it can only ever mount the profiler EARLY (harmless — the same cost normal
+* mode always pays), never MISS a real profiler request (which would break the dashboard).
+*/
+function profiler_demand_skip(on_demand, profiler_mounted, pathname, ui_path) {
+	return on_demand && !profiler_mounted && !pathname.includes(ui_path);
+}
+export { profiler_demand_skip };

package/dist/profiler/own-requests.d.ts

@@ -0,0 +1,9 @@
+import { ReportMeta, RequestEntry } from "./report.js";
+/**
+ * THE PROFILED PAGE'S OWN REQUESTS among every request the window saw: a page profile's renders
+ * (the profiler's own, of that path), a caught or header-profiled request's path. Another visitor's
+ * page answered meanwhile carries ITS islands and ITS seed — read from it, a report said the
+ * profiled page shipped the other page's data. A window profile has no page: all of them.
+ * (Its own module, type imports only: the compare view runs in the browser.)
+ */
+export declare function own_requests(meta: ReportMeta): RequestEntry[];

package/dist/profiler/own-requests.js

@@ -0,0 +1,17 @@
+// src/profiler/own-requests.ts
+/**
+* THE PROFILED PAGE'S OWN REQUESTS among every request the window saw: a page profile's renders
+* (the profiler's own, of that path), a caught or header-profiled request's path. Another visitor's
+* page answered meanwhile carries ITS islands and ITS seed — read from it, a report said the
+* profiled page shipped the other page's data. A window profile has no page: all of them.
+* (Its own module, type imports only: the compare view runs in the browser.)
+*/
+function own_requests(meta) {
+	if (meta.trigger === "page" && meta.page) {
+		const path = meta.page.split("?")[0];
+		return meta.requests.filter((r) => r.internal && r.path === path);
+	}
+	if (meta.request) return meta.requests.filter((r) => r.path === meta.request.path);
+	return meta.requests;
+}
+export { own_requests };