@ogygia/core 0.0.0 → 0.11.1

package/dist/runtime/core.js

@@ -0,0 +1,1173 @@
+import { frameAddress } from "../frame.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 { wire_classes_for } from "./wire-classes.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 { import_entry, island_entry_of, on_entry_fallback, pin_region_urls } from "./entry-locations.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 { PAGE_FACTS_SELECTOR } from "../page-facts-script.js";
+import { NAV_HANDLE_KEY, mpa_nav, publish_nav } from "./nav-handle.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 { preload_island_graph } from "./island-graph-preload.js";
+import { fetch_priority_of, load_slot, 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 { 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";
+// src/runtime/core.ts
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+const BEACON = typeof __OGYGIA_BEACON__ !== "undefined" ? __OGYGIA_BEACON__ : true;
+/** 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;
+/** Per-node stash of a nested island's PRISTINE server markup, captured from a fetched fragment WHILE it
+*  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. */
+function snapshot_markup(region) {
+	if (!region.firstChild) return null;
+	const html = region.innerHTML;
+	return html.length > SSR_SNAPSHOT_MAX ? null : html;
+}
+/** The same copy for a hole's answer BEFORE it is put in the document: serialized through a
+*  detached box (a fragment has no `innerHTML`; nothing connects, so no element reacts) and the
+*  nodes handed back. Taken after the swap it would be the DOM as the custom elements inside the
+*  answer left it — their connect reactions run at insertion, before any line after it. */
+function fragment_markup(frag) {
+	if (!frag.firstChild) return null;
+	const box = document.createElement("div");
+	box.appendChild(frag);
+	const html = box.innerHTML;
+	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) {
+	return {
+		entry: el.getAttribute("entry") || void 0,
+		fp: el.getAttribute("data-og-fp") || void 0
+	};
+}
+/** High-res clock for devtools timings (guarded — dead when devtools is off). */
+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;
+}
+/** 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();
+}
+/** 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
+*  `display: contents` wrapper from a descendant the pointer actually moves over. */
+const ON_DEMAND_EVENTS = [
+	"pointerover",
+	"focusin",
+	"pointerdown",
+	"touchstart",
+	"keydown"
+];
+const ON_DEMAND_SELECTOR = "ogygia-region[render=\"defer\"][when=\"interaction\"]";
+/**
+* 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 mega-menus). Intent lands anywhere
+* inside a hole; the nearest ARMED hole above the target fires once and is forgotten.
+*/
+const on_demand_armed = /* @__PURE__ */ new Map();
+let on_demand_installed = false;
+function on_demand_event(e) {
+	if (on_demand_armed.size === 0) return;
+	let region = e.target instanceof Element ? e.target.closest(ON_DEMAND_SELECTOR) : null;
+	while (region && !on_demand_armed.has(region)) region = region.parentElement?.closest(ON_DEMAND_SELECTOR) ?? null;
+	if (!region) return;
+	const fire = on_demand_armed.get(region);
+	on_demand_armed.delete(region);
+	fire();
+}
+function arm_on_demand(region, fire) {
+	on_demand_armed.set(region, fire);
+	if (on_demand_installed) return;
+	on_demand_installed = true;
+	for (const type of ON_DEMAND_EVENTS) document.addEventListener(type, on_demand_event, {
+		capture: true,
+		passive: true
+	});
+}
+/** Load a hydrate island module from `<ogygia-region entry>` (dev + prod), its whole chunk graph
+*  preloaded in the same task so nothing waits on a discovery waterfall (island-graph-preload.ts), at
+*  the priority its load class downloads at (load-scheduler.ts). */
+const load_island = (entry, cls = "visible") => {
+	preload_island_graph(entry, void 0, fetch_priority_of(cls));
+	return import_entry(entry, island_module_url(entry));
+};
+/**
+* DEV watchdog for a stranded tab (dev only; the branch is dead in a production build). Under
+* `csr = false` Kit ships no client bootstrap, so a Vite dep re-optimization — which rotates the
+* optimizer's browserHash — can leave a tab that was loaded under the old hash importing island dep
+* URLs (`svelte.js?v=<old>`) that now 404, and Vite's own full-reload does not always reach a
+* csr=false page. The island entry then throws `Failed to fetch dynamically imported module` on
+* wake, and nothing recovers it.
+*
+* We CONFIRM it is staleness, not a genuinely-missing module: re-fetch the entry URL, and reload
+* only when the server still serves it (200) — a real 404 is a different bug and must stay visible.
+* A timestamp in `sessionStorage` bounds it to one reload per few seconds, so a genuinely broken
+* entry (200 that keeps failing to import) never loops.
+*/
+const STALE_DEP_RELOAD_KEY = "ogygia:dev:dep-reload";
+const STALE_DEP_RELOAD_WINDOW_MS = 6e3;
+async function recover_from_stale_deps(entry) {
+	if (!import.meta.env.DEV || !entry || typeof location === "undefined") return;
+	try {
+		const last = Number(sessionStorage.getItem(STALE_DEP_RELOAD_KEY) || 0);
+		if (Date.now() - last < STALE_DEP_RELOAD_WINDOW_MS) return;
+		if (!(await fetch(island_module_url(entry), { cache: "no-store" })).ok) return;
+		sessionStorage.setItem(STALE_DEP_RELOAD_KEY, String(Date.now()));
+		location.reload();
+	} catch {}
+}
+function dom_ready() {
+	if (typeof document === "undefined" || document.readyState !== "loading") return Promise.resolve();
+	return new Promise((r) => document.addEventListener("DOMContentLoaded", r, { once: true }));
+}
+/** 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) {
+	const host = region;
+	let timer;
+	const cap = new Promise((r) => timer = setTimeout(r, SNIPPET_BOOT_CAP_MS));
+	let capped = false;
+	cap.then(() => capped = true);
+	try {
+		for (let batch = host[SNIPPET_BOOTS]; batch?.length && !capped; batch = host[SNIPPET_BOOTS]) {
+			host[SNIPPET_BOOTS] = [];
+			await Promise.race([Promise.allSettled(batch), cap]);
+			await Promise.resolve();
+		}
+	} finally {
+		clearTimeout(timer);
+		delete host[SNIPPET_BOOTS];
+	}
+}
+/**
+* Parse a fetched region's HTML into a fragment, HOISTING any `<link data-ogygia-region-css>` (or
+* 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.)
+*/
+function region_fragment(html) {
+	const frag = parse_region_html(html);
+	for (const facts of frag.querySelectorAll(PAGE_FACTS_SELECTOR)) {
+		facts.remove();
+		runtime_session.page_facts.push(facts.textContent ?? "");
+	}
+	const links = frag.querySelectorAll("link[data-ogygia-region-css]");
+	const pending = [];
+	if (links.length && import.meta.env.DEV) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const link of links) {
+			const href = link.getAttribute("href");
+			link.remove();
+			if (!href) continue;
+			const url = island_module_url(href);
+			if (seen.has(url)) continue;
+			seen.add(url);
+			pending.push(import(
+				/* @vite-ignore */
+				url
+).then(() => void 0, () => void 0));
+		}
+	} 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();
+		});
+		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 clone = document.createElement("link");
+			clone.rel = "stylesheet";
+			clone.href = href;
+			clone.setAttribute("data-ogygia-region-css", "");
+			pending.push(until_loaded(clone));
+			existing.set(href, 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();
+		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);
+		}
+		for (const style of styles) {
+			const id = style.getAttribute("data-ogygia-region-css") || "";
+			style.remove();
+			if (!id || present.has(id)) continue;
+			present.add(id);
+			const el = document.createElement("style");
+			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();
+	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
+	};
+}
+/** TEST: the pristine server markup {@link region_fragment} stashed on a nested island, if any. */
+function pristine_ssr_of(el) {
+	return el[PRISTINE_SSR];
+}
+var OgygiaRegion = class OgygiaRegion extends HTMLElement {
+	#scheduled = false;
+	/** The server-minted `endpoint` of a deferred hole, captured at connect. On a Kit-hydrated
+	*  (csr=true) document the wrapper's client leg cannot mint (the virtual is stubbed to ''), so
+	*  Kit's hydration pass reconciles the attribute to '' — after the runtime saw it at parse time.
+	*  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;
+	#watch() {
+		if (this.#watching) return;
+		this.#watching = true;
+		watch_region();
+	}
+	#unwatch() {
+		if (!this.#watching) return;
+		this.#watching = false;
+		unwatch_region();
+	}
+	/** 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;
+	/** 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_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;
+	/** 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 = "";
+	#hydrate_run = null;
+	#fire_hydrate = () => this.#hydrate_run ??= this.#hydrate().finally(() => this.#hydrate_run = null);
+	#fire_server = () => this.#server();
+	#fire_prefetch = () => 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
+	* (e.g. a player's `track` changes) instead of freezing at first-mount props. Called by the
+	* router just before `next` is discarded. Synchronous by contract — a kept island has hydrated,
+	* so the hydrate core is loaded.
+	*/
+	absorbKeptProps(next) {
+		if (!this.#app?.set_props || !loaded_core) return;
+		try {
+			this.#app.set_props(loaded_core.read_region_props(next));
+		} catch {}
+	}
+	connectedCallback() {
+		connected_regions.add(this);
+		pin_region_urls(this);
+		if (this.hasAttribute("live")) return;
+		if (this.#minted_endpoint === null && is_deferred(this)) {
+			const minted = this.getAttribute("endpoint");
+			if (minted) this.#minted_endpoint = minted;
+			else {
+				const identity = this.getAttribute("data-og-hole");
+				const facts = identity ? hole_facts_of(this.ownerDocument, identity) : null;
+				if (facts) {
+					this.setAttribute("endpoint", facts.endpoint);
+					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);
+			}
+		}
+		if (is_frozen(this) && slots.lakes.on_frozen_connect(this, this.#lake_arm())) return;
+		if (this.#scheduled) return;
+		const boundary = this.parentElement && this.parentElement.closest("ogygia-region");
+		const slot = this.parentElement && this.parentElement.closest("ogygia-slot,ogygia-snippet[data-og-static]");
+		const in_adopted_slot = !!(boundary && slot && boundary.contains(slot));
+		const entry_attr = this.getAttribute("entry") || "";
+		const foreign_entry = entry_attr.indexOf(":") > 0 && /^[a-z][a-z0-9+.-]*:/i.test(entry_attr) && new URL(entry_attr).origin !== location.origin;
+		if (boundary && is_awake(boundary) && !is_deferred(this) && !in_adopted_slot && !foreign_entry) {
+			this.setAttribute("data-nested", "");
+			if (DEVTOOLS) emit({
+				domain: "runtime",
+				name: "region.connected",
+				...dt_ids(this),
+				wake: this.getAttribute("wake") || void 0,
+				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).`);
+			return;
+		}
+		const deferred = is_deferred(this);
+		if (!deferred && this.#ssr_html === null) {
+			const pristine = this[PRISTINE_SSR];
+			this.#ssr_html = pristine ?? snapshot_markup(this);
+			if (pristine != null) mark_region_changed(this);
+		}
+		if (this.#ssr_html !== null) this.#watch();
+		if (slots.lakes.wait_for_boundary(this, boundary)) return;
+		this.#scheduled = true;
+		const when = region_schedule(this);
+		if (DEVTOOLS) {
+			emit({
+				domain: "runtime",
+				name: "region.connected",
+				...dt_ids(this),
+				wake: this.getAttribute("wake") || void 0,
+				deferred,
+				nested: false
+			});
+			emit({
+				domain: "runtime",
+				name: "wake.scheduled",
+				...dt_ids(this),
+				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 (prefetch && prefetch !== when && prefetch !== "interaction") this.#arm(prefetch, this.#fire_prefetch, this.getAttribute("margin") || void 0);
+	}
+	/**
+	* 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
+	* warm is harmless: the wake falls back to its own fetch. A hole already done or fetching has
+	* nothing left to warm.
+	*/
+	#prefetch_html() {
+		if (this.#done || this.#fetching || !this.isConnected) return;
+		const endpoint = this.#endpoint();
+		if (!endpoint || !is_allowed_region_endpoint(endpoint)) return;
+		const address = frameAddress(endpoint);
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "region.prefetch",
+			...dt_ids(this)
+		});
+		slots.frames?.ensure(address, this.#frame_fetcher(endpoint, false, "ahead"))?.catch(() => {});
+	}
+	/**
+	* The one network fetch for this hole's HTML — its own wake and a `prefetch` warm share it, so
+	* the frame store sees one fetcher shape per address. The endpoint's text, or the keep-fallback
+	* marker on a 204 (`keepFallback()` on the server). A revalidate bypasses the browser cache
+	* (the endpoint may answer `private, max-age`, and stale is the whole point of revalidating).
+	*/
+	#frame_fetcher(endpoint, revalidate, cls) {
+		const class_now = typeof cls === "function" ? cls : () => cls;
+		return async (signal) => {
+			const release = await load_slot({
+				kind: "content",
+				cls,
+				label: endpoint
+			}).ready;
+			try {
+				return await this.#fetch_region(endpoint, revalidate, fetch_priority_of(class_now()), signal);
+			} finally {
+				release();
+			}
+		};
+	}
+	#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",
+				priority,
+				signal
+			});
+			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. */
+	#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 }),
+			wake_children: () => this.#wake_waiting_regions()
+		};
+	}
+	/** Arm idle / visible / load / interaction / media for a schedule callback. */
+	#arm(when, fire, visible_margin) {
+		if (fire === this.#fire_hydrate && when !== "interaction") this.#catch_early_input(fire);
+		if (DEVTOOLS) {
+			const raw = fire;
+			fire = () => {
+				emit({
+					domain: "runtime",
+					name: "wake.fired",
+					...dt_ids(this),
+					when
+				});
+				return raw();
+			};
+		}
+		const start = () => background_start(fire);
+		if (when === "idle") this.#on_idle(fire);
+		else if (when === "visible") this.#on_visible(start, visible_margin);
+		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);
+	}
+	/**
+	* `wake="interaction"`: sleep until a pointer/key/focus/click lands inside the region, then
+	* hydrate and replay what arrived meanwhile (see runtime/interaction.ts). `pointerenter` warms
+	* the module so the wake is usually served from cache. On a csr=true page Kit already hydrated
+	* this island — do not arm (our click-cancel would eat live clicks); #hydrate's own guard
+	* handles the marking if it ever fires. Unless the island is ours even there: inside a lake
+	* (Kit adopts it as opaque DOM) or inside a hole's fetched answer (Kit never sees it).
+	*/
+	#on_interaction(fire) {
+		if (kit_hydrates_page() && !ours_on_kit_document(this)) {
+			this.setAttribute("data-kit-hydrated", "");
+			return;
+		}
+		const arm = slots.interaction;
+		if (!arm) {
+			fire();
+			return;
+		}
+		const disarm = arm(this, fire);
+		this.#disarm_interaction = typeof disarm === "function" ? disarm : null;
+	}
+	/**
+	* A scheduled island (`load` / `idle` / `visible` / media) also catches input until it is live — the
+	* interaction capture, armed beside its schedule: the first press, key or focus on it wakes it now,
+	* as a gesture, and a click is replayed once it is live. Not on a Kit-hydrated page (Kit owns the
+	* island there, as for `interaction`), not without the interaction feature, never once awake.
+	*/
+	#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;
+	}
+	/**
+	* 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.
+	*/
+	#adopt_renewed() {
+		const fresh = this.#renewed_endpoint;
+		if (!fresh) return;
+		this.#renewed_endpoint = null;
+		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;
+		}
+	}
+	/** 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). */
+	#endpoint() {
+		const attr = this.getAttribute("endpoint");
+		if (attr) return attr;
+		if (!this.#minted_endpoint) return null;
+		this.setAttribute("endpoint", this.#minted_endpoint);
+		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.
+	*/
+	async #server() {
+		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 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);
+		this.#arm(phase2, this.#fire_hydrate, margin);
+	}
+	/**
+	* 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
+	* version (SWR revalidate, live refresh) re-applies. Keeps all the DOM-side work — lakes settle
+	* offline before custom elements connect, then swap, mark, event. HOLE-TRUST: the HTML is our own
+	* signed same-origin SSR.
+	*/
+	async #apply(html) {
+		if (!this.isConnected) return;
+		if (html === "<!--ogygia:keep-fallback-->") {
+			this.#revalidating = false;
+			this.#done = true;
+			this.#kept = true;
+			if (!is_awake(this)) this.setAttribute("data-hydrated", "");
+			this.setAttribute("data-og-kept", "");
+			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;
+		slots.lakes.settle_in(frag);
+		slots.lakes.mark_frozen_settled(this);
+		const morph = slots.morph;
+		if (!this.#app && region_hydrate_schedule(this)) {
+			this.#ssr_html = fragment_markup(frag);
+			this.#watch();
+		}
+		if (morph) morph(this, Array.from(frag.childNodes));
+		else this.replaceChildren(frag);
+		restore_adopt_sheets();
+		init_shadow_registries(this);
+		absorb_page_facts_now();
+		this.#done = true;
+		if (revalidate) this.setAttribute("data-revalidated", "");
+		else if (!is_awake(this)) this.setAttribute("data-hydrated", "");
+		slots.lakes.after_html_swap(this, { revalidate });
+		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);
+		}
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "region.server.applied",
+			entry: this.getAttribute("entry") || void 0,
+			endpoint: this.getAttribute("endpoint") || void 0,
+			bytes: html.length,
+			revalidate,
+			...!revalidate && this.#fetch_started ? { wait_ms: Math.round(performance.now() - this.#fetch_started) } : {}
+		});
+		this.dispatchEvent(new CustomEvent("ogygia:server", { bubbles: true }));
+	}
+	/**
+	* Store applicator for a STATIC live/held region (`<ogygia-region live>` with no interactive
+	* module). Every frame at its address lands here — first paint (store replay), a live-query tick,
+	* or a single-flight mutation. First paint swaps in; a later frame morphs in place (same node
+	* 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) {
+		if (!this.isConnected) return;
+		if (!this.#live_ready && this.hasAttribute("data-og-baked")) {
+			this.#live_ready = true;
+			this.setAttribute("data-hydrated", "");
+			this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
+			return;
+		}
+		const { frag, ready } = region_fragment(html);
+		await ready;
+		if (!this.isConnected) return;
+		slots.lakes.settle_in(frag);
+		if (!this.#live_ready) {
+			this.replaceChildren(frag);
+			this.#live_ready = true;
+			this.setAttribute("data-hydrated", "");
+		} else {
+			const nodes = Array.from(frag.childNodes);
+			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();
+		}
+		restore_adopt_sheets();
+		init_shadow_registries(this);
+		absorb_page_facts_now();
+		this.dispatchEvent(new CustomEvent("ogygia:live", { bubbles: true }));
+	}
+	/**
+	* A refreshed region re-minted this hole (server/render-page.ts): at a new address — new props, or
+	* 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() {
+		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 });
+	}
+	/**
+	* 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.
+	* 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 = {}) {
+		if (this.#fetching || this.#done && !opts.revalidate) 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);
+			return;
+		}
+		this.#fetching = true;
+		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;
+		}
+		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;
+		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();
+		} 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,
+				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: this.#fetch_attempts,
+				final
+			});
+			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);
+				return;
+			}
+			slots.lakes.after_fetch_exhausted(this, opts, () => this.#wake_waiting_regions());
+		} finally {
+			this.#fetching = false;
+		}
+	}
+	/** 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;
+			fire();
+		}, 200);
+	}
+	/** `visible`: the shared observer for this margin (observe.ts) — fires once, on first entry. */
+	#on_visible(fire, root_margin) {
+		const rootMargin = root_margin || this.getAttribute("margin") || "0px";
+		this.#stop_visible = once_visible(this, rootMargin, () => {
+			this.#stop_visible = null;
+			fire();
+		});
+	}
+	#on_media(q, fire) {
+		if (!q) return 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
+		};
+	}
+	/**
+	* 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;
+		const t0 = now_ms();
+		const dt_t0 = DEVTOOLS ? t0 : 0;
+		let t_loaded = t0;
+		/** when its hydrate step began: a failed step held the thread from here (the reports count it busy) */
+		let t_turn;
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "region.hydrate.start",
+			...dt_ids(this)
+		});
+		if (CLIENT_PLUGINS) client_region_mount(this);
+		try {
+			if (typeof document !== "undefined" && document.readyState === "loading") await dom_ready();
+			if (!this.isConnected) return;
+			const entry = island_entry_of(this);
+			if (!entry) return;
+			const cls = () => this.#user_woken ? "user" : viewport_class(this);
+			const release = await load_slot({
+				kind: "code",
+				cls,
+				label: entry
+			}).ready;
+			let mod, core;
+			try {
+				if (!this.isConnected) return;
+				hydrate_started(this);
+				[mod, core] = await Promise.all([
+					load_island(entry, cls()),
+					hydrate_core(),
+					wire_classes_for(this)
+				]);
+			} finally {
+				release();
+			}
+			t_loaded = now_ms();
+			if (!this.isConnected) return;
+			await this.#kit_page_ready(core);
+			if (!this.isConnected) return;
+			core.seed_remote_once();
+			core.seed_page_once();
+			await hydrate_turn(this);
+			if (!this.isConnected || this.#app) return;
+			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);
+			this.#app = core.hydrate_island(this, entry, mod, ssr_html, touched);
+			this.#ssr_html = null;
+			this.#unwatch();
+			if (!this.#app) return;
+			const t_done = now_ms();
+			await Promise.resolve();
+			const t_mounted = now_ms();
+			await snippets_settled(this);
+			if (!this.isConnected || !this.#app) return;
+			this.setAttribute("data-hydrated", "");
+			if (BEACON) beacon_hydrated(this, t0, t_loaded, t_done, ssr_html, t_turn);
+			if (DEVTOOLS) emit({
+				domain: "runtime",
+				name: "region.hydrate.done",
+				...dt_ids(this),
+				ms: t_mounted - dt_t0
+			});
+			this.dispatchEvent(new CustomEvent("ogygia:hydrated", { bubbles: true }));
+		} catch (err) {
+			if (this.#watching) mark_region_changed(this);
+			this.#unwatch();
+			if (BEACON) beacon_failed(this, err?.message ?? String(err), t0, t_turn);
+			if (DEVTOOLS) emit({
+				domain: "runtime",
+				name: "region.hydrate.failed",
+				...dt_ids(this),
+				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 (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);
+					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);
+		} finally {
+			this.#hydrating = false;
+			hydrate_settled(this);
+			this.#disarm_interaction?.();
+			this.#disarm_interaction = null;
+		}
+	}
+	/**
+	* Apply a live region tick (called by Region.svelte for a deferred region whose ticket
+	* 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).
+	* - **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}).
+	* - **Later tick, module changed:** unmount, swap, re-hydrate.
+	*/
+	async applyLive(desc) {
+		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;
+			}
+			this.#morph_live(desc.html);
+			return;
+		}
+		if (this.#live_ready && interactive && this.#live_app && desc.module === this.#live_module) {
+			this.#live_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;
+		}
+		this.#live_ready = true;
+		this.#live_module = desc.module;
+		const { frag, ready } = region_fragment(desc.html);
+		await ready;
+		if (!this.isConnected) return;
+		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 }));
+		}
+	}
+	/**
+	* 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.
+	*/
+	#kit_page_ready(core) {
+		if (!kit_hydrates_page() || !ours_on_kit_document(this)) return null;
+		return core.kit_page_thread();
+	}
+	/** 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;
+		try {
+			if (!this.isConnected) return;
+			[mod, core] = await Promise.all([load_island(entry, cls()), hydrate_core()]);
+		} finally {
+			release();
+		}
+		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
+	* upgrade, moves its server-placed children out of its markup and back into its own light DOM)
+	* disconnects and reconnects it in one task. Tearing down there aborted a hole's in-flight
+	* fetch, re-armed its wake and fetched it again; disposed a woken island and woke it again. The
+	* teardown waits a microtask and runs only if the element is still out of the document. The
+	* reconnect itself runs as any connect: a region already scheduled stops at `#scheduled`, and one
+	* that was not (a nested island a lake lifted out and put back, now under a frozen boundary)
+	* decides afresh where it stands.
+	*/
+	disconnectedCallback() {
+		if (this.#leaving) return;
+		this.#leaving = true;
+		queueMicrotask(() => {
+			this.#leaving = false;
+			if (!this.isConnected) this.#teardown();
+		});
+	}
+	#teardown() {
+		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 (this.#app) {
+			this.#app.dispose();
+			this.#app = null;
+		}
+		this.#scheduled = false;
+	}
+};
+/**
+* Boot the always-on custom element after each selected feature has filled its {@link slots} entry.
+* Core never statically imports an optional feature — the generated entry (or {@link ./full.js})
+* passes each feature's `install` here, in {@link ../vite/runtime-entry.js FEATURE_ORDER}. Order is
+* load-bearing: `live` needs `morph` present first.
+*/
+/**
+* DEV ONLY: apply the region-CSS `<link data-ogygia-region-css>`s the SSR baked into the document.
+* In dev there is no extracted `.css` asset — `islandCss` hands a region its dev MODULE url as the
+* href, and a `<link rel="stylesheet">` to a JS module makes an EMPTY sheet (the server serves it as
+* `text/javascript`), so CSS authored in any hole or region silently never applied on first load.
+* Import each module instead — executing it injects the scoped `<style>` (Vite's dev CSS mechanism),
+* the exact rescue {@link region_fragment} already runs for a FETCHED answer, here for the links that
+* shipped on the page. Prod links a real `.css` asset, so `import.meta.env.DEV` DCEs this whole path.
+* Deferred to {@link dom_ready}: the runtime bootstrap is the FIRST node in `<head>`, so the region
+* links below it are not parsed yet at boot.
+*/
+function apply_dev_head_region_css() {
+	if (!import.meta.env.DEV || typeof document === "undefined") return;
+	dom_ready().then(() => {
+		const seen = /* @__PURE__ */ new Set();
+		for (const link of document.querySelectorAll("link[data-ogygia-region-css]")) {
+			const href = link.getAttribute("href");
+			if (!href || CSS_ASSET_HREF_RE.test(href)) continue;
+			link.remove();
+			const url = island_module_url(href);
+			if (seen.has(url)) continue;
+			seen.add(url);
+			import(
+				/* @vite-ignore */
+				url
+).catch(() => {});
+		}
+	});
+}
+function boot(installers = [], client_plugins = []) {
+	if (typeof document !== "undefined" && !(NAV_HANDLE_KEY in globalThis)) publish_nav(mpa_nav());
+	runtime_session.adopt_document_head();
+	link_boot();
+	for (const install of installers) install();
+	on_entry_fallback((report) => {
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "entry.fallback",
+			...report
+		});
+		if (BEACON) beacon_entry_fallback(report);
+	});
+	if (import.meta.env.DEV) apply_dev_head_region_css();
+	if (BEACON) beacon_watch();
+	if (import.meta.env.DEV) {
+		tap_svelte_warnings();
+		on_svelte_warning((w) => {
+			if (BEACON) beacon_warning(w);
+			if (DEVTOOLS) emit({
+				domain: "runtime",
+				name: "svelte.hydration.warning",
+				code: w.code,
+				message: w.message,
+				...w.file ? { file: w.file } : {},
+				...w.fp ? { fp: w.fp } : {}
+			});
+		});
+	}
+	if (DEVTOOLS) {
+		install_window_sink();
+		ingest_server_events();
+	}
+	if (CLIENT_PLUGINS) boot_client_plugins(client_plugins, false);
+	if (DEVTOOLS) {
+		const features = [];
+		if (slots.interaction) features.push("interaction");
+		if (slots.morph) features.push("morph");
+		if (slots.frames) features.push("frames");
+		if (slots.nav) features.push("router");
+		if (slots.forms.enabled) features.push("forms");
+		emit({
+			domain: "runtime",
+			name: "runtime.boot",
+			features
+		});
+	}
+	if (typeof customElements !== "undefined" && !customElements.get("ogygia-region")) customElements.define("ogygia-region", OgygiaRegion);
+}
+export { boot, pristine_ssr_of, region_fragment };