@ogygia/devtools 0.0.0 → 0.11.0

package/dist/devtools/cache-headers.js

@@ -0,0 +1,81 @@
+import { all_regions, region_name } from "./regions.js";
+import { tool_fetch, tool_made } from "@ogygia/core/internal/instruments";
+// src/devtools/cache-headers.ts
+/**
+* HOW THE HOST CACHES THE ISLANDS' FILES. In a build every island's file and the runtime are named by
+* their content (the region's `src`, the runtime script's `src`), so the right cache for them is a
+* year-long `immutable` one — a new build names new files. A host that serves them `no-cache`, or
+* with a short `max-age`, makes every returning visitor download (or revalidate) every island again.
+* The browser's timing API does not expose response headers, so this asks the server once for each
+* file's (a HEAD request, past the cache) when the Page tab opens. Off a build (no `src`): nothing.
+*/
+/** A day: a content-named file cached for less than this is fetched again on most return visits. */
+const MIN_MAX_AGE_S = 86400;
+/** Read one `cache-control`: whether it caches the file long enough to count. Split, not a regex. */
+function cached_long(cache_control) {
+	if (!cache_control) return false;
+	let max_age = -1;
+	let immutable = false;
+	for (const raw of cache_control.toLowerCase().split(",")) {
+		const d = raw.trim();
+		if (d === "no-store" || d === "no-cache") return false;
+		if (d === "immutable") immutable = true;
+		if (d.startsWith("max-age=")) max_age = Number(d.slice(8));
+	}
+	return immutable ? max_age !== 0 : max_age >= MIN_MAX_AGE_S;
+}
+/** Every content-named file the page loads (the islands' locations, the runtime's), each once. */
+function content_named_files(doc = document) {
+	const out = /* @__PURE__ */ new Map();
+	const abs = (u) => new URL(u, doc.baseURI).href;
+	for (const r of all_regions()) {
+		const src = r.el.getAttribute("src");
+		if (src && r.entry && src !== r.entry && !out.has(abs(src))) out.set(abs(src), region_name(r.entry));
+	}
+	const rt = doc.querySelector("script[data-ogygia-runtime]")?.getAttribute("src");
+	if (rt && !out.has(abs(rt))) out.set(abs(rt), "the runtime");
+	return [...out].map(([url, name]) => ({
+		url,
+		name
+	}));
+}
+/** Ask the server how it caches each file (HEAD, past the browser's cache), at most `limit` files. */
+async function probe_cache(doc = document, limit = 40) {
+	const sizes = /* @__PURE__ */ new Map();
+	for (const r of performance.getEntriesByType("resource")) if (!tool_made(r)) sizes.set(r.name, r.decodedBodySize || 0);
+	const files = content_named_files(doc).slice(0, limit);
+	return Promise.all(files.map(async ({ url, name }) => {
+		let cache_control = null;
+		try {
+			cache_control = (await tool_fetch(url, {
+				method: "HEAD",
+				cache: "no-store"
+			})).headers.get("cache-control");
+		} catch {
+			cache_control = null;
+		}
+		return {
+			url,
+			name,
+			cache_control,
+			bytes: sizes.get(url) ?? 0
+		};
+	}));
+}
+/** The finding: content-named files the host does not cache long, named, with the bytes at stake. */
+function cache_findings(probes) {
+	const short = probes.filter((p) => !cached_long(p.cache_control));
+	if (!short.length) return [];
+	const kb = (n) => n >= 1024 ? `${(n / 1024).toFixed(1)} KB` : `${n} B`;
+	const bytes = short.reduce((s, p) => s + p.bytes, 0);
+	const seen = [...new Set(short.map((p) => p.cache_control ?? "no cache-control"))].slice(0, 3);
+	const names = [...new Set([...short].sort((a, b) => b.bytes - a.bytes).map((p) => p.name))];
+	const list = names.length > 4 ? `${names.slice(0, 4).join(", ")} and ${names.length - 4} more` : names.join(", ");
+	return [{
+		code: "island-files-uncached",
+		severity: "warn",
+		message: `${short.length} of the page's content-named files (${list}) are served with \`${seen.join("`, `")}\`: a returning visitor downloads${bytes ? ` ${kb(bytes)}` : ""} again (or waits to revalidate) on every visit. Their names change with their content, so they can be cached for good.`,
+		fix: "Serve `_app/immutable/` with `cache-control: public, max-age=31536000, immutable` (SvelteKit's adapters do; a proxy, a CDN rule or a custom server in front can override it)."
+	}];
+}
+export { cache_findings, cached_long, content_named_files, probe_cache };

package/dist/devtools/highlight.d.ts

@@ -0,0 +1,7 @@
+/** The dock's shadow root (ui-app.ts sets it at mount). */
+export declare function set_highlight_root(r: ShadowRoot): void;
+/** Show boxes over `els` (with a caption); `scroll` brings the first into view. */
+export declare function highlight(els: Element[], caption?: string, scroll?: boolean): void;
+export declare function clear_highlight(): void;
+/** How many boxes are shown now (tests). */
+export declare function highlighted_count(): number;

package/dist/devtools/highlight.js

@@ -0,0 +1,83 @@
+// src/devtools/highlight.ts
+/**
+* Light up MANY elements on the page at once — the profile's "these 290 shadow roots", "every
+* element Icon.svelte rendered", "the largest paint". Boxes live in the dock's own shadow root (a
+* fixed, click-through layer), follow scroll and resize while shown, and cap at a few hundred so a
+* huge match stays cheap. No Svelte: plain DOM, one layer, replaced on each call.
+*/
+let root = null;
+let layer = null;
+let current = [];
+let label = "";
+let frame = 0;
+const MAX_BOXES = 400;
+/** The dock's shadow root (ui-app.ts sets it at mount). */
+function set_highlight_root(r) {
+	root = r;
+}
+function draw() {
+	frame = 0;
+	if (!layer) return;
+	layer.textContent = "";
+	const vw = innerWidth;
+	const vh = innerHeight;
+	let n = 0;
+	for (const el of current) {
+		if (n >= MAX_BOXES) break;
+		const r = el.getBoundingClientRect();
+		if (!r.width && !r.height) continue;
+		if (r.bottom < 0 || r.top > vh || r.right < 0 || r.left > vw) continue;
+		const b = document.createElement("div");
+		b.style.cssText = `position:fixed;left:${r.left}px;top:${r.top}px;width:${r.width}px;height:${r.height}px;border:1.5px solid #f472b6;background:rgba(244,114,182,.12);border-radius:3px;box-sizing:border-box`;
+		layer.appendChild(b);
+		n++;
+	}
+	if (label) {
+		const tag = document.createElement("div");
+		tag.textContent = label;
+		tag.style.cssText = "position:fixed;left:12px;top:12px;padding:4px 9px;border-radius:7px;background:#831843;color:#fce7f3;font:600 11px/1.4 ui-monospace,monospace;box-shadow:0 4px 12px rgba(0,0,0,.35)";
+		layer.appendChild(tag);
+	}
+}
+const schedule = () => {
+	if (!frame) frame = requestAnimationFrame(draw);
+};
+/** Show boxes over `els` (with a caption); `scroll` brings the first into view. */
+function highlight(els, caption = "", scroll = false) {
+	if (!root) return;
+	current = els;
+	label = caption;
+	if (!layer) {
+		layer = document.createElement("div");
+		layer.setAttribute("data-og-highlight", "");
+		layer.style.cssText = "position:fixed;inset:0;pointer-events:none;z-index:2147483600";
+		root.prepend(layer);
+		addEventListener("scroll", schedule, {
+			passive: true,
+			capture: true
+		});
+		addEventListener("resize", schedule, { passive: true });
+	}
+	if (scroll && els[0]) try {
+		els[0].scrollIntoView({
+			behavior: "smooth",
+			block: "center"
+		});
+	} catch {}
+	schedule();
+}
+function clear_highlight() {
+	current = [];
+	label = "";
+	if (layer) {
+		layer.remove();
+		layer = null;
+		removeEventListener("scroll", schedule, { capture: true });
+		removeEventListener("resize", schedule);
+	}
+}
+/** How many boxes are shown now (tests). */
+function highlighted_count() {
+	return current.length;
+}
+export { clear_highlight, highlight, highlighted_count, set_highlight_root };

package/dist/devtools/hydration.d.ts

@@ -0,0 +1,48 @@
+import { HtmlDiff, HydrationStatus, HydrationStatus as HydrationStatus$1 } from "@ogygia/core/insights";
+import { AttrChange } from "@ogygia/core/internal/instruments";
+export declare const STATUS_RANK: Record<HydrationStatus$1, number>;
+export interface IslandHydration {
+  fp: string;
+  name: string;
+  wake: string;
+  status: HydrationStatus$1;
+  reason: string;
+  el: Element;
+  /** `from`: a big island keeps only the window around its first change (runtime/beacon.ts
+   *  `snapshot_of`) — where that window starts in its markup without comments */
+  snap: {
+    ssr: string;
+    hydrated: string;
+    from?: number;
+  } | null;
+}
+export declare function hydration_rows(): {
+  rows: IslandHydration[];
+  measured: boolean;
+};
+/** The same, as plain data (no elements), with each changed island's diff — for tests. `t0` / `done`:
+ *  when it began to wake and when it could answer, on the document's clock (ms from its start; null
+ *  for an island that has not woken), so a test can tell which of its steps woke it. */
+export declare function hydration_report(): {
+  measured: boolean;
+  islands: {
+    fp: string;
+    name: string;
+    wake: string;
+    status: HydrationStatus$1;
+    reason: string;
+    diff: HtmlDiff | null;
+    t0: number | null;
+    done: number | null;
+    /** a `changed` island whose only differences are attributes (the same elements and text — often a
+     *  custom element setting its own as it upgrades); false when text or elements differ */
+    attributesOnly: boolean;
+    /** with `attributesOnly`, each attribute that differs */
+    attributes: AttrChange[] | null;
+    /** input landed on it while it hydrated (a pointer over it, a press, a key, focus): its DOM may
+     *  have answered that input */
+    inputDuringHydration: boolean;
+    window_from?: number;
+  }[];
+};
+export type { HydrationStatus };

package/dist/devtools/hydration.js

@@ -0,0 +1,93 @@
+import { all_regions, region_name } from "./regions.js";
+import { html_diff } from "@ogygia/core/insights";
+import { beacon_page } from "@ogygia/core/internal/instruments";
+import { snapshot } from "@ogygia/core/events";
+// src/devtools/hydration.ts
+/**
+* Every island's hydration status, from the bus (failed / recovered / healed), the beacon's
+* before-and-after markup (changed), the element (`data-og-recovered`, `data-hydrated`). Shared by
+* the Hydration tab and the testing API (`window.__ogygia_testing.hydration()`).
+*/
+const STATUS_RANK = {
+	failed: 0,
+	recovered: 1,
+	healed: 2,
+	changed: 3,
+	asleep: 4,
+	clean: 5
+};
+function hydration_rows() {
+	const why = /* @__PURE__ */ new Map();
+	for (const e of snapshot()) if (e.name === "region.hydrate.failed") {
+		if (e.fp) why.set(e.fp, {
+			status: "failed",
+			reason: e.message.split("\n")[0]
+		});
+	} else if (e.name === "region.hydrate.recovered") {
+		if (e.fp) why.set(e.fp, {
+			status: "recovered",
+			reason: e.reason ?? ""
+		});
+	} else if (e.name === "region.hydrate.healed") {
+		if (e.fp && why.get(e.fp)?.status !== "recovered") why.set(e.fp, {
+			status: "healed",
+			reason: e.reason ?? ""
+		});
+	} else if (e.name === "region.hydrate.done") {
+		if (e.fp && why.get(e.fp)?.status === "failed") why.delete(e.fp);
+	}
+	const page = beacon_page();
+	const changed = new Set((page?.islands ?? []).filter((i) => i.changed).map((i) => i.fp));
+	const snaps = new Map((page?.snapshots ?? []).map((s) => [s.fp, s]));
+	const rows = [];
+	for (const r of all_regions()) {
+		if (r.kind !== "island" || !r.fp) continue;
+		const w = why.get(r.fp);
+		const attr = r.el.getAttribute("data-og-recovered");
+		const status = w?.status ?? (attr !== null ? "recovered" : changed.has(r.fp) ? "changed" : r.hydrated ? "clean" : "asleep");
+		const s = snaps.get(r.fp);
+		rows.push({
+			fp: r.fp,
+			name: region_name(r.entry),
+			wake: r.wake,
+			status,
+			reason: w?.reason || attr || (r.rides ? `rides ${region_name(r.rides.getAttribute("entry"))}, the island around it (it wakes with it, not on its own)` : ""),
+			el: r.el,
+			snap: s ? {
+				ssr: s.ssr,
+				hydrated: s.hydrated,
+				...s.from !== void 0 ? { from: s.from } : {}
+			} : null
+		});
+	}
+	rows.sort((a, b) => STATUS_RANK[a.status] - STATUS_RANK[b.status] || a.name.localeCompare(b.name));
+	return {
+		rows,
+		measured: !!page
+	};
+}
+/** The same, as plain data (no elements), with each changed island's diff — for tests. `t0` / `done`:
+*  when it began to wake and when it could answer, on the document's clock (ms from its start; null
+*  for an island that has not woken), so a test can tell which of its steps woke it. */
+function hydration_report() {
+	const { rows, measured } = hydration_rows();
+	const woke = new Map((beacon_page()?.islands ?? []).map((i) => [i.fp, i]));
+	return {
+		measured,
+		islands: rows.map((r) => ({
+			fp: r.fp,
+			name: r.name,
+			wake: r.wake,
+			status: r.status,
+			reason: r.reason,
+			diff: r.snap && r.status !== "clean" ? html_diff(r.snap.ssr, r.snap.hydrated) : null,
+			t0: woke.get(r.fp)?.t0 ?? null,
+			done: woke.get(r.fp)?.done ?? null,
+			attributesOnly: r.status === "changed" && !!woke.get(r.fp)?.attrs,
+			attributes: r.status === "changed" ? woke.get(r.fp)?.attrs ?? null : null,
+			inputDuringHydration: !!woke.get(r.fp)?.input,
+			...r.snap?.from !== void 0 ? { window_from: r.snap.from } : {}
+		}))
+	};
+}
+export { STATUS_RANK, hydration_report, hydration_rows };

package/dist/devtools/index.d.ts

@@ -0,0 +1,3 @@
+import { install_devtools_ui } from "./ui.js";
+import { CompileEventInput, DEVTOOLS, DEVTOOLS_SCHEMA_VERSION, DevtoolsDomain, DevtoolsEnvelope, DevtoolsEvent, DevtoolsEventInput, DevtoolsSink, DevtoolsTrace, DevtoolsWindowHook, HubEventInput, NavEventInput, RuntimeEventInput, ServerEventInput, WireEventInput, add_sink, clear, configure, emit, ingest, ingest_server_events, install_console_sink, install_postmessage_sink, install_window_sink, snapshot, to_trace } from "@ogygia/core/events";
+export { type CompileEventInput, DEVTOOLS, DEVTOOLS_SCHEMA_VERSION, type DevtoolsDomain, type DevtoolsEnvelope, type DevtoolsEvent, type DevtoolsEventInput, type DevtoolsSink, type DevtoolsTrace, type DevtoolsWindowHook, type HubEventInput, type NavEventInput, type RuntimeEventInput, type ServerEventInput, type WireEventInput, add_sink, clear, configure, emit, ingest, ingest_server_events, install_console_sink, install_devtools_ui, install_postmessage_sink, install_window_sink, snapshot, to_trace };

package/dist/devtools/index.js

@@ -0,0 +1,3 @@
+import { install_devtools_ui } from "./ui.js";
+import { DEVTOOLS, DEVTOOLS_SCHEMA_VERSION, add_sink, clear, configure, emit, ingest, ingest_server_events, install_console_sink, install_postmessage_sink, install_window_sink, snapshot, to_trace } from "@ogygia/core/events";
+export { DEVTOOLS, DEVTOOLS_SCHEMA_VERSION, add_sink, clear, configure, emit, ingest, ingest_server_events, install_console_sink, install_devtools_ui, install_postmessage_sink, install_window_sink, snapshot, to_trace };

package/dist/devtools/ledger-dom.d.ts

@@ -0,0 +1,7 @@
+import { Ledger } from "./bytes.js";
+export declare function page_ledger(): Ledger | null;
+/** One island's line of the ledger (by its entry), and the islands it shares code with. */
+export declare function island_ledger(entry: string | null | undefined): {
+  row: Ledger["rows"][number];
+  shares_with: string[];
+} | null;

package/dist/devtools/ledger-dom.js

@@ -0,0 +1,151 @@
+import { byte_ledger } from "./bytes.js";
+import { all_regions, region_name } from "./regions.js";
+import { dynamic_imports, static_imports } from "@ogygia/core/insights";
+import { ISLAND_GRAPH_ATTR, decode_island_graph, tool_fetch, tool_made } from "@ogygia/core/internal/instruments";
+// src/devtools/ledger-dom.ts
+/**
+* The byte ledger's DOM side: the page's island graph (`script[data-ogygia-graph]`, a build writes
+* it), the browser's size of every file it loaded, the regions on the page and the runtime's files
+* — handed to the pure `byte_ledger` (bytes.ts). Null off a build (the dev server writes no graph).
+* Shared by the Bytes tab and an island's detail card.
+*/
+const abs = (href) => {
+	if (!href) return null;
+	try {
+		return new URL(href, location.href).href;
+	} catch {
+		return null;
+	}
+};
+let parts = null;
+/** globals only the devtools' own code sets (the runtime sets none: it publishes `__ogygia_devtools`
+*  alone, from its own chunk, never a root) — a part carrying one is the devtools', not the page's */
+const DOCK_MARKS = [
+	"__ogygia_session",
+	"__ogygia_testing",
+	"__ogygia_region_bytes",
+	"__ogygia_region_names",
+	"__ogygia_styles",
+	"__ogygia_devtools_meta"
+];
+function runtime_parts(src) {
+	if (parts?.src !== src) {
+		parts = {
+			src,
+			read: null
+		};
+		read_parts(src).then((read) => {
+			if (parts?.src === src) parts.read = read;
+		});
+	}
+	return parts.read;
+}
+async function read_parts(src) {
+	const cache = /* @__PURE__ */ new Map();
+	const text = (u) => {
+		let t = cache.get(u);
+		if (!t) {
+			t = tool_fetch(u, { cache: "force-cache" }).then((r) => r.ok ? r.text() : "").catch(() => "");
+			cache.set(u, t);
+		}
+		return t;
+	};
+	const self = import.meta.url;
+	const roots = /* @__PURE__ */ new Map();
+	const dock = [];
+	for (const spec of dynamic_imports(await text(src))) {
+		const root = abs_from(spec, src);
+		if (!root || roots.has(root) || dock.includes(root)) continue;
+		const closure = /* @__PURE__ */ new Set([root]);
+		const queue = [root];
+		let docked = false;
+		while (queue.length && closure.size < 300) {
+			const at = queue.shift();
+			const body = await text(at);
+			if (!docked && DOCK_MARKS.some((m) => body.includes(m))) docked = true;
+			for (const s of static_imports(body)) {
+				const u = abs_from(s, at);
+				if (u && !closure.has(u)) {
+					closure.add(u);
+					queue.push(u);
+				}
+			}
+		}
+		if (docked || closure.has(self)) dock.push(root);
+		else roots.set(root, closure);
+	}
+	return {
+		roots,
+		dock
+	};
+}
+const abs_from = (spec, base) => {
+	try {
+		return new URL(spec, base).href;
+	} catch {
+		return null;
+	}
+};
+function page_ledger() {
+	if (typeof document === "undefined") return null;
+	const graph = /* @__PURE__ */ new Map();
+	for (const s of document.querySelectorAll(`script[${ISLAND_GRAPH_ATTR}]`)) for (const [entry, hrefs] of decode_island_graph(s.textContent ?? "")) {
+		const key = abs(entry);
+		if (key && !graph.has(key)) graph.set(key, hrefs.map(abs).filter((x) => !!x));
+	}
+	if (!graph.size) return null;
+	const sizes = /* @__PURE__ */ new Map();
+	for (const r of performance.getEntriesByType("resource")) {
+		if (tool_made(r)) continue;
+		const wire = r.encodedBodySize || r.transferSize || r.decodedBodySize || 0;
+		sizes.set(r.name, {
+			wire,
+			raw: r.decodedBodySize || wire
+		});
+	}
+	const islands = /* @__PURE__ */ new Map();
+	for (const r of all_regions()) {
+		const entry = abs(r.entry);
+		if (!entry) continue;
+		const g = islands.get(entry);
+		const file = abs(r.src);
+		if (g) g.count++;
+		else islands.set(entry, {
+			entry,
+			...file ? { file } : {},
+			name: region_name(r.entry),
+			kind: r.kind,
+			wake: r.wake,
+			count: 1
+		});
+	}
+	const runtime_src = abs(document.querySelector("script[data-ogygia-runtime]")?.getAttribute("src"));
+	const runtime = [runtime_src, ...[...document.querySelectorAll("link[data-ogygia-runtime-dep]")].map((l) => abs(l.getAttribute("href")))].filter((x) => !!x);
+	const rp = runtime_src ? runtime_parts(runtime_src) : null;
+	if (rp) {
+		const island_files = /* @__PURE__ */ new Set();
+		for (const list of graph.values()) for (const u of list) island_files.add(u);
+		for (const i of islands.values()) island_files.add(i.file ?? i.entry);
+		for (const [root, closure] of rp.roots) if (sizes.has(root)) {
+			for (const u of closure) if (sizes.has(u) && !island_files.has(u) && !runtime.includes(u)) runtime.push(u);
+		}
+	}
+	return byte_ledger([...islands.values()], graph, (u) => sizes.get(u) ?? null, runtime);
+}
+/** One island's line of the ledger (by its entry), and the islands it shares code with. */
+function island_ledger(entry) {
+	const l = page_ledger();
+	const key = abs(entry);
+	if (!l || !key) return null;
+	const row = l.rows.find((r) => r.entry === key);
+	if (!row) return null;
+	const with_ = /* @__PURE__ */ new Set();
+	for (const s of l.shared) if (s.users.includes(row.name)) {
+		for (const u of s.users) if (u !== row.name) with_.add(u);
+	}
+	return {
+		row,
+		shares_with: [...with_]
+	};
+}
+export { island_ledger, page_ledger };

package/dist/devtools/leftovers.d.ts

@@ -0,0 +1,77 @@
+export interface LeftoverReg {
+  kind: "interval" | "listener";
+  /** a listener's target and event */
+  target?: "window" | "document";
+  type?: string;
+  capture?: boolean;
+  /** the files of the first calls above the registration (its caller first) */
+  frames: string[];
+  /** when it was made (performance.now) */
+  t: number;
+  /** an interval's runs so far, and the last one */
+  fires: number;
+  last?: number;
+}
+/** One island entry as this tab saw it: where its code lives, its instances, when one last left. */
+export interface LeftoverIsland {
+  entry: string;
+  /** its file locations (the entry, and the content-hashed file a build loads) as absolute URLs */
+  urls: string[];
+  /** when each instance seen alive now started (performance.now) */
+  live: number[];
+  /** when its first instance started, and when one last left */
+  first: number;
+  gone?: number;
+}
+/** What the report says: per island, what it left behind. */
+export interface Leftover {
+  name: string;
+  entry: string;
+  intervals: number;
+  /** `window 'resize'` … */
+  listeners: string[];
+  /** the intervals' runs since they were set, and how long ago the last one ran */
+  fires: number;
+  last_ago?: number;
+}
+/** The file URL of each stack line (Chrome `at f (url:1:2)` / `at url:1:2`, Firefox and Safari
+ *  `f@url:1:2`), without its position or query. No regex: this runs on every watched registration. */
+export declare function stack_files(stack: string): string[];
+/** Watch intervals and the global listeners. Once per page; a no-op off the browser. */
+export declare function watch_leftovers(): void;
+export interface ScrollReg {
+  type: string;
+  /** `window`, `document`, or the element briefly (`div.scroller`) */
+  on: string;
+  /** `passive: false` asked for on purpose */
+  forced: boolean;
+  frames: string[];
+}
+/** The window `unload` listeners still attached, as scroll registrations (the same owner rule). */
+export declare function unload_listeners(): ScrollReg[];
+/** The scroll-holding listeners still attached (an element's, while it is in the page). */
+export declare function scroll_listeners(): ScrollReg[];
+/** Each one's owner, the island whose file is the nearest of its callers (as owned_leftovers
+ *  decides), else the first caller's file. PURE. */
+export declare function owned_scroll_listeners(regs: ScrollReg[], isls: LeftoverIsland[], name_of: (entry: string) => string): {
+  owner: string;
+  type: string;
+  on: string;
+  forced: boolean;
+}[];
+/** An island instance starts (its hydrate begins): `entry` and its file locations. */
+export declare function leftover_island_seen(el: Element, entry: string, urls: string[]): void;
+/** An island instance left the page (its region disconnected and its app was disposed). */
+export declare function leftover_island_gone(el: Element, entry: string): void;
+/** Everything watched, as it stands now (for `owned_leftovers`). */
+export declare function leftover_state(): {
+  regs: LeftoverReg[];
+  islands: LeftoverIsland[];
+};
+/**
+ * Per island, what it left behind (PURE). A registration's owner is the island whose file is one of
+ * its first two callers: by location (a build's file, the entry), else by name (dev serves the
+ * component's own `.svelte` file, named as the island is). Left behind: an instance of that island
+ * was alive before it was made, and every instance alive now started after it.
+ */
+export declare function owned_leftovers(regs: LeftoverReg[], isls: LeftoverIsland[], name_of: (entry: string) => string, now: number): Leftover[];