@ogygia/core 0.12.2 → 0.13.0

package/dist/runtime/router.js

@@ -1,8 +1,16 @@
+import { import_again } from "./import-again.js";
 import { kit_hydrates_page } from "./kit-boot.js";
+import { create_navigation } from "./navigation.js";
 import { slots } from "./slots.js";
 import { publish_nav } from "./nav-handle.js";
 import { nearest_attr } from "./nearest-attr.js";
 import { record_server_body } from "./ownership.js";
+import { runtime_session } from "./session.js";
+import { OgygiaError, warn } from "../messages/core.js";
+import { report_thrown } from "../report-thrown.js";
+import { download } from "../policies.js";
+import { watch_router } from "./rules.js";
+import { STALE, flights } from "@ogygia/machine";
 // src/runtime/router.ts
 /**
 * Minimal SPA router for ogygia (Astro's ClientRouter equivalent).
@@ -17,6 +25,7 @@ import { record_server_body } from "./ownership.js";
 * merge, body reconcile, seeds, a11y) is ./router-nav.ts, loaded on the first prefetch or
 * intercepted click. A visitor who never leaves the page never downloads it.
 */
+const RULES = import.meta.env?.DEV || (typeof __OGYGIA_RULES__ !== "undefined" ? __OGYGIA_RULES__ : false);
 const WS = /\s+/;
 /**
 * The `<a>` a pointer event is about — through SHADOW ROOTS. A click inside a web component's
@@ -133,48 +142,159 @@ function jump_to_hash(hash) {
 		html_el.style.scrollBehavior = prev;
 	}
 }
-/** Run `fn` when the browser is idle (bounded), else soon. */
-function on_idle(fn, timeout = 1e3) {
-	if (typeof requestIdleCallback === "function") requestIdleCallback(fn, { timeout });
-	else setTimeout(fn, 50);
+/**
+* THE ROUTER'S HISTORY, one record (#310). The router keeps the visitor's entries it made, each with
+* its address and where its page was left, and reads the rest from it: the page on screen
+* (`current_url`, its document key), the scroll a back or forward step puts back. `history.state`
+* holds only an entry's id. It once kept the same facts in several places (the address bar written
+* before the fetch, `current_url`, `doc_key`, a scroll saved on push only), and they drifted.
+*
+* - An entry is written when a page goes in (the navigation's commit), never before its fetch: a
+*   download or a 204 adds none (#297), and the address bar is the page on screen.
+* - Leaving an entry keeps where its page was, on every move: a click, a back or forward step (#270).
+* - An id this document never made (its state names another document's entry) is not this
+*   document's to show: the browser loads it whole. An entry with no id (the browser's own fragment
+*   jump, an app's own `pushState`) is taken over when the router meets it.
+*/
+/** The state of the entry the browser is on, named by `id`: the id goes beside what the app (or
+*  Kit) keeps there, never over it (#375). */
+function named(id) {
+	const kept = history.state;
+	return kept !== null && typeof kept === "object" ? {
+		...kept,
+		ogygia: id
+	} : { ogygia: id };
+}
+var RouterHistory = class {
+	/** Names this document's entries apart from another document's (a reload's, say). */
+	#doc = Math.random().toString(36).slice(2, 10);
+	#n = 0;
+	#entries = /* @__PURE__ */ new Map();
+	#current = null;
+	/** The entry of the page on screen. */
+	get current() {
+		return this.#current ??= this.#add(new URL(location.href));
+	}
+	/** Takes over the entry the browser is on as the router starts: its state names it now. */
+	start() {
+		replace_state(named(this.current.id));
+	}
+	/** The entry a history state names: this model's, `'foreign'` (another document's), or null
+	*  (no id: an entry the browser or the app made). */
+	find(state) {
+		const id = state?.ogygia;
+		if (typeof id !== "string") return null;
+		return this.#entries.get(id) ?? (id.startsWith(this.#doc + ".") ? null : "foreign");
+	}
+	/** The page on screen is being left: keep where it is. */
+	leave() {
+		const entry = this.current;
+		entry.scroll = {
+			x: scrollX,
+			y: scrollY
+		};
+		const active = typeof document === "undefined" ? null : document.activeElement;
+		entry.focus = active && active !== document.body && active.id ? active.id : null;
+	}
+	/** A page goes in at `url` (the browser's entry is written now). `push`: a new entry after the
+	*  one left; `replace`: the current one at a new address; `pop`: `to`, the entry a back or
+	*  forward step is on. */
+	commit(url, move, to) {
+		if (move === "push") {
+			this.leave();
+			const entry = this.#add(url);
+			push_state({ ogygia: entry.id }, url.href);
+			return this.#current = entry;
+		}
+		const entry = move === "pop" && to ? to : this.current;
+		entry.url = url;
+		this.#current = entry;
+		if (location.href !== url.href || history.state?.ogygia !== entry.id) replace_state(named(entry.id), url.href);
+		return entry;
+	}
+	/** The entry the browser stepped to, which no id names: this model's from now on. */
+	adopt(url) {
+		const entry = this.#add(url);
+		replace_state(named(entry.id));
+		return entry;
+	}
+	#add(url) {
+		const entry = {
+			id: this.#doc + "." + ++this.#n,
+			url,
+			scroll: null,
+			focus: null
+		};
+		this.#entries.set(entry.id, entry);
+		return entry;
+	}
+};
+/** Run `fn` once, when the browser is idle or after `cap` ms, whichever is first, unless `page` (a
+*  page visit's scope) ends first. */
+function on_idle(page, fn, cap = 1e3) {
+	const run = () => {
+		idle();
+		capped();
+		fn();
+	};
+	const idle = page.timeout(run, "idle");
+	const capped = page.timeout(run, cap);
 }
-let nav_promise = null;
 let loaded_nav = null;
+const load_nav = flights({
+	name: "navigation",
+	run: import_again(() => import("./router-nav.js")),
+	retry: download
+});
+/** (Never STALE: nothing drops the navigation's load; a caller treats it as one that failed.) */
 function nav() {
-	slots.router_link ??= {
-		document_key,
-		jump_to_hash,
-		push_state,
-		replace_state
-	};
-	if (!nav_promise) nav_promise = import("./router-nav.js").then((m) => loaded_nav = m, (err) => {
-		nav_promise = null;
-		throw err;
-	});
-	return nav_promise;
+	slots.router_link ??= { jump_to_hash };
+	return load_nav.get().then((m) => m === STALE ? m : loaded_nav = m);
 }
 var SpaRouter = class {
 	#started = false;
 	#before_hooks = /* @__PURE__ */ new Set();
 	#after_hooks = /* @__PURE__ */ new Set();
-	/** href of the navigation in flight (set before the fetch, cleared when applied or aborted) */
-	nav_target = null;
-	/** The in-flight navigation's cancel handle: router-nav bumps `nav_gen` and sets `nav_abort` for
-	*  each navigation it starts, and stops at its next step once `nav_gen` moved on. */
-	nav_gen = 0;
-	nav_abort = null;
-	#viewport_io = null;
-	#viewport_seen = /* @__PURE__ */ new WeakSet();
-	/** pathname+search of the document currently in the DOM (hash ignored). */
-	doc_key = "";
 	/**
-	* Full URL of the document currently displayed in the DOM. `navigate()` uses this as its `from`
+	* THE NAVIGATION, one machine (./navigation.ts): idle, claimed (the click, while the navigation
+	* chunk loads), loading (its fetch through its swap), settling (swapped: the last steps run). A
+	* new click is a new visit, so whatever the old one still had in flight sees it is not current
+	* (`nav.now !== mine`) and stops, and its fetch is aborted. It was three fields kept by hand; two
+	* clicks during the first chunk load once held the same generation and the last one was lost.
+	*/
+	nav = create_navigation();
+	/** href of the router's navigation in flight (claimed or loading; cleared once it applied,
+	*  ended, or went to the browser: `hand_off`) */
+	get nav_target() {
+		const s = this.nav.now;
+		return s.kind === "claimed" || s.kind === "loading" ? s.href : null;
+	}
+	/**
+	* The anchors whose click the router took (prevented, and navigated), and the address it took each
+	* to. A link component clicks its inner `<a>` again after the visitor's click, and that second
+	* click may never reach the router's `document` listener: a click event that is not composed
+	* stays in the component's shadow tree, and an anchor the swap took out of the page is in no
+	* document. The browser then followed the link itself, a full load after a click the router had
+	* already prevented (#263). So an anchor the router took a click from listens itself, for the
+	* clicks `document` will not hear (`#on_anchor_click`).
+	*/
+	#taken = /* @__PURE__ */ new WeakMap();
+	/** The visitor's history, as the router keeps it (`RouterHistory`): the rest is read from it. */
+	history = new RouterHistory();
+	/**
+	* Full URL of the page on screen: its history entry's. `navigate()` uses this as its `from`
 	* instead of `location.href`, because on a `popstate` (back/forward) the browser has ALREADY
 	* changed `location` to the target — so `location.href` would equal the target and the
 	* same-document guard would wrongly bail into the hash-only branch, never swapping the body
 	* (browser back left the old page's DOM in place). POP-FROM.
 	*/
-	current_url = null;
+	get current_url() {
+		return this.history.current.url;
+	}
+	/** pathname+search of the page on screen (hash ignored). */
+	get doc_key() {
+		return document_key(this.current_url);
+	}
 	beforeNavigate(fn) {
 		this.#before_hooks.add(fn);
 		return () => this.#before_hooks.delete(fn);
@@ -188,7 +308,9 @@ var SpaRouter = class {
 				type: "enter",
 				willUnload: false
 			});
-		} catch {}
+		} catch (error) {
+			report_thrown(error);
+		}
 		return () => this.#after_hooks.delete(fn);
 	}
 	/**
@@ -199,62 +321,80 @@ var SpaRouter = class {
 	* swapping left the URL on the old page and `/plain` in the DOM).
 	*/
 	supersede() {
-		if (this.nav_target === null && this.nav_abort === null) return;
-		this.nav_gen++;
-		this.nav_abort?.abort();
-		this.nav_abort = null;
-		this.nav_target = null;
+		if (this.nav.now.kind !== "idle") this.nav.go("idle");
+	}
+	/**
+	* GIVE `visit`'s NAVIGATION TO THE BROWSER — a page the router will not render (a csr=true Kit
+	* page, a page that is not ogygia's, another build), or one it could not fetch or load its code
+	* for: a document navigation to `url`, from the document on screen (`from`).
+	*
+	* It ENDS the visit, on every path: from here on the navigation is the browser's, never the
+	* router's in flight. The browser may well keep this page on screen (a file download, a 204, a
+	* body it does not show), and then nothing else ends it: left `loading`, every later click on the
+	* link joined it and was swallowed (#266). A visit already left (a newer click took over, or back
+	* to the page on screen) hands nothing off: the browser never goes where the visitor no longer is.
+	*
+	* The router writes an entry only when a page goes in, so a click handed off has none: the
+	* browser's navigation is a new entry of its own, and one it keeps the page on screen for adds
+	* none (#297). A back or forward step is already on its entry, and a refresh on the one on
+	* screen: the browser's navigation REPLACES it, so its document holds the entry alone, never
+	* shares it with the router's page (back from a csr=true page then loads the router page, #259).
+	* So does a commit that failed after it wrote the entry (the address is already `url`).
+	*
+	* `error`: the navigation failed part way (its devalue did not load, its swap threw, #276). It
+	* is said (the page's error handler, as an uncaught throw would be), and the browser loads the
+	* page whole.
+	*/
+	hand_off(url, visit, move, error) {
+		if (this.nav.now !== visit) return;
+		this.nav.go("idle");
+		if (error !== void 0) report_thrown(error);
+		if (move === "push" && location.href !== url.href) location.assign(url.href);
+		else location.replace(url.href);
 	}
 	bust_page_cache() {
 		loaded_nav?.bust_page_cache();
 	}
-	_page_cache_size() {
-		return loaded_nav?.page_cache_size() ?? 0;
-	}
+	/** The page at `href`, or `null` when there is none to have: the fetch failed (./router-nav.ts
+	*  `fetch_page`), or the navigation code itself did not load. The prefetches (a hover, a
+	*  viewport link, `preloadData`) start it and never wait on it: a rejection here was uncaught. */
 	fetch_page(href, signal, purpose) {
-		return nav().then((n) => n.fetch_page(href, signal, purpose));
+		return nav().then((n) => n === STALE ? null : n.fetch_page(href, signal, purpose), () => null);
 	}
 	async navigate(url, opts = {}) {
 		const { push = true, type = "link", replace = false } = opts;
-		const from = this.current_url ?? new URL(location.href);
+		const from = this.current_url;
+		const move = opts.pop ? "pop" : push && !replace ? "push" : "replace";
 		if (same_document(url, from) && !replace) {
 			if (!this.run_before(from, url, type)) return;
 			this.supersede();
-			if (push && url.href !== location.href) push_state({
-				...history.state,
-				ogygia: true
-			}, url.href);
-			else if (url.href !== location.href) replace_state({
-				...history.state,
-				ogygia: true
-			}, url.href);
+			if (url.href !== location.href) this.history.commit(url, move);
 			jump_to_hash(url.hash);
-			this.current_url = url;
 			this.run_after(from, url, type);
 			return;
 		}
-		this.nav_target = url.href;
-		const gen = this.nav_gen;
+		if (!this.run_before(from, url, type)) return;
+		this.nav.go("claimed", { href: url.href });
+		const mine = this.nav.now;
 		let n;
 		try {
 			n = await nav();
 		} catch {
-			if (this.nav_target === url.href) this.nav_target = null;
-			location.href = url.href;
-			return;
+			return this.hand_off(url, mine, move);
 		}
-		if (gen !== this.nav_gen) return;
-		return n.navigate(this, url, from, opts);
+		if (n === STALE) return this.hand_off(url, mine, move);
+		if (this.nav.now !== mine) return;
+		return n.navigate(this, url, from, opts, mine);
 	}
 	goto(url, opts = {}) {
 		const target = new URL(url, location.href);
-		if (target.protocol !== "http:" && target.protocol !== "https:") throw new Error("[ogygia] goto() only supports http(s) URLs");
+		if (target.protocol !== "http:" && target.protocol !== "https:") throw new OgygiaError("goto_not_http");
 		if (target.origin !== location.origin) {
 			if (opts.external) {
 				location.assign(target.href);
 				return Promise.resolve();
 			}
-			throw new Error("[ogygia] goto() only supports same-origin URLs (pass { external: true } to leave)");
+			throw new OgygiaError("goto_cross_origin");
 		}
 		return this.navigate(target, {
 			push: !opts.replaceState,
@@ -263,7 +403,7 @@ var SpaRouter = class {
 		});
 	}
 	invalidateAll() {
-		return nav().then((n) => n.invalidate_all());
+		return nav().then((n) => n === STALE ? void 0 : n.invalidate_all(this.current_url));
 	}
 	invalidate() {
 		return this.invalidateAll();
@@ -286,75 +426,110 @@ var SpaRouter = class {
 		return Promise.resolve();
 	}
 	disableScrollHandling() {
-		if (typeof console !== "undefined") console.warn("[ogygia] disableScrollHandling() is a no-op in the islands SPA router.");
+		if (typeof console !== "undefined") warn("scroll_handling_noop");
 	}
 	pushState() {
-		console.warn("[ogygia] pushState() shallow routing is not supported; use goto().");
+		warn("shallow_routing_unsupported", { method: "pushState" });
 	}
 	replaceState() {
-		console.warn("[ogygia] replaceState() shallow routing is not supported; use goto().");
+		warn("shallow_routing_unsupported", { method: "replaceState" });
 	}
 	start() {
 		if (this.#started || typeof document === "undefined") return;
 		if (!document.querySelector("meta[name=\"ogygia-router\"]")) return;
 		if (kit_hydrates_page()) return;
 		this.#started = true;
-		this.doc_key = document_key(new URL(location.href));
-		this.current_url = new URL(location.href);
+		this.history.start();
+		if (RULES) watch_router(this);
 		const body = document.body;
 		if (body) record_server_body(body, body, Array.from(body.childNodes));
-		document.addEventListener("click", (event) => {
-			const anchor = anchor_of(event);
-			const url = this.#should_intercept(event, anchor);
-			if (!url) return;
-			if (this.nav_target === url.href) {
-				event.preventDefault();
-				return;
-			}
-			if (same_document(url, new URL(location.href))) {
-				const kind = same_document_link(url, new URL(location.href), this.nav_target);
-				if (kind === "hash") {
-					if (!hash_target_exists(url.hash)) {
-						event.preventDefault();
-						if (location.hash !== url.hash) {
-							push_state(history.state || {}, url.href);
-							window.dispatchEvent(new HashChangeEvent("hashchange", {
-								oldURL: location.href,
-								newURL: url.href
-							}));
-						}
-					}
-					return;
-				}
-				event.preventDefault();
-				if (kind === "refresh") this.navigate(url, {
-					push: false,
-					replace: true
-				});
-				return;
-			}
-			event.preventDefault();
-			this.navigate(url, { push: true });
-		});
+		document.addEventListener("click", (event) => this.#on_click(event, anchor_of(event)));
 		this.#install_prefetch();
 		window.addEventListener("popstate", () => {
 			const url = new URL(location.href);
+			const found = this.history.find(history.state);
+			if (found === "foreign") {
+				this.supersede();
+				location.reload();
+				return;
+			}
+			this.history.leave();
+			const entry = found ?? this.history.adopt(url);
 			if (document_key(url) === this.doc_key) {
 				this.supersede();
-				jump_to_hash(url.hash);
+				this.history.commit(url, "pop", entry);
 				return;
 			}
-			const pop_scroll = history.state?.scroll || null;
 			this.navigate(url, {
 				push: false,
-				pop_scroll,
+				pop: entry,
 				type: "popstate"
 			});
 		});
-		replace_state({
-			...history.state,
-			ogygia: true
-		});
+	}
+	/** A click on `anchor`: the router's, or the browser's. A click it prevents always ends in a
+	*  navigation, the one it starts or the one it joins. */
+	#on_click(event, anchor) {
+		const url = this.#should_intercept(event, anchor);
+		if (!url || !anchor) return;
+		if (this.#joins(event, anchor, url)) {
+			event.preventDefault();
+			return;
+		}
+		if (same_document(url, new URL(location.href))) {
+			const kind = same_document_link(url, new URL(location.href), this.nav_target);
+			if (kind === "hash") {
+				if (!hash_target_exists(url.hash)) {
+					event.preventDefault();
+					if (location.hash !== url.hash) {
+						const old = location.href;
+						this.history.commit(url, "push");
+						window.dispatchEvent(new HashChangeEvent("hashchange", {
+							oldURL: old,
+							newURL: url.href
+						}));
+					}
+				}
+				return;
+			}
+			event.preventDefault();
+			this.#take(anchor, url);
+			if (kind === "refresh") this.navigate(url, {
+				push: false,
+				replace: true
+			});
+			return;
+		}
+		event.preventDefault();
+		this.#take(anchor, url);
+		this.navigate(url, { push: true });
+	}
+	/**
+	* Does this click join a navigation the router already has? Its own in flight to the click's
+	* address (a double click, or a link component re-dispatching the visitor's click on its inner
+	* `<a>`): never one it gave the browser (`hand_off` ends that visit), so a link to a download is
+	* a new navigation each time; or
+	* the one this very anchor started, to the page now on screen, when the click is a re-dispatch
+	* (untrusted: the component's, never the visitor's — a visitor's click on a link to the page they
+	* are on refreshes it).
+	*/
+	#joins(event, anchor, url) {
+		if (this.nav_target === url.href) return true;
+		return !event.isTrusted && this.#taken.get(anchor) === url.href && same_document(url, this.current_url);
+	}
+	/** The router took a click on `anchor` to `url`: from now on the anchor hears its own clicks too. */
+	#take(anchor, url) {
+		if (!this.#taken.has(anchor)) anchor.addEventListener("click", (event) => this.#on_anchor_click(event, anchor));
+		this.#taken.set(anchor, url.href);
+	}
+	/**
+	* A click on an anchor the router took a click from, heard on the anchor itself. One that reaches
+	* `document` is the document listener's (a component on the way may still prevent it); one that
+	* cannot — not composed and inside a shadow tree, or on an anchor that is in no document — is
+	* handled here, the same way.
+	*/
+	#on_anchor_click(event, anchor) {
+		if (!(anchor.isConnected && (event.composed || anchor.getRootNode() === document))) this.#on_click(event, anchor);
 	}
 	#should_intercept(event, anchor) {
 		if (event.defaultPrevented) return false;
@@ -381,7 +556,9 @@ var SpaRouter = class {
 		};
 		for (const fn of this.#before_hooks) try {
 			fn(nav);
-		} catch {}
+		} catch (error) {
+			report_thrown(error);
+		}
 		return !cancelled;
 	}
 	run_after(from, to, type) {
@@ -392,7 +569,9 @@ var SpaRouter = class {
 				type,
 				willUnload: false
 			});
-		} catch {}
+		} catch (error) {
+			report_thrown(error);
+		}
 	}
 	#install_prefetch() {
 		document.addEventListener("mouseover", (event) => {
@@ -407,34 +586,27 @@ var SpaRouter = class {
 		document.addEventListener("touchstart", on_press, { passive: true });
 		this.scan_preload_links();
 	}
-	/** After start + every navigation: drop detached IO targets, then re-observe the live body. */
-	#reset_viewport_io() {
-		this.#viewport_io?.disconnect();
-		this.#viewport_seen = /* @__PURE__ */ new WeakSet();
-		this.#viewport_io = new IntersectionObserver((entries) => {
-			for (const e of entries) if (e.isIntersecting) {
-				this.#viewport_io.unobserve(e.target);
-				this.#warm_anchor(e.target);
-			}
-		}, { rootMargin: "0px" });
-	}
 	/**
 	* After start + every navigation, in IDLE: eager links warm now; viewport links get observed.
 	* Only anchors under a preload-marked element are read — an unmarked anchor has no trigger. Idle,
 	* because the scan competes with the freshly swapped page's own islands for the main thread and
-	* a warm is speculation by definition.
+	* a warm is speculation by definition. The scan and its observer are the page visit's
+	* (./session.ts `PageVisit`): the next page's swap disconnects it, so the anchors of a page left
+	* behind are never held, and a scan still waiting for idle time when its page is left never runs.
 	*/
 	scan_preload_links() {
-		on_idle(() => {
-			this.#reset_viewport_io();
-			if (!this.#viewport_io) return;
+		const page = runtime_session.visit.scope;
+		on_idle(page, () => {
+			const io = page.watch(new IntersectionObserver((entries) => {
+				for (const e of entries) if (e.isIntersecting) {
+					io.unobserve(e.target);
+					this.#warm_anchor(e.target);
+				}
+			}, { rootMargin: "0px" }));
 			for (const anchor of Array.from(document.querySelectorAll(PRELOAD_MARKED_ANCHORS))) {
 				const rank = this.#preload_rank(anchor);
 				if (rank === PRELOAD_RANK.eager) this.#warm_anchor(anchor);
-				else if (rank === PRELOAD_RANK.viewport && !this.#viewport_seen.has(anchor)) {
-					this.#viewport_seen.add(anchor);
-					this.#viewport_io.observe(anchor);
-				}
+				else if (rank === PRELOAD_RANK.viewport) io.observe(anchor);
 			}
 		});
 	}
@@ -493,10 +665,6 @@ function afterNavigate(fn) {
 function bust_page_cache() {
 	spa.bust_page_cache();
 }
-/** Test helper — current warmed entry count. */
-function _page_cache_size() {
-	return spa._page_cache_size();
-}
 /**
 * Programmatic same-origin navigation. Mirrors Kit's `goto()` subset.
 * @param url - Absolute or relative URL (http(s) only).
@@ -593,4 +761,4 @@ function install() {
 	if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", start, { once: true });
 	else start();
 }
-export { SpaRouter, _page_cache_size, afterNavigate, anchor_of, beforeNavigate, bust_page_cache, disableScrollHandling, document_key, goto, install, invalidate, invalidateAll, jump_to_hash, preloadCode, preloadData, pushState, push_state, reload_opt_out, replaceState, replace_state, same_document, same_document_link, startRouter };
+export { RouterHistory, SpaRouter, afterNavigate, anchor_of, beforeNavigate, bust_page_cache, disableScrollHandling, document_key, goto, install, invalidate, invalidateAll, jump_to_hash, preloadCode, preloadData, pushState, push_state, reload_opt_out, replaceState, replace_state, same_document, same_document_link, startRouter };

package/dist/runtime/rules.d.ts

@@ -0,0 +1,35 @@
+import { Rules } from "../rules.js";
+type RuntimeRule = "rule_region_mounted_twice" | "rule_address_bar_drift" | "rule_old_page_open" | "rule_failure_uncoded" | "rule_parse_upgraded";
+/** The runtime's rules. */
+export declare const runtime_rules: Rules<RuntimeRule>;
+/** A region element mounted its island. */
+export declare function note_mount(region: Element): void;
+/** A region element let its island go. */
+export declare function note_unmount(region: Element): void;
+type Visit = {
+  readonly scope: {
+    readonly closed: boolean;
+  };
+};
+/** A page visit was made (`current`: it is the page on screen's now). */
+export declare function note_visit(visit: Visit, is_current: boolean): void;
+/** What the rule reads of the router: its navigation, and its history model's page on screen. */
+interface RouterView {
+  readonly nav: {
+    readonly now: {
+      readonly kind: string;
+    };
+  };
+  readonly history: {
+    readonly current: {
+      readonly id: string;
+      readonly url: URL;
+    };
+  };
+}
+/** The router started: its history model is checked against the address bar. */
+export declare function watch_router(router: RouterView): void;
+/** Rules on: `globalThis.__ogygia_rules()` gives what is broken now (for e2e); in dev they are also
+ *  checked after machine moves, and what broke is said with its code. */
+export declare function install_rules(dev: boolean): void;
+export {};