@ogygia/devtools 0.0.0 → 0.11.0

package/dist/devtools/profile-anchors.d.ts

@@ -0,0 +1,22 @@
+import { SlimProfile } from "./profile-store.js";
+export interface Anchor {
+  key: string;
+  title: string;
+  detail: string;
+  /** the elements, found now */
+  find: () => Element[];
+  /** how many there were when the list was built */
+  count: number;
+}
+/** a tag name we may put in a selector: letters, digits and dashes, starting with a letter */
+export declare function safe_tag(t: string): boolean;
+/** Every element on the page, INTO open shadow roots (a design system nests its parts in them), the
+ *  dock's own host left out. */
+export declare function all_elements(doc?: Document): Element[];
+/** Every element that has a source location, by file (one pass over the page). */
+export declare function elements_by_file(doc?: Document): Map<string, Element[]>;
+/** Hosts of declarative shadow roots on the page (the dock's own host left out). */
+export declare function shadow_hosts(doc?: Document): Element[];
+/** Elements of a tag, into shadow roots. */
+export declare function by_tag(tag: string, doc?: Document): Element[];
+export declare function page_anchors(p: SlimProfile, doc?: Document): Anchor[];

package/dist/devtools/profile-anchors.js

@@ -0,0 +1,135 @@
+// src/devtools/profile-anchors.ts
+const ms = (n) => n >= 1e3 ? (n / 1e3).toFixed(2) + " s" : n >= 10 ? Math.round(n) + " ms" : n.toFixed(1) + " ms";
+const kb = (n) => n < 1024 ? n + " B" : n < 1048576 ? (n / 1024).toFixed(1) + " KB" : (n / 1048576).toFixed(2) + " MB";
+/** a tag name we may put in a selector: letters, digits and dashes, starting with a letter */
+function safe_tag(t) {
+	if (!t || t.length > 60) return false;
+	const c0 = t.charCodeAt(0);
+	if (!(c0 >= 97 && c0 <= 122 || c0 >= 65 && c0 <= 90)) return false;
+	for (let i = 1; i < t.length; i++) {
+		const c = t.charCodeAt(i);
+		if (!(c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45)) return false;
+	}
+	return true;
+}
+/** Every element on the page, INTO open shadow roots (a design system nests its parts in them), the
+*  dock's own host left out. */
+function all_elements(doc = document) {
+	const out = [];
+	const walk = (root) => {
+		for (const el of root.querySelectorAll("*")) {
+			if (el.hasAttribute("data-ogygia-devtools-host")) continue;
+			out.push(el);
+			if (el.shadowRoot) walk(el.shadowRoot);
+		}
+	};
+	walk(doc);
+	return out;
+}
+/** Every element that has a source location, by file (one pass over the page). */
+function elements_by_file(doc = document) {
+	const out = /* @__PURE__ */ new Map();
+	for (const el of all_elements(doc)) {
+		const file = el.__svelte_meta?.loc?.file;
+		if (!file) continue;
+		const list = out.get(file);
+		if (list) list.push(el);
+		else out.set(file, [el]);
+	}
+	return out;
+}
+/** Hosts of declarative shadow roots on the page (the dock's own host left out). */
+function shadow_hosts(doc = document) {
+	return all_elements(doc).filter((el) => !!el.shadowRoot);
+}
+/** Elements of a tag, into shadow roots. */
+function by_tag(tag, doc = document) {
+	const t = tag.toLowerCase();
+	return all_elements(doc).filter((el) => el.localName === t);
+}
+const same_file = (a, b) => a === b || a.endsWith("/" + b) || b.endsWith("/" + a);
+function page_anchors(p, doc = document) {
+	const out = [];
+	const by_file = elements_by_file(doc);
+	const files = [...by_file.keys()];
+	const els_of = (file) => {
+		const hit = files.find((f) => same_file(f, file));
+		return hit ? by_file.get(hit) ?? [] : [];
+	};
+	const seen_files = /* @__PURE__ */ new Set();
+	for (const c of p.components) {
+		if (!c.file || !c.file.endsWith(".svelte") || seen_files.has(c.file)) continue;
+		seen_files.add(c.file);
+		const n = els_of(c.file).length;
+		if (!n) continue;
+		const file = c.file;
+		out.push({
+			key: "component:" + file,
+			title: c.name,
+			detail: `${ms(c.self_ms)} on the server${c.instances ? ` for ${c.instances} instance${c.instances === 1 ? "" : "s"}` : ""} · ${n} element${n === 1 ? "" : "s"} here`,
+			find: () => els_of(file),
+			count: n
+		});
+		if (out.length >= 6) break;
+	}
+	const islands = p.islands.filter((i) => i.fp && doc.querySelector(`ogygia-region[data-og-fp="${i.fp}"]`)).sort((a, b) => (b.ssr_ms ?? 0) - (a.ssr_ms ?? 0) || (b.props_bytes ?? 0) - (a.props_bytes ?? 0)).slice(0, 4);
+	for (const i of islands) {
+		const fp = i.fp;
+		out.push({
+			key: "island:" + fp,
+			title: `${i.name} (island)`,
+			detail: [
+				i.ssr_ms !== null ? `${ms(i.ssr_ms)} server render` : null,
+				i.props_bytes !== null ? `${kb(i.props_bytes)} props${i.culprit ? ` (not JSON: ${i.culprit})` : ""}` : null,
+				i.client_p50_ms !== null ? `${ms(i.client_p50_ms)} to hydrate` : null
+			].filter(Boolean).join(" · "),
+			find: () => [...doc.querySelectorAll(`ogygia-region[data-og-fp="${fp}"]`)],
+			count: 1
+		});
+	}
+	const runs = Math.max(1, p.runs.length);
+	for (const s of p.spans) for (const t of s.tags) {
+		if (!safe_tag(t.tag)) continue;
+		const n = by_tag(t.tag, doc).length;
+		if (!n) continue;
+		const tag = t.tag;
+		out.push({
+			key: `span:${s.name}:${tag}`,
+			title: `${s.name} · <${tag}>`,
+			detail: `${Math.round(t.count / runs)} per render, ${ms(t.ms / runs)} of the server's CPU each render · ${n} on the page`,
+			find: () => by_tag(tag, doc),
+			count: n
+		});
+	}
+	if (p.html && p.html.shadow_count) {
+		const n = shadow_hosts(doc).length;
+		if (n) out.push({
+			key: "html:shadow",
+			title: `${p.html.shadow_count} declarative shadow roots`,
+			detail: `${kb(p.html.shadow)} of the ${kb(p.html.total)} HTML · ${n} became shadow roots here` + (n < p.html.shadow_count ? ` — the browser refused the other ${p.html.shadow_count - n} (a second shadow root on one element is not allowed): their bytes are shipped for nothing` : ""),
+			find: () => shadow_hosts(doc),
+			count: n
+		});
+	}
+	if (p.lcp && (p.lcp.fp || p.lcp.tag)) {
+		const find = () => {
+			const island = p.lcp.fp ? doc.querySelector(`ogygia-region[data-og-fp="${p.lcp.fp}"]`) : null;
+			if (island && p.lcp.tag && safe_tag(p.lcp.tag)) {
+				const inner = island.querySelector(p.lcp.tag);
+				if (inner) return [inner];
+			}
+			return island ? [island] : [];
+		};
+		const n = find().length;
+		if (n) out.push({
+			key: "lcp",
+			title: "Largest paint",
+			detail: `<${p.lcp.tag ?? "?"}>${p.lcp.ms !== null ? ` at ${ms(p.lcp.ms)}` : ""}${p.lcp.fp ? ` in ${p.islands.find((i) => i.fp === p.lcp.fp)?.name ?? "an island"}` : ""}`,
+			find,
+			count: n
+		});
+	}
+	const keys = /* @__PURE__ */ new Set();
+	return out.filter((a) => !keys.has(a.key) && !!keys.add(a.key));
+}
+export { all_elements, by_tag, elements_by_file, page_anchors, safe_tag, shadow_hosts };

package/dist/devtools/profile-store.d.ts

@@ -0,0 +1,175 @@
+/**
+ * The devtools' copy of the last SSR profile per page — the native Profiler tab writes it, the Lens
+ * roster and the island detail read it (joined by fingerprint, then by entry), so a server cost sits
+ * next to the browser's numbers for the same island. Kept SLIM: the profiler's JSON answer is
+ * hundreds of KB; the dock needs the score, the forecast, the findings, the islands, the top
+ * components and the calls. The slim copy also survives a reload (sessionStorage, best effort).
+ */
+export interface SlimIsland {
+  name: string;
+  fp: string | null;
+  entry: string | null;
+  wake: string | null;
+  ssr_ms: number | null;
+  props_bytes: number | null;
+  seed_refs: number;
+  culprit: string | null;
+  client_p50_ms: number | null;
+  recovered: number;
+  /** its first line that draws differently in the browser (the profiler's reading of its sources) */
+  hazard?: {
+    file: string;
+    line: number;
+    kind: "await" | "browser";
+    reads?: string;
+    guard?: true;
+  };
+}
+export interface SlimProfile {
+  id: string;
+  page: string;
+  at: number;
+  runs: number[];
+  render_ms: number;
+  /** the Cache-Control the page answered the profiler's renders (what the browser cannot read) */
+  cache_control?: string;
+  /** the page is prerendered: 'file' (served as the build's file), 'route' (its route prerenders) */
+  prerendered?: "file" | "route";
+  score: {
+    score: number;
+    grade: string;
+    categories: {
+      key: string;
+      label: string;
+      score: number;
+      value: string;
+      lost: number;
+      detail: string[];
+    }[];
+    missing: {
+      label: string;
+      why: string;
+    }[];
+    /** since the last profile of this page */
+    was?: {
+      score: number;
+      grade: string;
+    };
+  } | null;
+  /** what the page loads at start (a build only) */
+  assets: {
+    js: number;
+    lazy_js: number;
+    wire: number;
+    files: {
+      name: string;
+      kind: string;
+      bytes: number;
+      lazy: boolean;
+      contains: string[];
+    }[];
+    /** one module shipped as two copies, both loaded by this page: its files, their bytes, where each
+     *  came from, and what the second copy costs */
+    twice?: {
+      name: string;
+      copies: {
+        file: string;
+        bytes: number;
+        from?: string;
+      }[];
+      extra: number;
+    }[];
+  } | null;
+  forecast: {
+    now_ms: number;
+    after_ms: number;
+    parts: {
+      title: string;
+      kind: string;
+      ms: number;
+      wait: boolean;
+    }[];
+  } | null;
+  findings: {
+    severity: string;
+    code: string;
+    message: string;
+    fix?: string;
+    fps?: string[];
+  }[];
+  islands: SlimIsland[];
+  components: {
+    name: string;
+    file: string | null;
+    self_ms: number;
+    total_ms: number;
+    instances: number | null;
+  }[];
+  network: {
+    count: number;
+    total_ms: number;
+    sequential_ms: number;
+    calls: {
+      method: string;
+      url: string;
+      status: number | null;
+      wait_ms: number;
+    }[];
+  } | null;
+  seed_bytes: number | null;
+  links: {
+    html: string;
+    json: string;
+  } | null;
+  /** named spans split by an element tag (`span('ds.render', …, { tag })`): the page's elements of it */
+  spans: {
+    name: string;
+    total_ms: number;
+    tags: {
+      tag: string;
+      count: number;
+      ms: number;
+    }[];
+  }[];
+  /** the document as bytes: its size, what kind, and the declarative shadow roots in it */
+  html: {
+    total: number;
+    shadow: number;
+    shadow_count: number;
+    by_kind: Record<string, number>;
+  } | null;
+  /** the largest paint the browser saw (its tag, the island it sat in) */
+  lcp: {
+    tag: string | null;
+    fp: string | null;
+    ms: number | null;
+  } | null;
+  /** the server's hottest code (own time, per render) */
+  hot: {
+    name: string;
+    file: string | null;
+    line: number | null;
+    ms: number;
+    kind: string;
+  }[];
+}
+/**
+ * Profile a same-origin path on the server, now (the profiler's `/page?format=json`; a 409 = the
+ * recorder is busy: wait and ask again). Stores the slim copy and returns it.
+ */
+export declare function run_profile(path: string, runs?: number, base?: string): Promise<SlimProfile>;
+/**
+ * A record of the profiler's JSON answer, untyped on the wire (and possibly from another version):
+ * read deep and tolerant (`r.since?.score?.a`), with every value checked before use (`num`, `str`,
+ * `arr`, `String`), so a missing or odd field reads as empty instead of throwing.
+ */
+type WireRecord = Record<string, any>;
+/** The profiler's JSON answer (`/page?format=json`) cut to what the dock shows. Tolerant: a field
+ *  the report lacks is left empty, never a throw. */
+export declare function slim_profile(r: WireRecord): SlimProfile;
+/** The server row for an island: by fingerprint, else by entry (the same island with other props). */
+export declare function island_row(p: SlimProfile | null, fp: string | null, entry: string | null): SlimIsland | null;
+export declare function set_profile(p: SlimProfile): void;
+export declare function profile_for(page: string): SlimProfile | null;
+export declare function profiles_version(): number;
+export {};

package/dist/devtools/profile-store.js

@@ -0,0 +1,239 @@
+// src/devtools/profile-store.ts
+/**
+* Profile a same-origin path on the server, now (the profiler's `/page?format=json`; a 409 = the
+* recorder is busy: wait and ask again). Stores the slim copy and returns it.
+*/
+async function run_profile(path, runs = 3, base = "/__profiler") {
+	const url = `${base}/page?p=${encodeURIComponent(path)}&runs=${runs}&format=json`;
+	for (let tries = 0; tries < 30; tries++) {
+		const r = await fetch(url, { headers: { accept: "application/json" } });
+		if (r.status === 409) {
+			await new Promise((ok) => setTimeout(ok, 2e3));
+			continue;
+		}
+		if (!r.ok) {
+			const text = await r.text();
+			let said = text;
+			try {
+				const j = JSON.parse(text);
+				said = typeof j.error === "string" ? j.error : typeof j.message === "string" ? j.message : text;
+			} catch {}
+			throw new Error(r.status === 503 ? said.slice(0, 600) : `the profiler answered ${r.status}: ${said.slice(0, 300)}`);
+		}
+		const p = slim_profile(await r.json());
+		set_profile(p);
+		return p;
+	}
+	throw new Error("another profile kept the recorder busy for a minute");
+}
+const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+const str = (v) => typeof v === "string" ? v : null;
+const arr = (v) => Array.isArray(v) ? v.filter((x) => x && typeof x === "object") : [];
+/** an island row's first hazard line — a value it renders before a guard around browser-only work */
+function slim_hazard(v) {
+	const list = arr(v).filter((h) => typeof h.file === "string" && typeof h.line === "number" && (h.kind === "await" || h.kind === "browser"));
+	const h = list.find((x) => !x.guard) ?? list[0];
+	return h ? { hazard: {
+		file: h.file,
+		line: h.line,
+		kind: h.kind,
+		...typeof h.reads === "string" ? { reads: h.reads } : {},
+		...h.guard === true ? { guard: true } : {}
+	} } : {};
+}
+function median(xs) {
+	if (!xs.length) return 0;
+	const s = [...xs].sort((a, b) => a - b);
+	const m = s.length >> 1;
+	return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+/** The profiler's JSON answer (`/page?format=json`) cut to what the dock shows. Tolerant: a field
+*  the report lacks is left empty, never a throw. */
+function slim_profile(r) {
+	const target = r?.target ?? {};
+	const runs = (Array.isArray(target.runs) ? target.runs : []).filter((x) => typeof x === "number");
+	const sc = r?.score;
+	const fc = r?.forecast;
+	const net = r?.network;
+	const order = {
+		error: 0,
+		warn: 1,
+		info: 2
+	};
+	return {
+		id: String(r?.id ?? ""),
+		page: String(target.page ?? ""),
+		at: num(r?.created) ?? Date.now(),
+		runs,
+		render_ms: Math.round(median(runs) * 10) / 10,
+		...typeof target.cache_control === "string" && target.cache_control ? { cache_control: target.cache_control.slice(0, 200) } : {},
+		...target.prerendered === "file" || target.prerendered === "route" ? { prerendered: target.prerendered } : {},
+		score: sc && typeof sc.score === "number" ? {
+			score: sc.score,
+			grade: String(sc.grade ?? ""),
+			categories: arr(sc.categories).map((c) => ({
+				key: String(c.key),
+				label: String(c.label ?? c.key),
+				score: num(c.score) ?? 0,
+				value: String(c.value ?? ""),
+				lost: num(c.lost) ?? 0,
+				detail: Array.isArray(c.detail) ? c.detail.map(String).slice(0, 4) : []
+			})),
+			missing: arr(sc.missing).map((m) => ({
+				label: String(m.label ?? m.key),
+				why: String(m.why ?? "")
+			})),
+			...typeof r?.since?.score?.a === "number" ? { was: {
+				score: r.since.score.a,
+				grade: String(r.since.score.a_grade ?? "")
+			} } : {}
+		} : null,
+		assets: r?.assets?.totals ? {
+			js: num(r.assets.totals.js) ?? 0,
+			lazy_js: num(r.assets.totals.lazy_js) ?? 0,
+			wire: num(r.assets.totals.wire) ?? 0,
+			files: arr(r.assets.files).slice(0, 10).map((f) => ({
+				name: String(f.url ?? "").split("?")[0].split("/").pop() ?? "",
+				kind: String(f.kind ?? ""),
+				bytes: num(f.bytes) ?? 0,
+				lazy: !!f.lazy,
+				contains: Array.isArray(f.contains) ? f.contains.map(String).slice(0, 4) : []
+			})),
+			...(() => {
+				const twice = arr(r.assets.twice).slice(0, 8).map((d) => ({
+					name: String(d.name ?? ""),
+					copies: arr(d.copies).slice(0, 3).map((c) => ({
+						file: String(c.file ?? ""),
+						bytes: num(c.bytes) ?? 0,
+						...typeof c.from === "string" ? { from: c.from } : {}
+					})),
+					extra: num(d.extra) ?? 0
+				})).filter((d) => d.name && d.copies.length >= 2);
+				return twice.length ? { twice } : {};
+			})()
+		} : null,
+		forecast: fc && typeof fc.now_ms === "number" ? {
+			now_ms: fc.now_ms,
+			after_ms: num(fc.after_ms) ?? fc.now_ms,
+			parts: arr(fc.parts).slice(0, 8).map((p) => ({
+				title: String(p.title ?? p.kind),
+				kind: String(p.kind ?? ""),
+				ms: num(p.ms) ?? 0,
+				wait: !!p.wait
+			}))
+		} : null,
+		findings: arr(r?.findings).filter((f) => f.code !== "summary").map((f) => ({
+			severity: String(f.severity ?? "info"),
+			code: String(f.code ?? ""),
+			message: String(f.message ?? ""),
+			...f.fix ? { fix: String(f.fix) } : {},
+			...Array.isArray(f.fps) && f.fps.length ? { fps: f.fps.slice(0, 40).map(String) } : {}
+		})).sort((a, b) => (order[a.severity] ?? 3) - (order[b.severity] ?? 3)).slice(0, 30),
+		islands: arr(r?.ogygia?.island_rows).map((i) => ({
+			name: String(i.name ?? ""),
+			fp: str(i.fp),
+			entry: str(i.entry),
+			wake: str(i.wake),
+			ssr_ms: num(i.ssr_ms),
+			props_bytes: num(i.props_bytes),
+			seed_refs: num(i.seed_refs) ?? 0,
+			culprit: str(i.devalue_culprit),
+			client_p50_ms: num(i.client?.p50_ms),
+			recovered: num(i.client?.recovered) ?? 0,
+			...slim_hazard(i.hazards)
+		})),
+		components: arr(r?.components).slice(0, 12).map((c) => ({
+			name: String(c.name ?? ""),
+			file: str(c.file),
+			self_ms: num(c.self_ms) ?? 0,
+			total_ms: num(c.total_ms) ?? 0,
+			instances: num(c.instances)
+		})),
+		network: net ? {
+			count: num(net.count) ?? 0,
+			total_ms: num(net.total_ms) ?? 0,
+			sequential_ms: num(net.sequential_ms) ?? 0,
+			calls: arr(net.calls).slice(0, 20).map((c) => ({
+				method: String(c.method ?? "GET"),
+				url: String(c.url ?? ""),
+				status: num(c.status),
+				wait_ms: num(c.wait_ms) ?? 0
+			}))
+		} : null,
+		seed_bytes: num(r?.ogygia?.seed_bytes),
+		links: r?.links?.html ? {
+			html: String(r.links.html),
+			json: String(r.links.json ?? "")
+		} : null,
+		spans: arr(r?.spans).filter((s) => Array.isArray(s?.by?.tag) && s.by.tag.length).slice(0, 6).map((s) => ({
+			name: String(s.name ?? ""),
+			total_ms: num(s.total_ms) ?? 0,
+			tags: arr(s.by.tag).slice(0, 8).map((t) => ({
+				tag: String(t.value ?? ""),
+				count: num(t.count) ?? 0,
+				ms: num(t.share_ms) ?? num(t.wall_ms) ?? 0
+			}))
+		})),
+		html: r?.strip ? {
+			total: num(r.strip.total) ?? 0,
+			shadow: num(r.strip.by_kind?.shadow) ?? 0,
+			shadow_count: num(r.strip.shadow_count) ?? 0,
+			by_kind: Object.fromEntries(Object.entries(r.strip.by_kind ?? {}).filter(([, v]) => typeof v === "number"))
+		} : null,
+		lcp: r?.browser?.visit?.paints ? {
+			tag: str(r.browser.visit.paints.lcp_tag),
+			fp: str(r.browser.visit.paints.lcp_fp),
+			ms: num(r.browser.visit.paints.lcp)
+		} : null,
+		hot: arr(r?.hot_functions).filter((f) => f.category !== "profiler" && f.category !== "idle").slice(0, 6).map((f) => ({
+			name: String(f.label || f.name || "(anonymous)").slice(0, 80),
+			file: str(f.file),
+			line: num(f.line),
+			ms: Math.round((num(f.self_ms) ?? 0) / Math.max(1, runs.length) * 10) / 10,
+			kind: String(f.category ?? "")
+		}))
+	};
+}
+/** The server row for an island: by fingerprint, else by entry (the same island with other props). */
+function island_row(p, fp, entry) {
+	if (!p) return null;
+	if (fp) {
+		const hit = p.islands.find((i) => i.fp === fp);
+		if (hit) return hit;
+	}
+	if (entry) {
+		const tail = entry.slice(entry.lastIndexOf("/") + 1);
+		return p.islands.find((i) => i.entry && i.entry.slice(i.entry.lastIndexOf("/") + 1) === tail) ?? null;
+	}
+	return null;
+}
+const KEY = "ogygia:devtools:profiles:v1";
+const by_page = /* @__PURE__ */ new Map();
+let loaded = false;
+let version = 0;
+function load() {
+	if (loaded) return;
+	loaded = true;
+	try {
+		const raw = sessionStorage.getItem(KEY);
+		const list = raw ? JSON.parse(raw) : [];
+		for (const p of list) if (p && p.page) by_page.set(p.page, p);
+	} catch {}
+}
+function set_profile(p) {
+	load();
+	by_page.set(p.page, p);
+	version++;
+	try {
+		const list = [...by_page.values()].sort((a, b) => b.at - a.at).slice(0, 8);
+		sessionStorage.setItem(KEY, JSON.stringify(list));
+	} catch {}
+}
+function profile_for(page) {
+	load();
+	return by_page.get(page) ?? null;
+}
+function profiles_version() {
+	return version;
+}
+export { island_row, profile_for, profiles_version, run_profile, set_profile, slim_profile };

package/dist/devtools/regions.d.ts

@@ -0,0 +1,77 @@
+import { IslandHazard } from "@ogygia/core/insights";
+import { DevtoolsEvent } from "@ogygia/core/events";
+/** Region kind, from the two dials the compiler stamps. */
+export type RegionKind = "island" | "lake" | "hole";
+export declare function region_kind(el: Element): RegionKind;
+/** One region's identity + live state, read straight off its `<ogygia-region>`. */
+export interface RegionInfo {
+  el: Element;
+  kind: RegionKind;
+  wake: string;
+  /** its identity (the stable URL every name and key uses) */
+  entry: string | null;
+  /** its location: the content-hashed file it loads (a build names one; else the entry) */
+  src: string | null;
+  fp: string | null;
+  hydrated: boolean;
+  /** a region inside an awake island: it does not wake itself, it rides the island's hydration
+   *  (`data-nested`) — awake when that island is, with no `data-hydrated` of its own */
+  rides?: Element;
+}
+export declare function region_info(el: Element): RegionInfo;
+/** Every `<ogygia-region>` on the page, as {@link RegionInfo}. */
+export declare function all_regions(): RegionInfo[];
+/**
+ * The raw devalue text of a region's `<script data-ogygia-props>` sidecar (the props that crossed the
+ * boundary), or null. Mirrors the runtime's own sibling walk (skips `<link>` CSS hints). Returned as
+ * TEXT so this module stays devalue-free; the detail view decodes it.
+ */
+export declare function region_props_sidecar(el: Element): string | null;
+/** basename of a URL/path (drops query + directory). */
+export declare function basename(url: string): string;
+/** basename without a trailing `.js`, for a compact chunk label. */
+export declare function short_chunk(url: string | null): string;
+/** The island id from an entry URL, or '': `<id>` in the dev server's `virtual:ogygia/island/<id>.js`
+ *  and in a build's `og-region.<id>.js` (the name maps key the bare id — with the prefix left on, every
+ *  tab in a build showed hashes). */
+export declare function island_id(entry: string | null | undefined): string;
+/**
+ * The compiler's `island id → component name` map (dev-only), published on `window` by the
+ * `virtual:ogygia/devtools-names` side-effect module the runtime/devtools boot pulls in. Empty off a
+ * devtools build. Lets every tab label a region "Counter" instead of a hashed entry.
+ */
+export declare function region_names(): Record<string, string>;
+/** Component name for an island entry URL, or `short_chunk(entry)` when unknown. */
+export declare function region_name(entry: string | null | undefined): string;
+/**
+ * Transitive dev size for an island entry — the compiler's module-graph estimate (wrapper +
+ * component + everything imported), published on `window.__ogygia_region_bytes` by the dock's mount
+ * fetch. `null` when the island is still cold (never woken → no subgraph yet) or off a dev build.
+ */
+export declare function region_transitive(entry: string | null | undefined): {
+  bytes: number;
+  modules: number;
+  top?: {
+    file: string;
+    bytes: number;
+  }[];
+  barrels?: {
+    file: string;
+    fanout: number;
+  }[];
+  hazards?: IslandHazard[];
+} | null;
+/** Component name for a region fingerprint — joined to its live `<ogygia-region>` in the DOM. */
+export declare function region_name_by_fp(fp: string | null | undefined): string;
+/** kB with one decimal. */
+export declare function kb(bytes: number): string;
+/** Resource-timing entry for a chunk, matched by hashed basename (unique per build). */
+export declare function timing_for(entry: string): PerformanceResourceTiming | undefined;
+/** Over-the-wire + decoded bytes for a chunk entry (0/0 when not yet loaded or size hidden). */
+export declare function chunk_bytes(entry: string): {
+  wire: number;
+  raw: number;
+  loaded: boolean;
+};
+/** Latest buffered event matching a predicate (newest wins), or null. */
+export declare function latest_event(pred: (e: DevtoolsEvent) => boolean): DevtoolsEvent | null;