@ogygia/core 0.12.3 → 0.13.0

package/dist/runtime/core.js

@@ -1,31 +1,43 @@
 import { frameAddress } from "../frame.js";
+import { import_again, is_failed_import, on_reload_needed } from "./import-again.js";
 import { kit_hydrates_page } from "./kit-boot.js";
 import { init_shadow_registries, parse_region_html, restore_adopt_sheets, restore_markup } from "./parse-html.js";
 import { mark_region_changed, region_changed, unwatch_region, watch_region } from "./drift-watch.js";
 import { runtime_session } from "./session.js";
-import { RegionAnswerRefused, capability_expired, deny_of, is_allowed_region_endpoint, is_document_answer, is_redirected_answer, is_same_origin_response, island_module_url, renewal_url } from "./region-endpoint-url.js";
+import { RegionAnswerRefused, capability_expired, is_allowed_region_endpoint, island_module_url } from "./region-endpoint-url.js";
+import { fetch_hole } from "./hole-fetch.js";
 import { import_entry, island_entry_of, on_entry_fallback, pin_build_map, pin_region_urls } from "./entry-locations.js";
+import { load_devalue, needs_devalue } from "./devalue-lane.js";
 import { is_awake, is_deferred, is_frozen, ours_on_kit_document, phase2_hydrate_schedule, region_hydrate_schedule, region_schedule } from "./region-attrs.js";
 import { slots } from "./slots.js";
-import { KEEP_FALLBACK_HTML } from "../keep-fallback-marker.js";
+import { create_answer, create_hole, create_live, create_paint, create_wake } from "./region-machines.js";
+import "../keep-fallback-marker.js";
+import { download, region_fetch } from "../policies.js";
+import { install_rules, note_mount, note_unmount } from "./rules.js";
 import { PAGE_FACTS_SELECTOR } from "../page-facts-script.js";
 import { link_boot } from "./boot-link.js";
 import { background_start, hydrate_settled, hydrate_started, hydrate_turn, register_region, unregister_region, yield_task } from "./schedule.js";
 import { once_visible } from "./observe.js";
+import { sheet_of, use_sheets } from "./region-sheets.js";
 import { preload_island_graph } from "./island-graph-preload.js";
-import { fetch_priority_of, load_slot, viewport_class } from "./load-scheduler.js";
+import { LoadSlot, fetch_priority_of, viewport_class } from "./load-scheduler.js";
 import { connected_regions } from "./connected.js";
 import { restore_props_sidecar } from "./sidecar.js";
 import { hole_facts_of } from "./hole-facts.js";
-import { beacon_entry_fallback, beacon_failed, beacon_hole_answered, beacon_hole_failed, beacon_hole_fetched, beacon_hydrated, beacon_warning, beacon_watch } from "./beacon.js";
+import { beacon_entry_fallback, beacon_failed, beacon_hole_answered, beacon_hole_failed, beacon_hydrated, beacon_warning, beacon_watch } from "./beacon.js";
 import { on_svelte_warning, set_hydrating, tap_svelte_warnings } from "./svelte-warnings.js";
 import { emit } from "../events/bus.js";
 import { ingest_server_events, install_window_sink } from "../events/sinks.js";
 import { CLIENT_PLUGINS, boot_client_plugins, client_region_mount, client_region_unmount } from "./client-plugins.js";
+import { OgygiaError, line, warn } from "../messages/core.js";
+import { report_restores } from "./restore-report.js";
+import { disclose_version } from "./disclose-version.js";
+import { STALE, backoffAfter, flights, mailbox, scope } from "@ogygia/machine";
 import { FRAMES } from "virtual:ogygia/runtime-flags";
 // src/runtime/core.ts
 const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
 const BEACON = typeof __OGYGIA_BEACON__ !== "undefined" ? __OGYGIA_BEACON__ : true;
+const RULES = import.meta.env?.DEV || (typeof __OGYGIA_RULES__ !== "undefined" ? __OGYGIA_RULES__ : false);
 /** Above this many characters an island keeps no server copy (its hydration falls back to
 *  Svelte's own recovery on a mismatch) — a bound on memory, not a behaviour anyone tunes. */
 const SSR_SNAPSHOT_MAX = 1 << 19;
@@ -33,9 +45,6 @@ const SSR_SNAPSHOT_MAX = 1 << 19;
 *  is still disconnected — nothing has upgraded it — so the island repairs against its true server bytes
 *  instead of a DOM a swapped-in foreign runtime may have already mutated. See region_fragment. */
 const PRISTINE_SSR = Symbol("ogygia.pristine-ssr");
-/** A dynamic-import failure of the island ENTRY (network/stale), not a hydration throw. The browser
-*  message is `Failed to fetch dynamically imported module: <url>` across engines. */
-const ENTRY_FETCH_FAILED_RE = /failed to fetch dynamically imported module|error loading dynamically imported module/i;
 const CSS_ASSET_HREF_RE = /\.css(\?|$)/;
 /** The island's server markup to hydrate against later (#ssr_html), or `null` when there is
 *  nothing worth keeping: no children, or more than SSR_SNAPSHOT_MAX characters. */
@@ -56,7 +65,6 @@ function fragment_markup(frag) {
 	frag.append(...Array.from(box.childNodes));
 	return html.length > SSR_SNAPSHOT_MAX ? null : html;
 }
-const HOLE_WITHOUT_ADDRESS_WARNING = "[ogygia] deferred region %s was rendered in the browser with no server-minted address, and the document records none for it (a client-side navigation mounted it, or its props differ from the server render) — its fallback stands. A hole is server HTML: render it on the server.";
 /** Read the identity fields devtools events correlate on, off a region element. Cheap — attributes
 *  already in hand. Only ever called from behind an `if (DEVTOOLS)` guard, so it costs nothing off. */
 function dt_ids(el) {
@@ -69,17 +77,47 @@ function dt_ids(el) {
 function now_ms() {
 	return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
 }
-let core_promise = null;
 let loaded_core = null;
-function hydrate_core() {
-	if (!core_promise) core_promise = yield_task().then(() => import("./hydrate-core.js")).then((m) => loaded_core = m);
-	return core_promise;
-}
+const import_core = import_again(() => import("./hydrate-core.js"));
+const hydrate_core = flights({
+	name: "hydrate core",
+	run: () => yield_task().then(import_core).then((m) => loaded_core = m),
+	retry: download
+});
 /** An answer just went in carrying the page facts it rendered with (server/render-page.ts): once
 *  islands are awake (the hydrate core loaded), they join the page store NOW, so a KEPT island reading
 *  those keys shows the new values; before any island woke, the first hydrate absorbs them. */
 function absorb_page_facts_now() {
-	if (runtime_session.page_facts.length) loaded_core?.seed_page_once();
+	if (runtime_session.visit.facts.length && loaded_core) load_devalue().then(() => loaded_core?.seed_page_once(), () => {});
+}
+/** devalue, when this wake's reads need it (./devalue-lane.ts): a devalue-lane script in the
+*  document (a props sidecar, the page seed) or page facts an answer queued. Started beside the
+*  hydrate core, so it adds no hop; a page of JSON-lane scripts never downloads it. */
+function devalue_for_wake() {
+	if (runtime_session.visit.facts.length || document_needs_devalue()) return load_devalue();
+}
+/**
+* The document's `needs_devalue` answer (null: ask). One query of the whole document, not one per
+* wake (that was islands × the page's elements). Asked again only after markup came in: a region
+* connecting (every later render root, a hole answer, a router document, a fragment, carries its
+* sidecars beside its regions), a fetched region's HTML parsed, a router swap. A yes stays yes: devalue
+* is loading from then on.
+*/
+let doc_needs_devalue = null;
+let devalue_swap_armed = false;
+function document_needs_devalue() {
+	if (doc_needs_devalue === null) {
+		if (!devalue_swap_armed) {
+			devalue_swap_armed = true;
+			document.addEventListener("og:after-swap", devalue_lane_stale);
+		}
+		doc_needs_devalue = needs_devalue(document);
+	}
+	return doc_needs_devalue;
+}
+/** New markup may hold a devalue-lane script: the next wake asks the document again. */
+function devalue_lane_stale() {
+	if (doc_needs_devalue === false) doc_needs_devalue = null;
 }
 /** What counts as intent for an ON-DEMAND hole (`render: 'deferred'` + `fetch: 'interaction'`).
 *  `pointerover` (not `pointerenter`) so it fires on hover AND bubbles through the boxless
@@ -92,6 +130,8 @@ const ON_DEMAND_EVENTS = [
 	"keydown"
 ];
 const ON_DEMAND_SELECTOR = "ogygia-region[render=\"defer\"][when=\"interaction\"]";
+/** A visitor's wake with nothing to replay (a hole's on-demand fetch). */
+const NO_REPLAY = Promise.resolve();
 /**
 * ON-DEMAND holes, delegated: ONE set of capture listeners on the document for every armed hole
 * (five listeners per hole used to be five hundred on a page of nav-menus). Intent lands anywhere
@@ -153,26 +193,36 @@ function dom_ready() {
 	if (typeof document === "undefined" || document.readyState !== "loading") return Promise.resolve();
 	return new Promise((r) => document.addEventListener("DOMContentLoaded", r, { once: true }));
 }
+/** What a region element holds before its first connect and after it left the page: nothing.
+*  Anything given to it is let go at once. */
+const NOT_CONNECTED = scope();
+NOT_CONNECTED.close();
+/** Its mailbox then: closed (every post dropped, every wait `STALE`). */
+const CLOSED_BOX = mailbox(NOT_CONNECTED);
+/** A download slot (load-scheduler.ts) asked for by a step whose element then left: its turn still
+*  comes, and is handed straight back. */
+const hand_back = (release) => release();
+const nothing = () => {};
 /** Where a live snippet's pending hydrate waits on its host region (region-snippet.ts `hold_host`). */
 const SNIPPET_BOOTS = Symbol.for("ogygia.snippet-boots");
 /** A snippet whose entry never arrives must not hold its host's signal forever. */
 const SNIPPET_BOOT_CAP_MS = 1e4;
 /** Settle the live snippets a just-hydrated region renders — and the snippets those render, which
-*  register as they boot — or the cap, whichever is first. A failed boot settles too. */
-async function snippets_settled(region) {
+*  register as they boot — or the cap, whichever is first. A failed boot settles too. The wait is
+*  `visit`'s (the wake's): it ends when the region leaves, too. */
+async function snippets_settled(region, visit) {
 	const host = region;
-	let timer;
-	const cap = new Promise((r) => timer = setTimeout(r, SNIPPET_BOOT_CAP_MS));
-	let capped = false;
-	cap.then(() => capped = true);
+	const wait = visit.child();
+	const cap = new Promise((r) => wait.defer(r));
+	wait.timeout(() => wait.close(), SNIPPET_BOOT_CAP_MS);
 	try {
-		for (let batch = host[SNIPPET_BOOTS]; batch?.length && !capped; batch = host[SNIPPET_BOOTS]) {
+		for (let batch = host[SNIPPET_BOOTS]; batch?.length && !wait.closed; batch = host[SNIPPET_BOOTS]) {
 			host[SNIPPET_BOOTS] = [];
 			await Promise.race([Promise.allSettled(batch), cap]);
 			await Promise.resolve();
 		}
 	} finally {
-		clearTimeout(timer);
+		wait.close();
 		delete host[SNIPPET_BOOTS];
 	}
 }
@@ -181,16 +231,20 @@ async function snippets_settled(region) {
 * inlined `<style data-ogygia-region-css="href">`) it carries into `<head>` (deduped by href). A held / server-picked region's component was never
 * imported by the page, so its scoped CSS is in no stylesheet the page loaded; the region response
 * ships the links and the runtime lifts them to the head — where they load once and stick. (A link
-* left in the body would also fail to load inside a `<template>` batch parcel.)
+* left in the body would also fail to load inside a `<template>` batch parcel.) `sheets`: the head
+* nodes the answer uses, for the region that paints it (./region-sheets.ts `use_sheets`).
 */
 function region_fragment(html) {
 	const frag = parse_region_html(html);
+	devalue_lane_stale();
+	const { facts: queued, scope: page } = runtime_session.visit;
 	for (const facts of frag.querySelectorAll(PAGE_FACTS_SELECTOR)) {
 		facts.remove();
-		runtime_session.page_facts.push(facts.textContent ?? "");
+		queued.push(facts.textContent ?? "");
 	}
 	const links = frag.querySelectorAll("link[data-ogygia-region-css]");
 	const pending = [];
+	const sheets = [];
 	if (links.length && import.meta.env.DEV) {
 		const seen = /* @__PURE__ */ new Set();
 		for (const link of links) {
@@ -207,55 +261,70 @@ function region_fragment(html) {
 		}
 	} else if (links.length) {
 		const existing = new Map(Array.from(document.querySelectorAll("link[rel=\"stylesheet\"]"), (l) => [l.getAttribute("href"), l]));
-		const until_loaded = (l) => new Promise((resolve) => {
-			l.addEventListener("load", () => resolve(), { once: true });
-			l.addEventListener("error", () => resolve(), { once: true });
-			if (l.sheet) resolve();
-		});
+		const until_settled = (sheet) => sheet.wait("loaded").then(() => void 0);
 		for (const link of links) {
 			const href = link.getAttribute("href");
 			link.remove();
 			if (!href) continue;
 			const present = existing.get(href);
 			if (present) {
-				if (!present.sheet) pending.push(until_loaded(present));
-				continue;
+				const sheet = sheet_of(present);
+				if (sheet.now.kind === "loading") pending.push(until_settled(sheet));
+				if (sheet.now.kind !== "failed") {
+					sheets.push(present);
+					continue;
+				}
+				present.remove();
 			}
 			const clone = document.createElement("link");
 			clone.rel = "stylesheet";
 			clone.href = href;
 			clone.setAttribute("data-ogygia-region-css", "");
-			pending.push(until_loaded(clone));
+			pending.push(until_settled(sheet_of(clone)));
 			existing.set(href, clone);
+			sheets.push(clone);
 			runtime_session.claim_page_head(clone);
 			document.head.appendChild(clone);
 		}
 	}
 	const styles = frag.querySelectorAll("style[data-ogygia-region-css]");
 	if (styles.length) {
-		const present = /* @__PURE__ */ new Set();
+		const present = /* @__PURE__ */ new Map();
 		for (const n of document.head.querySelectorAll("[data-ogygia-region-css], link[rel=\"stylesheet\"]")) {
 			const id = n.tagName === "STYLE" ? n.getAttribute("data-ogygia-region-css") : n.getAttribute("href");
-			if (id) present.add(id);
+			if (id) present.set(id, n);
 		}
 		for (const style of styles) {
 			const id = style.getAttribute("data-ogygia-region-css") || "";
 			style.remove();
-			if (!id || present.has(id)) continue;
-			present.add(id);
+			if (!id) continue;
+			const found = present.get(id);
+			if (found !== void 0) {
+				sheets.push(found);
+				continue;
+			}
 			const el = document.createElement("style");
+			present.set(id, el);
+			sheets.push(el);
 			el.setAttribute("data-ogygia-region-css", id);
 			el.textContent = style.textContent || "";
 			runtime_session.claim_page_head(el);
 			document.head.insertBefore(el, document.head.firstChild);
 		}
 	}
-	const ready = pending.length ? Promise.race([Promise.all(pending).then(() => void 0), new Promise((r) => setTimeout(r, 5e3))]) : Promise.resolve();
+	const ready = pending.length ? page.task(() => new Promise((resolve) => {
+		const cancel = page.timeout(resolve, 5e3);
+		Promise.all(pending).then(() => {
+			cancel();
+			resolve();
+		});
+	})).then(() => void 0) : Promise.resolve();
 	restore_markup(frag);
 	for (const el of frag.querySelectorAll("ogygia-region")) if (el.getAttribute("entry") && !is_deferred(el) && !is_frozen(el)) el[PRISTINE_SSR] = el.innerHTML;
 	return {
 		frag,
-		ready
+		ready,
+		sheets
 	};
 }
 /** TEST: the pristine server markup {@link region_fragment} stashed on a nested island, if any. */
@@ -270,71 +339,107 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	*  The fetch reads this copy and restores the attribute (lakes, devtools and the router's
 	*  next-page warm all read the DOM). */
 	#minted_endpoint = null;
-	/** A fresh capability a renewal answered (#frame_fetcher), adopted once the fetch that got it is
-	*  applied (#adopt_renewed) — moving addresses mid-fetch would orphan that answer. */
-	#renewed_endpoint = null;
 	/** THE HYDRATION SOURCE OF TRUTH: this island's server markup as it connected (or, for a
 	*  hydrating hole, as its answer was swapped in). An island can sleep a long time and other
 	*  scripts edit the page meanwhile; on wake, hydrate-core hydrates against THIS when the live
 	*  DOM drifted, instead of letting Svelte re-render the island client-side. Dropped once the
 	*  island is awake. `null` for a nested region (rides its parent) and above SSR_SNAPSHOT_MAX. */
 	#ssr_html = null;
-	/** Counted in drift-watch.ts's sleeping islands (paired: one watch, one unwatch). */
-	#watching = false;
+	/**
+	* THE ELEMENT'S LIFETIME IN THE PAGE: made at its connect, closed at its teardown (a move — out and
+	* back in one task — is no teardown, so it keeps it). What the element holds across its machines'
+	* visits is this scope's: its sleep in drift-watch.ts, its viewport snapshot for the scheduler,
+	* its binding to its frame-store address, the frame that replays a visitor's clicks. What one
+	* visit holds stays on that visit (`m.scope`). Closed before the first connect and after the
+	* teardown: anything given to it then is let go at once.
+	*/
+	#life = NOT_CONNECTED;
+	/**
+	* ITS EVENTS, ONE AT A TIME (@ogygia/machine's `mailbox()`, #322): a connect, a schedule firing, a
+	* frame landing, a live tick, its fetch's end and its retry, its wake's steps — each a turn, in the
+	* order they came, so no two see each other's half-done step, whichever of its machines they drive.
+	* Its lifetime's:
+	* the element leaving drops what is queued, and a step waiting gets `STALE` at once. Every callback
+	* that comes back to the element later posts here (the box of the lifetime it started in).
+	*/
+	#box = CLOSED_BOX;
+	/** The answer it painted last: what a hole put back on the page shows again when the frame store
+	*  let it go meanwhile (#336). */
+	#shown = null;
+	/** Frames its binding was handed (a binding that replays one counts it at once). */
+	#frames_in = 0;
+	/** A live region's last tick: what it goes on with when it is put back on the page (#337). */
+	#live_last = null;
+	/** While it sleeps with a copy: counted in drift-watch.ts's sleeping islands, until it wakes (or
+	*  leaves the page). */
+	#asleep = null;
+	get #watching() {
+		return this.#asleep !== null && !this.#asleep.closed;
+	}
 	#watch() {
 		if (this.#watching) return;
-		this.#watching = true;
+		this.#asleep = this.#life.child();
 		watch_region();
+		this.#asleep.defer(unwatch_region);
 	}
 	#unwatch() {
-		if (!this.#watching) return;
-		this.#watching = false;
-		unwatch_region();
+		this.#asleep?.close();
+		this.#asleep = null;
 	}
-	/** True after a successful HTML swap — failures leave this false so a later schedule can retry. */
-	#done = false;
-	/** In-flight `#apply` run. `#apply` awaits the region's stylesheet before swapping, so anyone
-	* who needs the post-swap state (`#done`, phase-2 hydrate arming) must await this first —
-	* sampling `#done` right after the fetch races the CSS wait and reads stale `false`. */
-	#applying;
-	/** In-flight fetch guard (separate from `#done` so a failed fetch does not one-shot the region). */
-	#fetching = false;
-	/** Bounded automatic retries after a failed defer/SWR fetch. */
-	#fetch_attempts = 0;
+	/** A deferred region's own fetch of its answer: armed, fetching, waiting to retry, given up
+	*  (./region-machines.ts). Its `armed` state owns the `when` and `prefetch` listeners. */
+	#hole = create_hole();
+	/** What the hole's answers put on screen: nothing yet, an answer, or the kept fallback. Any
+	*  answer counts, whoever fetched it (a twin, a batch, a write at its address). */
+	#answer = create_answer();
+	/** The island's hydration: cold, armed (its schedule's listeners), waking, awake, failed. */
+	#wake = create_wake();
 	/** when this hole's first fetch started (devtools + profiler: how long its fallback showed) */
 	#fetch_started = 0;
-	/** Frame-store address (endpoint call) this region is fetching, so disconnect can release it. */
+	/** Frame-store address (endpoint call) this region is bound to. */
 	#frame_address = null;
-	/** Unsubscribe from the frame store (a defer region binds to its address). */
-	#frame_unsub = null;
-	/** Set while an SWR revalidate is in flight, so the next apply marks `data-revalidated`. */
-	#revalidating = false;
-	#hydrating = false;
-	/** A visitor's gesture woke this region (`interaction`): its downloads are the `user` class. */
-	#user_woken = false;
+	/** Its subscription at that address (a defer region binds to its address), a child of its
+	*  lifetime in the page: closing it unsubscribes. */
+	#binding = null;
+	/** A visitor's gesture woke this region (`interaction`, or the capture on a scheduled island): its
+	*  downloads are the `user` class, and this is what replays their input (the capture's replay half,
+	*  loading) — its island goes live once it is in, so the input lands AT wake (#260). */
+	#visitor = null;
 	/** The hydrated island (hydrate core handle): dispose, and for a kept island, props push. */
 	#app = null;
-	/** Stops the shared `visible` observation (set while armed, cold). */
-	#stop_visible = null;
-	/** Removes the `wake="interaction"` wake listeners (set while armed, cold). */
-	#disarm_interaction = null;
-	#mql = null;
-	/** The hole answered `keepFallback()`: the page's fallback stands, no phase-2 wake. */
-	#kept = false;
-	/** Abort in-flight region HTML fetch on disconnect (P-ABORT). */
-	#fetch_abort = null;
-	/** Cancel idle schedule when disconnected. */
-	#idle_handle = null;
 	/** Disconnected, teardown waiting a microtask: a reconnect before it is a move. */
 	#leaving = false;
 	/** Live region (`<ogygia-region live>`): driven imperatively by Region.svelte's applyLive. */
 	#live_ready = false;
-	#live_app = null;
-	#live_module = "";
+	/** Its mode, tick by tick: static (subscribed to the store), hydrating, live (./region-machines.ts). */
+	#live = create_live();
+	/** The frame that paints next: each frame waits for its sheets in a visit of its own, and only
+	*  the newest paints (./region-machines.ts). */
+	#paint = create_paint();
+	/** The props of the latest same-module tick that came while its island hydrated: pushed once live. */
+	#live_props = null;
+	/** A static live region's subscription to its address, while it is static. */
+	#live_unsub = null;
 	#hydrate_run = null;
-	#fire_hydrate = () => this.#hydrate_run ??= this.#hydrate().finally(() => this.#hydrate_run = null);
-	#fire_server = () => this.#server();
-	#fire_prefetch = () => this.#prefetch_html();
+	#fire_hydrate = () => {
+		const held = this.#hydrate_run;
+		if (held && (held.visit === this.#wake.now || this.#wake.now.kind === "waking")) return held.run;
+		const run = this.#box.ask((turn) => this.#hydrate(turn)).then(nothing);
+		const entry = {
+			visit: this.#wake.now,
+			run
+		};
+		this.#hydrate_run = entry;
+		const ran = () => this.#hydrate_ran(entry);
+		run.then(ran, ran);
+		return run;
+	};
+	/** A hydration run ended: forget it, unless a newer one took its place. */
+	#hydrate_ran(entry) {
+		if (this.#hydrate_run === entry) this.#hydrate_run = null;
+	}
+	#fire_server = () => this.#box.post((turn) => this.#server(turn));
+	#fire_prefetch = () => this.#box.post(() => this.#prefetch_html());
 	/**
 	* CONTINUITY: this persisted island is relocating onto `next` (the incoming page's SSR region).
 	* Push the new page's props into the live app so a `persist`ed component reflects the new route
@@ -349,9 +454,18 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		} catch {}
 	}
 	connectedCallback() {
+		if (this.#life.closed && this.isConnected) {
+			this.#life = scope();
+			this.#box = mailbox(this.#life);
+		}
 		connected_regions.add(this);
+		devalue_lane_stale();
 		pin_region_urls(this);
-		if (this.hasAttribute("live")) return;
+		this.#box.post((turn) => this.#connect(turn));
+	}
+	/** The connect, in its turn: where the region stands, and what it arms. */
+	#connect(turn) {
+		if (this.hasAttribute("live")) return this.#live_put_back(turn);
 		if (FRAMES && this.#minted_endpoint === null && is_deferred(this)) {
 			const minted = this.getAttribute("endpoint");
 			if (minted) this.#minted_endpoint = minted;
@@ -363,7 +477,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 					pin_region_urls(this);
 					this.#minted_endpoint = this.getAttribute("endpoint");
 					if (facts.sidecar) restore_props_sidecar(this, facts.sidecar.cloneNode(true));
-				} else if (import.meta.env.DEV && identity) console.warn(HOLE_WITHOUT_ADDRESS_WARNING, this.getAttribute("entry") || identity);
+				} else if (import.meta.env.DEV && identity) warn("hole_without_address", { region: this.getAttribute("entry") || identity });
 			}
 		}
 		if (is_frozen(this) && slots.lakes.on_frozen_connect(this, this.#lake_arm())) return;
@@ -383,7 +497,10 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 				deferred: false,
 				nested: true
 			});
-			if (import.meta.env.DEV) console.warn(`[ogygia] nested region "${this.getAttribute("entry")}" skipped self-run; the nearest region above it is awake, so it rides that hydration (inner hydrate "${this.getAttribute("wake") || "load"}" ignored).`);
+			if (import.meta.env.DEV) warn("nested_region_rides_parent", {
+				entry: this.getAttribute("entry") || "",
+				wake: this.getAttribute("wake") || "load"
+			});
 			return;
 		}
 		const deferred = is_deferred(this);
@@ -395,6 +512,10 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		if (this.#ssr_html !== null) this.#watch();
 		if (slots.lakes.wait_for_boundary(this, boundary)) return;
 		this.#scheduled = true;
+		if (deferred && this.#answer.now.kind !== "none") {
+			this.#put_back();
+			return;
+		}
 		const when = region_schedule(this);
 		if (DEVTOOLS) {
 			emit({
@@ -412,13 +533,44 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 				when
 			});
 		}
-		if (!deferred) register_region(this);
-		if (deferred) this.#arm(when, this.#fire_server);
-		else this.#arm(when, this.#fire_hydrate);
-		const prefetch = deferred ? this.getAttribute("prefetch") : null;
+		if (!deferred) register_region(this, this.#life);
+		if (!deferred) {
+			if (this.#wake.now.kind === "cold") this.#wake.go("armed");
+			this.#arm(when, this.#fire_hydrate);
+			return;
+		}
+		if (!this.#hole_armed()) return;
+		this.#arm(when, this.#fire_server);
+		const prefetch = this.getAttribute("prefetch");
 		if (prefetch && prefetch !== when && prefetch !== "interaction") this.#arm(prefetch, this.#fire_prefetch, this.getAttribute("margin") || void 0);
 	}
 	/**
+	* Put the hole's fetch in `armed`, the state its schedules' listeners belong to: from idle, from a
+	* retry it waited for, or after it gave up (a lake's or a connect's new try). A fetch in flight
+	* arms nothing — it is already doing what a schedule would start.
+	*/
+	#hole_armed() {
+		const s = this.#hole.now;
+		if (s.kind === "armed") return true;
+		if (s.kind === "fetching") return false;
+		return this.#hole.go("armed", { attempts: s.kind === "retrying" ? s.attempts : 0 });
+	}
+	/**
+	* A hole that had its answer is back on the page (#336): it binds to its address again, and the
+	* store hands it the frame there, as it does any late binder — its island wakes on it, whoever's
+	* the answer. A minute off the page with nothing bound, the store let the frame go: the hole's own
+	* last answer is painted again (its island, unmounted as it left, took its markup with it). Still
+	* bound (a move, a failed refresh), it has nothing to catch up on.
+	*/
+	#put_back() {
+		const endpoint = this.#endpoint();
+		if (!endpoint || this.#bound()) return;
+		const handed = this.#frames_in;
+		this.#bind(endpoint);
+		const shown = this.#shown;
+		if (this.#frames_in === handed && shown !== null && this.#answer.now.kind === "answered") this.#box.post((turn) => this.#apply(shown, turn));
+	}
+	/**
 	* Warm this hole's HTML into the frame store ahead of its `when` — the `prefetch` schedule. No
 	* subscription is taken, so nothing is applied now; the later wake (`#server`) subscribes, the
 	* store replays the warm frame at once, and its `ensure` joins instead of fetching. A failed
@@ -427,7 +579,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	*/
 	#prefetch_html() {
 		if (!FRAMES) return;
-		if (this.#done || this.#fetching || !this.isConnected) return;
+		if (this.#answer.now.kind !== "none" || this.#hole.now.kind === "fetching" || !this.isConnected) return;
 		const endpoint = this.#endpoint();
 		if (!endpoint || !is_allowed_region_endpoint(endpoint)) return;
 		const address = frameAddress(endpoint);
@@ -447,7 +599,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	#frame_fetcher(endpoint, revalidate, cls) {
 		const class_now = typeof cls === "function" ? cls : () => cls;
 		return async (signal) => {
-			const release = await load_slot({
+			const release = await new LoadSlot({
 				kind: "content",
 				cls,
 				label: endpoint
@@ -460,45 +612,41 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		};
 	}
 	#fetch_region(endpoint, revalidate, priority, signal) {
-		return runtime_session.server_gate.run(async () => {
-			if (BEACON) beacon_hole_fetched(endpoint);
-			let res = await fetch(endpoint, {
-				credentials: "same-origin",
-				cache: revalidate ? "no-store" : "default",
+		return runtime_session.server_gate.run(() => {
+			const address = frameAddress(endpoint);
+			return fetch_hole(endpoint, {
+				revalidate,
 				priority,
-				signal
+				signal,
+				renewed: (fresh) => slots.frames?.renew(address, fresh)
 			});
-			if (res.status === 403 && capability_expired(endpoint)) {
-				res = await fetch(renewal_url(endpoint), {
-					credentials: "same-origin",
-					cache: "no-store",
-					signal
-				});
-				const fresh = res.ok ? res.headers.get("x-ogygia-capability") : null;
-				if (fresh && is_allowed_region_endpoint(fresh)) this.#renewed_endpoint = fresh;
-			}
-			if (!is_same_origin_response(res)) throw new Error("cross-origin redirect");
-			if (is_redirected_answer(res)) throw new RegionAnswerRefused("redirected", res.url);
-			if (res.status === 403) throw new RegionAnswerRefused("forbidden", res.url || endpoint, deny_of(res, endpoint));
-			if (!res.ok) throw new Error("status " + res.status);
-			if (res.status === 204) return KEEP_FALLBACK_HTML;
-			const text = await res.text();
-			if (is_document_answer(text)) throw new RegionAnswerRefused("document", res.url);
-			return text;
 		});
 	}
-	/** The schedule hooks a frozen region (lake) drives its revalidation through. */
+	/** The schedule hooks a frozen region (lake) drives its revalidation through: their listeners
+	*  belong to the hole's `armed` state, like a hole's own schedule's. */
 	#lake_arm() {
 		return {
-			idle: (fire) => this.#on_idle(fire),
-			visible: (fire, margin) => this.#on_visible(fire, margin),
-			media: (when, fire) => this.#on_media(when, fire),
-			fetch_revalidate: () => void this.#fetch_html({ revalidate: true }),
+			idle: (fire) => {
+				if (this.#hole_armed()) this.#on_idle(fire, this.#hole);
+			},
+			visible: (fire, margin) => {
+				if (this.#hole_armed()) this.#on_visible(fire, margin, this.#hole);
+			},
+			media: (when, fire) => {
+				if (this.#hole_armed()) this.#on_media(when, fire, this.#hole);
+			},
+			fetch_revalidate: () => this.#box.post((turn) => this.#fetch_html(turn, true)),
 			wake_children: () => this.#wake_waiting_regions()
 		};
 	}
-	/** Arm idle / visible / load / interaction / media for a schedule callback. */
+	/**
+	* Arm idle / visible / load / interaction / media for a schedule callback. The listeners belong to
+	* the `armed` state of the machine the callback drives — the island's wake, or the hole's fetch —
+	* which must be in it: leaving it (the schedule fired, an answer came another way, the region left
+	* the page) drops every one, however many schedules armed.
+	*/
 	#arm(when, fire, visible_margin) {
+		const owner = fire === this.#fire_hydrate ? this.#wake : this.#hole;
 		if (fire === this.#fire_hydrate && when !== "interaction") this.#catch_early_input(fire);
 		if (DEVTOOLS) {
 			const raw = fire;
@@ -512,18 +660,20 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 				return raw();
 			};
 		}
-		const start = () => background_start(fire);
-		if (when === "idle") this.#on_idle(fire);
-		else if (when === "visible") this.#on_visible(start, visible_margin);
+		const armed = owner.scope;
+		const start = () => background_start(() => void (armed.closed || fire()));
+		if (when === "idle") this.#on_idle(fire, owner);
+		else if (when === "visible") this.#on_visible(start, visible_margin, owner);
 		else if (when === "load") start();
 		else if (when === "interaction") {
-			const by_user = () => {
-				this.#user_woken = true;
-				return fire();
-			};
-			if (is_deferred(this)) arm_on_demand(this, by_user);
-			else this.#on_interaction(by_user);
-		} else this.#on_media(when, start);
+			if (owner === this.#hole) {
+				arm_on_demand(this, () => {
+					this.#visitor = NO_REPLAY;
+					return fire();
+				});
+				owner.scope.defer(() => on_demand_armed.delete(this));
+			} else this.#on_interaction(fire);
+		} else this.#on_media(when, start, owner);
 	}
 	/**
 	* `wake="interaction"`: sleep until a pointer/key/focus/click lands inside the region, then
@@ -543,8 +693,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 			fire();
 			return;
 		}
-		const disarm = arm(this, fire);
-		this.#disarm_interaction = typeof disarm === "function" ? disarm : null;
+		this.#hold_capture(arm(this, this.#by_visitor(fire), this.#life));
 	}
 	/**
 	* A scheduled island (`load` / `idle` / `visible` / media) also catches input until it is live — the
@@ -555,28 +704,81 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	#catch_early_input(fire) {
 		const arm = slots.interaction;
 		if (!arm || this.#app || kit_hydrates_page() && !ours_on_kit_document(this)) return;
-		const disarm = arm(this, () => {
-			this.#user_woken = true;
-			return fire();
-		});
-		this.#disarm_interaction = typeof disarm === "function" ? disarm : null;
+		this.#hold_capture(arm(this, this.#by_visitor(fire), this.#life));
+	}
+	/**
+	* The wake as the interaction capture awaits it: a visitor's gesture (its downloads are the `user`
+	* class from here on), and a promise that REJECTS when the island failed to wake — the capture then
+	* replays its clicks onto the server markup and says so (interaction.ts). Only the capture gets this:
+	* a schedule's own wake has nobody to tell.
+	*/
+	#by_visitor(fire) {
+		return (replayed) => {
+			this.#visitor = replayed;
+			return Promise.resolve(fire()).then(() => {
+				const s = this.#wake.now;
+				if (s.kind === "failed") throw s.error;
+			});
+		};
+	}
+	/**
+	* The capture outlives the schedule it was armed with: it stays while the island wakes (a click
+	* meanwhile is queued, and replayed once the island is live), so leaving `armed` for `waking` hands
+	* its disarm on to `waking`, and leaving that (awake, failed, or the region gone) disarms it. Gone
+	* (out of the document), its visit is over: the clicks it queued go with it.
+	*/
+	#hold_capture(disarm) {
+		if (typeof disarm !== "function") return;
+		const wake = this.#wake;
+		const hold = () => {
+			if (wake.now.kind === "waking") wake.scope.defer(hold);
+			else disarm(!this.isConnected);
+		};
+		wake.scope.defer(hold);
 	}
 	/**
-	* Move this hole onto the fresh capability a renewal answered: the attribute (every DOM reader —
-	* lakes, devtools, the router's warm — agrees), the minted copy, and the frame-store address its
-	* later wakes and revalidates fetch and apply at. Called after the answer that carried it landed.
+	* Move this hole onto the fresh capability a renewal at its address answered (frame-store
+	* `renew`, whichever copy's fetch got it): the attribute (every DOM reader — lakes, devtools, the
+	* router's warm — agrees), the minted copy, and, should the address differ, the frame-store
+	* address its later wakes and revalidates fetch and apply at. Called once an answer landed — moving
+	* addresses mid-fetch would orphan that answer. A copy whose own capability has not expired keeps
+	* it (it can be newer than the renewal: a page rendered since).
 	*/
 	#adopt_renewed() {
-		const fresh = this.#renewed_endpoint;
-		if (!fresh) return;
-		this.#renewed_endpoint = null;
+		const address = this.#frame_address;
+		const fresh = address ? slots.frames?.renewal(address) : null;
+		const current = this.getAttribute("endpoint");
+		if (!fresh || fresh === current || current && !capability_expired(current)) return;
 		this.#minted_endpoint = fresh;
 		this.setAttribute("endpoint", fresh);
-		if (this.#frame_unsub) {
-			this.#frame_unsub();
-			const address = this.#frame_address = frameAddress(fresh);
-			this.#frame_unsub = slots.frames?.subscribe(address, (f) => void (this.#applying = this.#apply(f.html))) ?? null;
-		}
+		if (this.#bound()) this.#bind(fresh);
+	}
+	/**
+	* Bind to the store at `endpoint`'s address: this region applies whatever frame lands there (#apply)
+	* — from its own fetch, a twin's, a navigation batch stream, or a mutation. subscribe() replays
+	* current content immediately, so a late-mounting twin catches up free. A re-minted endpoint (new
+	* props, new page facts) moves the binding to its new address. Returns the address.
+	*/
+	#bind(endpoint) {
+		const address = frameAddress(endpoint);
+		if (this.#bound() && this.#frame_address === address) return address;
+		this.#binding?.close();
+		const binding = this.#binding = this.#life.child();
+		this.#frame_address = address;
+		binding.defer(() => {
+			if (this.#binding === binding) this.#frame_address = null;
+		});
+		const box = this.#box;
+		const off = slots.frames?.subscribe(address, (f) => {
+			this.#frames_in++;
+			box.post((turn) => this.#apply(f.html, turn));
+		});
+		if (off) binding.defer(off);
+		return address;
+	}
+	/** Bound to a frame-store address now. */
+	#bound() {
+		return this.#binding !== null && !this.#binding.closed;
 	}
 	/** The hole's endpoint: the attribute, or the server-minted copy when Kit's hydration wiped it
 	*  (restored on the element so every other DOM reader agrees). */
@@ -588,28 +790,53 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		return this.#minted_endpoint;
 	}
 	/**
-	* Deferred hole: get its HTML and swap it in. When `hydrate` is also set (deferred client
-	* island), schedule phase-2 hydrate — coalescing matching schedules to immediate load.
+	* Deferred hole, its `when` fired: bind to its address and get its HTML. The swap — and, for a
+	* deferred client island, the phase-2 wake — happen where every answer lands (#apply), whoever
+	* fetched it.
 	*/
-	async #server() {
+	#server(turn) {
 		if (!FRAMES) return;
 		const endpoint = this.#endpoint();
-		if (endpoint && !this.#frame_unsub) {
-			const address = this.#frame_address = frameAddress(endpoint);
-			this.#frame_unsub = slots.frames?.subscribe(address, (f) => void (this.#applying = this.#apply(f.html))) ?? null;
-		}
-		await this.#fetch_html();
-		await this.#applying;
-		if (!this.#done || !this.isConnected) return;
-		if (this.#kept) return;
+		const handed = this.#frames_in;
+		if (endpoint) this.#bind(endpoint);
+		const run = this.#frames_in === handed ? this.#fetch_html(turn) : void 0;
+		if (this.#hole.now.kind === "armed") this.#hole.go("idle");
+		return run;
+	}
+	/**
+	* A deferred client island's answer is in: arm its phase-2 wake — coalescing a schedule that
+	* matches the hole's own `when` to an immediate load. Once: an island already armed, waking, awake
+	* or failed is not armed again (a refresh morphs a live island in place).
+	*/
+	#arm_phase2() {
+		if (this.#wake.now.kind !== "cold" || this.#app || !this.isConnected) return;
 		const hydrate = region_hydrate_schedule(this);
 		if (!hydrate) return;
 		const defer_when = this.getAttribute("when") || "load";
 		const phase2 = phase2_hydrate_schedule(defer_when, hydrate);
 		const margin = phase2 === "visible" ? this.getAttribute("hydrate-margin") || this.getAttribute("margin") || void 0 : void 0;
-		register_region(this);
+		register_region(this, this.#life);
+		this.#wake.go("armed");
 		this.#arm(phase2, this.#fire_hydrate, margin);
 	}
+	/** An answer landed: the hole's own fetch has nothing left to wait for — a schedule still armed
+	*  (a retry's) or a retry it waited for is called off. A fetch in flight runs to its end. */
+	#answered(kind) {
+		if (this.#answer.now.kind !== kind) this.#answer.go(kind);
+		const hole = this.#hole.now.kind;
+		if (hole === "armed" || hole === "retrying" || hole === "failed") this.#hole.go("idle");
+	}
+	/** A frame landed: it starts its paint visit (a frame still waiting for its sheets is older, and
+	*  its visit is over). Returns the visit, to check after the wait. */
+	#paint_next() {
+		this.#paint.go("painting");
+		return this.#paint.now;
+	}
+	/** The frame of visit `painting` paints now: nothing is waiting any more, unless a newer frame
+	*  already started (a listener of this paint wrote one). */
+	#painted(painting) {
+		if (this.#paint.now === painting) this.#paint.go("idle");
+	}
 	/**
 	* THE single apply path. A frame's HTML lands here from any source (own fetch, stream parcel,
 	* navigation batch, mutation). First arrival hydrates the hole; a later arrival at a newer
@@ -617,22 +844,25 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* offline before custom elements connect, then swap, mark, event. HOLE-TRUST: the HTML is our own
 	* signed same-origin SSR.
 	*/
-	async #apply(html) {
+	async #apply(html, turn) {
 		if (!this.isConnected) return;
+		const painting = this.#paint_next();
 		if (html === "<!--ogygia:keep-fallback-->") {
-			this.#revalidating = false;
-			this.#done = true;
-			this.#kept = true;
+			this.#painted(painting);
+			use_sheets(this, []);
+			this.#answered("kept");
 			if (!is_awake(this)) this.setAttribute("data-hydrated", "");
 			this.setAttribute("data-og-kept", "");
+			this.#adopt_renewed();
 			this.dispatchEvent(new CustomEvent("ogygia:server", { bubbles: true }));
 			return;
 		}
-		const revalidate = this.#revalidating || this.#done;
-		this.#revalidating = false;
-		const { frag, ready } = region_fragment(html);
-		await ready;
-		if (!this.isConnected) return;
+		const revalidate = is_frozen(this) || this.#answer.now.kind === "answered";
+		const { frag, ready, sheets } = region_fragment(html);
+		if (await turn.wait(ready) === STALE || this.#paint.now !== painting) return;
+		this.#painted(painting);
+		use_sheets(this, sheets);
+		this.#shown = html;
 		slots.lakes.settle_in(frag);
 		slots.lakes.mark_frozen_settled(this);
 		const morph = slots.morph;
@@ -645,10 +875,11 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		restore_adopt_sheets();
 		init_shadow_registries(this);
 		absorb_page_facts_now();
-		this.#done = true;
+		this.#answered("answered");
+		this.removeAttribute("data-og-kept");
 		if (revalidate) this.setAttribute("data-revalidated", "");
 		else if (!is_awake(this)) this.setAttribute("data-hydrated", "");
-		slots.lakes.after_html_swap(this, { revalidate });
+		slots.lakes.after_html_swap(this, { revalidate }, () => this.#wake_waiting_regions());
 		if (BEACON && !revalidate && this.#fetch_started) {
 			const ep = this.getAttribute("endpoint");
 			beacon_hole_answered(this, this.#fetch_started, ep ? slots.frames?.batch_times?.(ep) : void 0);
@@ -662,7 +893,9 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 			revalidate,
 			...!revalidate && this.#fetch_started ? { wait_ms: Math.round(performance.now() - this.#fetch_started) } : {}
 		});
+		this.#adopt_renewed();
 		this.dispatchEvent(new CustomEvent("ogygia:server", { bubbles: true }));
+		this.#arm_phase2();
 	}
 	/**
 	* Store applicator for a STATIC live/held region (`<ogygia-region live>` with no interactive
@@ -671,7 +904,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* survives — the breathing update live partials rely on). Interactive live regions never reach
 	* here: they keep the imperative keep-alive path in {@link applyLive}.
 	*/
-	async #morph_live(html) {
+	async #morph_live(html, turn) {
 		if (!this.isConnected) return;
 		if (!this.#live_ready && this.hasAttribute("data-og-baked")) {
 			this.#live_ready = true;
@@ -679,9 +912,11 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 			this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
 			return;
 		}
-		const { frag, ready } = region_fragment(html);
-		await ready;
-		if (!this.isConnected) return;
+		const painting = this.#paint_next();
+		const { frag, ready, sheets } = region_fragment(html);
+		if (await turn.wait(ready) === STALE || this.#paint.now !== painting) return;
+		this.#painted(painting);
+		use_sheets(this, sheets);
 		slots.lakes.settle_in(frag);
 		if (!this.#live_ready) {
 			this.replaceChildren(frag);
@@ -692,7 +927,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 			const morph = slots.morph;
 			if (morph) morph(this, nodes);
 			else this.replaceChildren(...nodes);
-			for (const el of this.querySelectorAll("ogygia-region")) if (el instanceof OgygiaRegion) el.#renew();
+			for (const el of this.querySelectorAll("ogygia-region")) if (el instanceof OgygiaRegion) el.#box.post((t) => el.#renew(t));
 		}
 		restore_adopt_sheets();
 		init_shadow_registries(this);
@@ -704,154 +939,188 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* new page facts (`pv`) — it fetches its new answer, the current one on screen until that lands.
 	* A hole that never fetched yet fetches the new address on its own schedule.
 	*/
-	#renew() {
+	#renew(turn) {
 		if (!this.#frame_address || !is_deferred(this)) return;
 		const endpoint = this.getAttribute("endpoint");
 		if (!endpoint || frameAddress(endpoint) === this.#frame_address) return;
-		this.#fetch_html({ revalidate: true });
+		return this.#fetch_html(turn, true);
 	}
 	/**
-	* Fetch `endpoint` HTML and swap it in.
-	* Success sets `#done` (at most one successful swap per element). Failure leaves `#done` false
-	* so a reconnect, remount, or deferred retry can try again — previously `#done` was set up front
-	* and a transient network error permanently killed the hole.
+	* Fetch `endpoint` HTML into the store; the store's write swaps it in (#apply). One visit to the
+	* hole's `fetching`: it ends when the fetch does (idle), when it failed (`retrying`, `failed`), or
+	* when the region leaves the page (it leaves the shared fetch). A failure leaves the
+	* answer as it was, so a reconnect, a remount or the retry can try again — a transient network
+	* error never kills the hole for good.
 	* A deferred hole reuses the browser's `<link rel="preload">` response; an swr REVALIDATE must
 	* not (the endpoint answers `cache-control: private, max-age=30`, and stale is the whole point).
 	*/
-	async #fetch_html(opts = {}) {
+	async #fetch_html(turn, revalidate = false) {
 		if (!FRAMES) return;
-		if (this.#fetching || this.#done && !opts.revalidate) return;
+		const s = this.#hole.now;
+		if (s.kind === "fetching" || !revalidate && this.#answer.now.kind !== "none") return;
 		const endpoint = this.#endpoint();
 		if (!endpoint) return;
 		if (!is_allowed_region_endpoint(endpoint)) {
-			if (import.meta.env.DEV) console.warn("[ogygia] refused non-same-origin region endpoint", endpoint);
+			if (import.meta.env.DEV) warn("region_endpoint_foreign", { endpoint });
 			return;
 		}
-		this.#fetching = true;
+		const frames = slots.frames;
+		if (!frames) return;
 		if (!this.#fetch_started) this.#fetch_started = performance.now();
-		this.#fetch_abort?.abort();
-		this.#fetch_abort = new AbortController();
-		const outer = this.#fetch_abort.signal;
-		const previous = this.#frame_address;
-		const address = this.#frame_address = frameAddress(endpoint);
-		if (this.#frame_unsub && previous !== address) {
-			this.#frame_unsub();
-			this.#frame_unsub = null;
+		const address = this.#bind(endpoint);
+		const attempts = s.kind === "armed" || s.kind === "retrying" ? s.attempts : 0;
+		this.#hole.go("fetching", {
+			attempts,
+			revalidate
+		});
+		const mine = this.#hole.now;
+		let html;
+		try {
+			html = await turn.wait(this.#hole.scope.task((signal) => this.#ensure_frame(frames, endpoint, address, revalidate, signal)));
+		} catch (err) {
+			if (this.#hole.now !== mine) return;
+			return this.#fetch_failed(turn, err, endpoint, revalidate, attempts + 1);
 		}
-		if (!this.#frame_unsub) this.#frame_unsub = slots.frames?.subscribe(address, (f) => void (this.#applying = this.#apply(f.html))) ?? null;
-		if (opts.revalidate) this.#revalidating = true;
+		if (html !== STALE && this.#hole.now === mine) this.#hole.go("idle");
+	}
+	/**
+	* The network side of one visit to `fetching`, through the frame store: N regions with the same
+	* address ⇒ one request, and a stale response can't overwrite a newer one (the store tickets at
+	* request time). `signal` is the visit's: leaving it (the region left the page) lets THIS region
+	* go (`STALE`), never a twin — the shared fetch is aborted only once its last caller left.
+	*/
+	async #ensure_frame(frames, endpoint, address, revalidate, signal) {
+		if (!revalidate && frames.join && !endpoint.includes("&ttl=") && !capability_expired(endpoint)) await frames.join(endpoint);
+		const fetcher = this.#frame_fetcher(endpoint, revalidate, () => this.#visitor ? "user" : viewport_class(this));
+		const run = () => frames.ensure(address, fetcher, {
+			force: revalidate,
+			signal
+		});
 		try {
-			const frames = slots.frames;
-			if (!opts.revalidate && frames?.join && !endpoint.includes("&ttl=") && !capability_expired(endpoint)) await frames.join(endpoint);
-			const run = () => frames?.ensure(address, this.#frame_fetcher(endpoint, !!opts.revalidate, () => this.#user_woken ? "user" : viewport_class(this)), { force: opts.revalidate });
-			try {
-				await run();
-			} catch (err) {
-				if (err?.name !== "OgygiaBatchMiss" || outer.aborted) throw err;
-				await run();
-			}
-			this.#adopt_renewed();
+			return await run();
 		} catch (err) {
-			if (err?.name === "AbortError" || outer.aborted) return;
-			const refused = err instanceof RegionAnswerRefused;
-			const deny = refused && err.reason === "forbidden" ? err.deny || "no reason given" : void 0;
-			if (import.meta.env.DEV) {
-				if (deny !== void 0) console.warn(`[ogygia] region answer refused for ${endpoint}: ${deny.startsWith("not ogygia") ? deny : `the islands endpoint refused its capability (403: ${deny})`}. ` + (deny.startsWith("foreign-key") ? "The page and its islands endpoint came from different deployments (two keys): route the endpoint to the deployment that served the page, or give every deployment one OGYGIA_SECRET. " : "") + "The fallback stands.");
-				else if (refused) console.warn(`[ogygia] region answer refused for ${endpoint}: the request was ${err.reason === "redirected" ? "redirected to" : "answered with a whole document at"} ${err.final_url}. A handle in front of ogygia.handle() (an auth redirect, a locale bounce, a 404 handler) took the region request — exempt the islands endpoint there. The fallback stands.`);
-				else console.warn("[ogygia] region fetch failed for", endpoint, err);
-			}
-			this.#fetch_attempts++;
-			const final = refused || !this.isConnected || this.#fetch_attempts >= 3;
-			if (final) {
-				let id = "";
-				let final_path;
-				try {
-					id = new URL(endpoint, location.href).searchParams.get("id") ?? "";
-					if (refused) final_path = new URL(err.final_url, location.href).pathname;
-				} catch {}
-				if (BEACON && id) beacon_hole_failed({
-					id,
-					reason: refused ? err.reason : "error",
-					...final_path ? { final_path } : {},
-					...refused ? {} : { message: String(err?.message ?? err).split("\n")[0].slice(0, 200) },
-					...deny !== void 0 ? { message: deny.slice(0, 200) } : {},
-					attempts: this.#fetch_attempts,
-					t: Math.round(performance.now())
-				});
-			}
-			if (DEVTOOLS) emit({
-				domain: "runtime",
-				name: "region.server.failed",
-				entry: this.getAttribute("entry") || void 0,
+			if (err?.name !== "OgygiaBatchMiss" || signal.aborted) throw err;
+			return await run();
+		}
+	}
+	/**
+	* A fetch of this hole failed (never its own leaving: that is no failure). Said in dev, told to the
+	* profiler and the devtools; then a retry waits in `retrying` (called off by an answer that comes
+	* another way, a new schedule, or the region leaving), or, refused or out of tries, it gives up.
+	*/
+	async #fetch_failed(turn, err, endpoint, revalidate, attempts) {
+		const refused = err instanceof RegionAnswerRefused;
+		const deny = refused && err.reason === "forbidden" ? err.deny || "no reason given" : void 0;
+		if (import.meta.env.DEV) {
+			if (deny !== void 0) warn("region_answer_denied", {
 				endpoint,
+				deny
+			});
+			else if (refused) warn("region_answer_redirected", {
+				endpoint,
+				how: err.reason === "redirected" ? "redirected" : "document",
+				final_url: err.final_url
+			});
+			else warn("region_fetch_failed", { endpoint }, err);
+		}
+		const final = refused || !this.isConnected || attempts >= region_fetch.attempts;
+		if (final) {
+			let id = "";
+			let final_path;
+			try {
+				id = new URL(endpoint, location.href).searchParams.get("id") ?? "";
+				if (refused) final_path = new URL(err.final_url, location.href).pathname;
+			} catch {}
+			if (BEACON && id) beacon_hole_failed({
+				id,
 				reason: refused ? err.reason : "error",
-				...refused ? { final_url: err.final_url } : { message: String(err?.message ?? err).split("\n")[0].slice(0, 200) },
+				...final_path ? { final_path } : {},
+				...refused ? {} : { message: String(err?.message ?? err).split("\n")[0].slice(0, 200) },
 				...deny !== void 0 ? { message: deny.slice(0, 200) } : {},
-				attempt: this.#fetch_attempts,
-				final
+				attempts,
+				t: Math.round(performance.now())
 			});
-			this.#scheduled = false;
-			if (!refused && this.isConnected && this.#fetch_attempts < 3) {
-				const delay = 500 * this.#fetch_attempts;
-				setTimeout(() => {
-					if (!this.isConnected || this.#done || this.#fetching) return;
-					if (opts.revalidate) this.#fetch_html({ revalidate: true });
-					else this.connectedCallback();
-				}, delay);
+		}
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "region.server.failed",
+			entry: this.getAttribute("entry") || void 0,
+			endpoint,
+			reason: refused ? err.reason : "error",
+			...refused ? { final_url: err.final_url } : { message: String(err?.message ?? err).split("\n")[0].slice(0, 200) },
+			...deny !== void 0 ? { message: deny.slice(0, 200) } : {},
+			attempt: attempts,
+			final
+		});
+		this.#scheduled = false;
+		if (!final) {
+			if (this.#answer.now.kind !== "none") {
+				this.#hole.go("idle");
 				return;
 			}
-			slots.lakes.after_fetch_exhausted(this, opts, () => this.#wake_waiting_regions());
-		} finally {
-			this.#fetching = false;
+			this.#hole.go("retrying", {
+				attempts,
+				revalidate
+			});
+			const retrying = this.#hole.scope;
+			const wait = backoffAfter(region_fetch, attempts);
+			if (await turn.wait(retrying.task(() => new Promise((resolve) => retrying.timeout(resolve, wait)))) === STALE) return;
+			if (revalidate) return this.#fetch_html(turn, true);
+			return this.#connect(turn);
 		}
+		this.#hole.go("failed");
+		slots.lakes.after_fetch_exhausted(this, { revalidate }, () => this.#wake_waiting_regions());
 	}
 	/** Re-enter connectedCallback for descendants that early-returned on an unsettled lake. */
 	#wake_waiting_regions() {
 		for (const el of this.querySelectorAll("ogygia-region")) if (el instanceof OgygiaRegion) el.connectedCallback();
 	}
-	#on_idle(fire) {
-		if ("requestIdleCallback" in window) this.#idle_handle = requestIdleCallback(() => {
-			this.#idle_handle = null;
-			fire();
-		}, { timeout: 2e3 });
-		else this.#idle_handle = setTimeout(() => {
-			this.#idle_handle = null;
+	#on_idle(fire, owner) {
+		const s = owner.scope;
+		if (!("requestIdleCallback" in window)) {
+			s.timeout(() => fire(), 200);
+			return;
+		}
+		const first = () => {
+			off_idle();
+			off_cap();
 			fire();
-		}, 200);
+		};
+		const off_idle = s.timeout(first, "idle");
+		const off_cap = s.timeout(first, 2e3);
 	}
 	/** `visible`: the shared observer for this margin (observe.ts) — fires once, on first entry. */
-	#on_visible(fire, root_margin) {
+	#on_visible(fire, root_margin, owner) {
 		const rootMargin = root_margin || this.getAttribute("margin") || "0px";
-		this.#stop_visible = once_visible(this, rootMargin, () => {
-			this.#stop_visible = null;
-			fire();
-		});
+		owner.scope.defer(once_visible(this, rootMargin, () => void fire()));
 	}
-	#on_media(q, fire) {
-		if (!q) return fire();
+	#on_media(q, fire, owner) {
+		if (!q) return void fire();
 		const mql = matchMedia(q);
-		if (mql.matches) return fire();
-		const on = (e) => {
-			if (e.matches) {
-				mql.removeEventListener("change", on);
-				this.#mql = null;
-				fire();
-			}
-		};
-		mql.addEventListener("change", on);
-		this.#mql = {
-			mql,
-			on
-		};
+		if (mql.matches) return void fire();
+		const off = owner.scope.on(mql, "change", (e) => {
+			if (!e.matches) return;
+			off();
+			fire();
+		});
 	}
 	/**
 	* Wake this island: load its module and the hydrate core in parallel, then take a SCHEDULER
 	* TURN (one island per task, viewport first — schedule.ts) and run the synchronous hydrate step
 	* (hydrate-core.ts) inside it.
 	*/
-	async #hydrate() {
-		if (this.#app || this.#hydrating) return;
-		this.#hydrating = true;
+	async #hydrate(turn) {
+		const from = this.#wake.now.kind;
+		if (this.#app || from !== "cold" && from !== "armed") return;
+		this.#wake.go("waking");
+		const mine = this.#wake.now;
+		/** What this wake waits on is its visit's: leaving `waking` ends it. */
+		const visit = this.#wake.scope;
+		/** After each wait, back in its turn: the region left the page (`STALE`: its mailbox closed, the
+		*  one it came back with wakes it), or is on its way out (its teardown a microtask away), or the
+		*  visit is over. Checked after every wait before the turn. */
+		const gone = (back) => back === STALE || !this.isConnected || this.#wake.now !== mine;
+		let failure = null;
 		const t0 = now_ms();
 		const dt_t0 = DEVTOOLS ? t0 : 0;
 		let t_loaded = t0;
@@ -864,49 +1133,60 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		});
 		if (CLIENT_PLUGINS) client_region_mount(this);
 		try {
-			if (typeof document !== "undefined" && document.readyState === "loading") await dom_ready();
-			if (!this.isConnected) return;
+			if (typeof document !== "undefined" && document.readyState === "loading") {
+				if (gone(await turn.wait(dom_ready()))) return;
+			}
+			if (gone()) return;
 			const entry = island_entry_of(this);
 			if (!entry) return;
-			const cls = () => this.#user_woken ? "user" : viewport_class(this);
-			const release = await load_slot({
+			const cls = () => this.#visitor ? "user" : viewport_class(this);
+			const slot = new LoadSlot({
 				kind: "code",
 				cls,
 				label: entry
-			}).ready;
+			});
+			const release = await turn.wait(slot.ready);
+			if (release === STALE) return void slot.ready.then(hand_back);
 			let mod, core;
 			try {
-				if (!this.isConnected) return;
+				if (gone()) return;
 				hydrate_started(this);
-				[mod, core] = await Promise.all([
+				const loaded = await turn.wait(Promise.all([
 					load_island(entry, cls()),
-					hydrate_core(),
-					slots.wire_classes?.(this)
-				]);
+					hydrate_core.get(),
+					slots.wire_classes?.(this),
+					devalue_for_wake()
+				]));
+				if (loaded === STALE) return;
+				[mod, core] = loaded;
 			} finally {
 				release();
 			}
 			t_loaded = now_ms();
-			if (!this.isConnected) return;
-			await this.#kit_page_ready(core);
-			if (!this.isConnected) return;
+			if (gone()) return;
+			if (gone(await turn.wait(this.#kit_page_ready(core, visit)))) return;
 			core.seed_remote_once();
 			core.seed_page_once();
-			await hydrate_turn(this);
-			if (!this.isConnected || this.#app) return;
+			let visitor;
+			do {
+				visitor = this.#visitor;
+				if (visitor && gone(await turn.wait(visitor.catch(nothing)))) return;
+				if (gone()) return;
+				if (gone(await turn.wait(hydrate_turn(this))) || this.#app) return;
+			} while (this.#visitor !== visitor);
 			t_turn = now_ms();
 			const ssr_html = this.#ssr_html;
 			const touched = ssr_html === null || region_changed(this);
-			if (import.meta.env.DEV) set_hydrating(this);
+			if (import.meta.env.DEV) set_hydrating(this, this.#life);
 			this.#app = core.hydrate_island(this, entry, mod, ssr_html, touched);
 			this.#ssr_html = null;
 			this.#unwatch();
 			if (!this.#app) return;
+			if (RULES) note_mount(this);
 			const t_done = now_ms();
 			await Promise.resolve();
 			const t_mounted = now_ms();
-			await snippets_settled(this);
-			if (!this.isConnected || !this.#app) return;
+			if (gone(await turn.wait(snippets_settled(this, visit))) || !this.#app) return;
 			this.setAttribute("data-hydrated", "");
 			if (BEACON) beacon_hydrated(this, t0, t_loaded, t_done, ssr_html, t_turn);
 			if (DEVTOOLS) emit({
@@ -917,6 +1197,8 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 			});
 			this.dispatchEvent(new CustomEvent("ogygia:hydrated", { bubbles: true }));
 		} catch (err) {
+			if (this.#wake.now !== mine) return;
+			failure = { error: err };
 			if (this.#watching) mark_region_changed(this);
 			this.#unwatch();
 			if (BEACON) beacon_failed(this, err?.message ?? String(err), t0, t_turn);
@@ -927,19 +1209,19 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 				message: err?.message ?? String(err),
 				...t_turn !== void 0 ? { turn: t_turn } : {}
 			});
-			const msg = err?.message ?? "";
 			const entry = this.getAttribute("entry");
-			if (ENTRY_FETCH_FAILED_RE.test(msg)) {
+			if (is_failed_import(err)) {
 				if (import.meta.env.DEV) {
-					console.error(`[ogygia] island entry failed to load: ${entry}\nThe module could not be FETCHED (not a hydration error). In dev this almost always means Vite re-optimized dependencies and rotated its optimizer hash while this tab was open, so its dep imports 404. Recovering… Original error:`, err);
+					console.error(new OgygiaError("island_load_failed_stale_deps", { entry }), err);
 					recover_from_stale_deps(entry);
-				} else console.error("[ogygia] island entry failed to load:", entry, err);
-			} else console.error("[ogygia] hydration failed for", entry, err);
+				} else console.error(new OgygiaError("island_load_failed", { entry }), err);
+			} else console.error(new OgygiaError("island_hydrate_failed", { entry }), err);
 		} finally {
-			this.#hydrating = false;
-			hydrate_settled(this);
-			this.#disarm_interaction?.();
-			this.#disarm_interaction = null;
+			if (this.#wake.now === mine) {
+				hydrate_settled(this);
+				if (failure) this.#wake.go("failed", failure);
+				else this.#wake.go(this.#app ? "awake" : "cold");
+			}
 		}
 	}
 	/**
@@ -947,7 +1229,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* carries server-rendered HTML). No fetch — the HTML is already here.
 	*
 	* - **First tick:** parse + swap the HTML in. Interactive (`hydrate` + `module`) → hydrate a
-	*   {@link LiveHost} so later ticks can push props. Static → done (no JS ever ships).
+	*   pushable props so later ticks can push them. Static → done (no JS ever ships).
 	* - **Later tick, same interactive module:** keep-alive — push the new props to the mounted
 	*   component (focus + local state survive; Svelte reconciles). No swap, no re-hydrate.
 	* - **Later tick, static:** morph the new HTML in place (see {@link morph_children}).
@@ -955,82 +1237,145 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	*/
 	async applyLive(desc) {
 		if (!FRAMES) return;
+		this.#live_last = desc;
+		await this.#box.ask((turn) => this.#apply_live(desc, turn));
+	}
+	/**
+	* A live region put back on the page (#337) goes on with its last tick: leaving it disposed its
+	* island or dropped its subscription. A static one binds to its address again, where the store
+	* hands it the newest frame (or, when it let that go, the last tick's HTML is painted again); an
+	* interactive one swaps and hydrates its island again. Still in its mode (a move), it has nothing
+	* to catch up on.
+	*/
+	#live_put_back(turn) {
+		const last = this.#live_last;
+		if (last === null || this.#live.now.kind !== "idle") return;
+		return this.#apply_live(last, turn, true);
+	}
+	/** One live tick, in its turn. `again`: its last tick, gone on with as it is put back. */
+	async #apply_live(desc, turn, again = false) {
 		this.setAttribute("render", "defer");
 		this.setAttribute("entry", desc.module || desc.id);
 		if (desc.url) this.setAttribute("endpoint", desc.url);
 		if (desc.hydrate) this.setAttribute("wake", desc.hydrate);
 		else this.removeAttribute("wake");
 		if (desc.hydrateMargin) this.setAttribute("hydrate-margin", desc.hydrateMargin);
-		const interactive = !!desc.hydrate && !!desc.module;
-		if (!interactive) {
-			if (desc.url && !this.#frame_unsub) {
-				this.#frame_address = frameAddress(desc.url);
-				this.#frame_unsub = slots.frames?.subscribe(this.#frame_address, (f) => this.#morph_live(f.html)) ?? null;
+		if (!(!!desc.hydrate && !!desc.module)) {
+			if (this.#live.now.kind !== "static") this.#live.go("static");
+			let replayed = false;
+			if (desc.url && !this.#live_unsub) {
+				const box = this.#box;
+				let binding = true;
+				const off = slots.frames?.subscribe(frameAddress(desc.url), (f) => {
+					if (binding && !again) return;
+					replayed ||= binding;
+					box.post((t) => this.#morph_live(f.html, t));
+				});
+				binding = false;
+				if (off) {
+					this.#live_unsub = off;
+					this.#live.scope.defer(() => {
+						off();
+						this.#live_unsub = null;
+					});
+				}
 			}
-			this.#morph_live(desc.html);
+			if (!replayed) await this.#morph_live(desc.html, turn);
 			return;
 		}
-		if (this.#live_ready && interactive && this.#live_app && desc.module === this.#live_module) {
-			this.#live_app.set_props?.(desc.props);
+		const s = this.#live.now;
+		if (s.kind === "live" && s.module === desc.module) {
+			s.app.set_props?.(desc.props);
 			this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
 			return;
 		}
-		if (this.#live_app) {
-			this.#live_app.dispose();
-			this.#live_app = null;
+		if (s.kind === "hydrating" && s.module === desc.module) {
+			this.#live_props = desc.props;
+			return;
 		}
+		this.#live.go("hydrating", { module: desc.module });
+		const mine = this.#live.now;
+		const painting = this.#paint_next();
+		this.#live_props = null;
 		this.#live_ready = true;
-		this.#live_module = desc.module;
-		const { frag, ready } = region_fragment(desc.html);
-		await ready;
-		if (!this.isConnected) return;
+		const { frag, ready, sheets } = region_fragment(desc.html);
+		if (await turn.wait(ready) === STALE || this.#live.now !== mine) return;
+		this.#painted(painting);
+		use_sheets(this, sheets);
 		slots.lakes.settle_in(frag);
 		this.replaceChildren(frag);
 		restore_adopt_sheets();
 		init_shadow_registries(this);
-		if (interactive) await this.#live_hydrate(desc.props);
-		else {
-			this.setAttribute("data-hydrated", "");
-			this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
-		}
+		await this.#live_hydrate(desc.props, mine, desc.module, turn);
 	}
 	/**
 	* On a Kit-hydrated document, a region of ours (a lake's inside, a hole's answer) waits for Kit to
 	* apply its page before it hydrates — `null` (no await) once applied. The wait lives in the lazy
 	* hydrate core (it observes Kit's reactive page, i.e. it needs Svelte), so it never reaches the boot.
+	* It waits for `visit` (the wake's, or the live tick's): a region that left stops waiting, and the
+	* wait ends with the last region in it.
 	*/
-	#kit_page_ready(core) {
+	#kit_page_ready(core, visit) {
 		if (!kit_hydrates_page() || !ours_on_kit_document(this)) return null;
-		return core.kit_page_thread();
+		return core.kit_page_thread(visit.signal);
 	}
-	/** Hydrate a live region's swapped-in HTML through the hydrate core's LiveHost path. */
-	async #live_hydrate(props) {
-		await dom_ready();
-		if (!this.isConnected) return;
-		const entry = island_entry_of(this);
-		if (!entry) return;
-		const cls = () => viewport_class(this);
-		const release = await load_slot({
-			kind: "code",
-			cls,
-			label: entry
-		}).ready;
-		let mod, core;
+	/**
+	* Hydrate a live region's swapped-in HTML through the hydrate core's live path — for the visit to
+	* `hydrating` that swapped it (`mine`): a later tick that took over (another module, a static
+	* tick) or the region leaving ends it before it mounts. One that could not mount goes back to
+	* `idle`, so the next tick starts over.
+	*/
+	async #live_hydrate(props, mine, module, turn) {
+		/** Back in its turn after a wait: the region left the page (`STALE`), is on its way out, or
+		*  another tick took over. */
+		const ours = (back) => back !== STALE && this.isConnected && this.#live.now === mine;
 		try {
-			if (!this.isConnected) return;
-			[mod, core] = await Promise.all([load_island(entry, cls()), hydrate_core()]);
+			if (!ours(await turn.wait(dom_ready()))) return;
+			const entry = island_entry_of(this);
+			if (!entry) return;
+			const cls = () => viewport_class(this);
+			const slot = new LoadSlot({
+				kind: "code",
+				cls,
+				label: entry
+			});
+			const release = await turn.wait(slot.ready);
+			if (release === STALE) return void slot.ready.then(hand_back);
+			let mod, core;
+			try {
+				if (!ours()) return;
+				const loaded = await turn.wait(Promise.all([
+					load_island(entry, cls()),
+					hydrate_core.get(),
+					devalue_for_wake()
+				]));
+				if (loaded === STALE) return;
+				[mod, core] = loaded;
+			} finally {
+				release();
+			}
+			if (!ours()) return;
+			if (!ours(await turn.wait(this.#kit_page_ready(core, this.#live.scope)))) return;
+			if (CLIENT_PLUGINS) client_region_mount(this);
+			const app = core.hydrate_live(this, entry, mod, props);
+			if (!app) return;
+			this.#live.go("live", {
+				module,
+				app
+			});
+			this.#live.scope.defer(() => {
+				if (CLIENT_PLUGINS) client_region_unmount(this, this.getAttribute("entry") ?? "");
+				app.dispose();
+			});
+			const pending = this.#live_props;
+			this.#live_props = null;
+			if (pending) app.set_props?.(pending);
+			this.setAttribute("data-hydrated", "");
+			this.dispatchEvent(new CustomEvent("ogygia:hydrated", { bubbles: true }));
+			this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
 		} finally {
-			release();
+			if (this.#live.now === mine) this.#live.go("idle");
 		}
-		if (!this.isConnected) return;
-		await this.#kit_page_ready(core);
-		if (!this.isConnected) return;
-		if (CLIENT_PLUGINS) client_region_mount(this);
-		this.#live_app = core.hydrate_live(this, entry, mod, props);
-		if (!this.#live_app) return;
-		this.setAttribute("data-hydrated", "");
-		this.dispatchEvent(new CustomEvent("ogygia:hydrated", { bubbles: true }));
-		this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
 	}
 	/**
 	* A MOVE IS NOT A REMOVAL. Another script relocating the element (a custom element that, at its
@@ -1054,37 +1399,17 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		connected_regions.delete(this);
 		unregister_region(this);
 		if (this.#watching) mark_region_changed(this);
-		this.#unwatch();
-		if (CLIENT_PLUGINS && (this.#live_app || this.#app)) client_region_unmount(this, this.getAttribute("entry") ?? "");
-		if (this.#live_app) {
-			this.#live_app.dispose();
-			this.#live_app = null;
-		}
-		this.#fetch_abort?.abort();
-		this.#fetch_abort = null;
-		this.#frame_unsub?.();
-		this.#frame_unsub = null;
-		if (this.#frame_address) {
-			slots.frames?.abandon(this.#frame_address);
-			this.#frame_address = null;
-		}
-		if (this.#idle_handle != null) {
-			if ("cancelIdleCallback" in window) cancelIdleCallback(this.#idle_handle);
-			else clearTimeout(this.#idle_handle);
-			this.#idle_handle = null;
-		}
-		this.#stop_visible?.();
-		this.#stop_visible = null;
-		on_demand_armed.delete(this);
-		this.#disarm_interaction?.();
-		this.#disarm_interaction = null;
-		if (this.#mql) {
-			this.#mql.mql.removeEventListener("change", this.#mql.on);
-			this.#mql = null;
-		}
+		if (CLIENT_PLUGINS && this.#app) client_region_unmount(this, this.getAttribute("entry") ?? "");
+		if (this.#live.now.kind !== "idle") this.#live.go("idle");
+		if (this.#hole.now.kind !== "idle") this.#hole.go("idle");
+		if (this.#wake.now.kind !== "cold") this.#wake.go("cold");
+		this.#life.close();
+		this.#life = NOT_CONNECTED;
+		this.#box = CLOSED_BOX;
 		if (this.#app) {
 			this.#app.dispose();
 			this.#app = null;
+			if (RULES) note_unmount(this);
 		}
 		this.#scheduled = false;
 	}
@@ -1125,7 +1450,15 @@ function apply_dev_head_region_css() {
 	});
 }
 function boot(installers = [], client_plugins = []) {
+	disclose_version();
+	if (RULES) install_rules(import.meta.env.DEV);
 	runtime_session.adopt_document_head();
+	globalThis[Symbol.for("ogygia.messages")] ??= {
+		OgygiaError,
+		warn,
+		line
+	};
+	report_restores();
 	link_boot();
 	for (const install of installers) install();
 	pin_build_map();
@@ -1137,6 +1470,7 @@ function boot(installers = [], client_plugins = []) {
 		});
 		if (BEACON) beacon_entry_fallback(report);
 	});
+	on_reload_needed((url, error) => console.error(new OgygiaError("chunk_reload_needed", { url }), error));
 	if (import.meta.env.DEV) apply_dev_head_region_css();
 	if (BEACON) beacon_watch();
 	if (import.meta.env.DEV) {