@ogygia/core 0.0.0 → 0.11.0

package/dist/runtime/router-nav.js

@@ -0,0 +1,740 @@
+import { PageCache } from "./page-cache.js";
+import { boot_link, router_link, slots } from "./slots.js";
+import { dispose_scope } from "../ref.js";
+import { reconcile_body, stamp_region_keys, swap_body } from "./reconcile.js";
+import { apply_soft_invalidate_doc, finish_spa_document, page_seed_of, prepare_spa_document } from "./seeds.js";
+import { spa_html_cacheable } from "./spa-cacheable.js";
+import { pin_region_urls } from "./entry-locations.js";
+import { emit } from "../events/bus.js";
+// src/runtime/router-nav.ts
+/**
+* THE NAVIGATION — the router's heavy half, loaded lazily by ./router.ts on the first prefetch or
+* intercepted click: page fetch + cache, head merge, the body reconcile / morph, seeds, a11y.
+* Nothing here runs at boot; a visitor who never leaves the page never downloads it.
+*
+* A navigation is TWO tasks. The first — this module's `navigate` after the fetch — does everything
+* that needs no live DOM change: parse the HTML, read the route facts, batch the incoming holes,
+* stamp reconcile keys, parse the incoming page seed, drop hints for modules already warm, preload
+* stylesheets. Then it yields. The second task is the view transition's callback and does ONLY the
+* DOM: head merge, seeds, body morph, title. The old single-task swap ran a whole-document regex,
+* two `'*'` walks and a seed parse inside `startViewTransition`, on the frame the transition
+* captures.
+*/
+const KitBoot = { document_has: (doc) => boot_link().KitBoot.document_has(doc) };
+const regions_in_shadow = () => boot_link().regions_in_shadow();
+const session = () => boot_link().runtime_session;
+const is_warmed_module = (entry, base) => boot_link().is_warmed_module(entry, base);
+const warm_island_module = (entry, base) => boot_link().warm_island_module(entry, base);
+const note_entry_location = (entry, src, base) => boot_link().note_entry_location(entry, src, base);
+const register_island_graph = (text, base) => boot_link().register_island_graph(text, base);
+const yield_task = () => boot_link().yield_task();
+const document_key = (url) => router_link().document_key(url);
+const jump_to_hash = (hash) => router_link().jump_to_hash(hash);
+const push_state = (state, url) => router_link().push_state(state, url);
+const replace_state = (state, url) => router_link().replace_state(state, url);
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+/** High-res clock for devtools nav timings (guarded — dead when off). */
+const dt_now = () => typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+/** Max bytes for the `x-ogygia-known` header — past this we OMIT it, so the server renders every
+*  region (the safe full-render fallback). Keeps request headers well under proxy/server limits. */
+const KNOWN_HEADER_CAP = 6144;
+/** SERVER-DELTA NAV is OPT-IN for the first release (a new client↔server protocol). Off → the client
+*  never sends `x-ogygia-known`, so `known_region_fps()` is always empty server-side and every region
+*  full-renders (the documented safe fallback). Compile-time constant (Vite `define`); typeof-guarded
+*  so a plain node import of dist/ without the define falls back to OFF. */
+const SERVER_DELTA = typeof __OGYGIA_SERVER_DELTA__ !== "undefined" ? __OGYGIA_SERVER_DELTA__ : false;
+/** The `Accept` a browser sends for a top-level document navigation (Chromium's value). */
+const DOCUMENT_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
+/**
+* SERVER-DELTA NAV (D2): headers for a nav/prefetch fetch. Always `x-ogygia-spa`. When `purpose` is
+* not a plain nav, `x-ogygia-purpose` names it (see {@link NavPurpose}). Plus, when the current
+* document has HYDRATED islands carrying a `data-og-fp`, `x-ogygia-known` lists their fingerprints so
+* the server can SKIP re-rendering the ones this page already has live. Only data-hydrated regions
+* are claimed (never assert a region we don't actually have), and the header is omitted past a size
+* cap → the server renders everything (progressive enhancement: every header here is an optimization
+* the server may ignore, and its absence is always correct).
+*/
+function nav_headers(purpose = "nav") {
+	const headers = {
+		accept: DOCUMENT_ACCEPT,
+		"x-ogygia-spa": "1"
+	};
+	if (purpose !== "nav") headers["x-ogygia-purpose"] = purpose;
+	if (!SERVER_DELTA || typeof document === "undefined") return headers;
+	const seen = /* @__PURE__ */ new Set();
+	for (const el of document.querySelectorAll("ogygia-region[data-og-fp][data-hydrated]")) {
+		const fp = el.getAttribute("data-og-fp");
+		if (fp) seen.add(fp);
+	}
+	if (seen.size === 0) return headers;
+	const joined = [...seen].join(",");
+	if (joined.length <= KNOWN_HEADER_CAP) headers["x-ogygia-known"] = joined;
+	return headers;
+}
+/**
+* Fold ORPHANED `view-transition-name`s into the page-level cross-fade. A name promotes its element
+* to a standalone transition group, LIFTED OUT of the root snapshot. When the element has no
+* counterpart on the other page — a sidebar full of named nav rows navigating to a marketing page
+* that has none — each one runs a solo enter/exit AND leaves a hole in the root cross-fade: a visible
+* stutter, worst in dev where the destination paints late. Names present on BOTH pages (the docs↔docs
+* active-highlight slide) are KEPT, so matched animations still play. Only INLINE names are touched
+* (nav rows carry theirs inline; the single CSS-set highlight chip is left alone). Returns a restore
+* fn to re-apply the stripped names AFTER the transition, so a page entered across a shell change
+* still animates on its next same-shell nav.
+*/
+function fold_orphan_vt_names(current, incoming) {
+	const names_in = (root) => {
+		const map = /* @__PURE__ */ new Map();
+		for (const el of root.querySelectorAll("[style*=\"view-transition-name\"]")) {
+			const n = el.style.getPropertyValue("view-transition-name").trim();
+			if (!n || n === "none") continue;
+			let arr = map.get(n);
+			if (!arr) map.set(n, arr = []);
+			arr.push(el);
+		}
+		return map;
+	};
+	const cur = names_in(current);
+	const inc = names_in(incoming);
+	const stripped = [];
+	const fold = (map, other) => {
+		for (const [name, els] of map) {
+			if (other.has(name)) continue;
+			for (const el of els) {
+				stripped.push([el, name]);
+				el.style.setProperty("view-transition-name", "none");
+			}
+		}
+	};
+	fold(cur, inc);
+	fold(inc, cur);
+	return () => {
+		for (const [el, name] of stripped) el.style.setProperty("view-transition-name", name);
+	};
+}
+const PREFETCH_TTL_MS = 8e3;
+const PAGE_CACHE_MAX_ENTRIES = 32;
+const PAGE_CACHE_MAX_BYTES = 4e6;
+/** Cap on waiting for a destination stylesheet to load before the body swap (cold-cache FOUC guard). */
+const STYLESHEET_WAIT_MS = 2e3;
+/** Kit remote-function POSTs live under `…/_app/remote/…` (or custom `appDir`). */
+const REMOTE_MUTATION_PATH = /\/remote(?:\/|$|\?)/;
+/** An `<ogygia-region>` open tag's attributes (shared `g` regex — reset `lastIndex` per scan). */
+const REGION_OPEN_TAG_G = /<ogygia-region\b([^>]*)>/g;
+/** One attribute's value in an open tag's attribute text (our own SSR: `name="value"`, no quotes
+*  inside a value). Null when absent. @internal Exported for unit tests. */
+function tag_attr(attrs, name) {
+	const key = " " + name + "=\"";
+	const at = attrs.indexOf(key);
+	if (at === -1) return null;
+	const from = at + key.length;
+	const to = attrs.indexOf("\"", from);
+	return to === -1 ? null : attrs.slice(from, to);
+}
+/** The island graph scripts in our own SSR output (island-graph.ts; the JSON is `<`-escaped, so
+*  its text never holds a `<`). */
+const ISLAND_GRAPH_SCRIPT_G = /<script type="application\/json" data-ogygia-graph>([^<]*)<\/script>/g;
+/** Stable-ish head node identity without serializing full outerHTML when possible. */
+function head_node_key(node) {
+	const tag = node.tagName;
+	switch (tag) {
+		case "TITLE": return "TITLE";
+		case "META": {
+			if (node.getAttribute("charset") != null) return "META:charset";
+			const http_equiv = node.getAttribute("http-equiv");
+			if (http_equiv) return `META:http:${http_equiv}:${node.getAttribute("content") || ""}`;
+			const name = node.getAttribute("name") || node.getAttribute("property") || "";
+			if (name) return `META:${name}:${node.getAttribute("content") || ""}`;
+			return `META:${node.outerHTML}`;
+		}
+		case "LINK": return `LINK:${node.getAttribute("rel") || ""}:${node.getAttribute("href") || ""}:${node.getAttribute("as") || ""}`;
+		case "SCRIPT": {
+			const src = node.getAttribute("src");
+			if (src) return `SCRIPT:src:${src}:${node.getAttribute("type") || ""}`;
+			const type = node.getAttribute("type") || "";
+			const text = node.textContent || "";
+			return `SCRIPT:inline:${type}:${text.length}:${text.slice(0, 48)}`;
+		}
+		case "STYLE": {
+			if (node.hasAttribute("data-sveltekit")) return "STYLE:data-sveltekit";
+			const region_css = node.getAttribute("data-ogygia-region-css");
+			if (region_css) return `STYLE:og-css:${region_css}`;
+			const vite_id = node.getAttribute("data-vite-dev-id");
+			if (vite_id) return `STYLE:vite:${vite_id}`;
+			const text = node.textContent || "";
+			return `STYLE:${text.length}:${text.slice(0, 48)}`;
+		}
+		default: return `${tag}:${node.outerHTML}`;
+	}
+}
+/**
+* Head nodes that must survive SPA swaps even when absent from the next SSR head.
+* @internal
+*/
+function keep_head_node_across_spa(node) {
+	if (node.tagName === "SCRIPT" && node.getAttribute("type") === "module" && (node.hasAttribute("data-ogygia-runtime") || node.hasAttribute("data-ogygia-dev-hmr"))) return true;
+	if (node.tagName === "STYLE" && node.hasAttribute("data-vite-dev-id")) return true;
+	if (node.tagName === "LINK" && node.getAttribute("rel") === "stylesheet" && node.hasAttribute("data-vite-dev-id")) return true;
+	return false;
+}
+/**
+* Install a `<style>` into the live document. `cloneNode` from a `DOMParser` tree
+* often fails to register the sheet; recreate with textContent instead.
+* @internal
+*/
+function install_head_style(source, head = document.head, before = null) {
+	const el = document.createElement("style");
+	for (const attr of Array.from(source.attributes)) el.setAttribute(attr.name, attr.value);
+	el.textContent = source.textContent || "";
+	session().claim_page_head(el);
+	head.insertBefore(el, before);
+	return el;
+}
+/** Apply STREAMED-page late chunks after an SPA body swap: move each inert
+*  `<template data-og-late>` into its `og-late-slot` (stylesheets hoisted first via the same
+*  keyed head installer, so the swap never paints unstyled). On a full load the inline boot
+*  script in the streamed head does this progressively during parse — this is the swap-path
+*  twin. Islands inside the adopted content are custom elements: they connect and wake alone. */
+function apply_late_templates(root) {
+	for (const tpl of Array.from(root.querySelectorAll("template[data-og-late]"))) {
+		const id = tpl.getAttribute("data-og-late") ?? "";
+		const slot = document.querySelector(`og-late-slot[data-og-slot="${CSS.escape(id)}"]`);
+		if (slot) {
+			const content = tpl.content;
+			for (const sheet of Array.from(content.querySelectorAll("link[rel=\"stylesheet\"], style"))) install_head_style(sheet);
+			slot.replaceChildren(content);
+		}
+		tpl.remove();
+	}
+}
+/**
+* Move keyboard focus to `el` without scrolling (so it never fights the post-nav scroll restore),
+* making it momentarily focusable via `tabindex=-1` and then cleaning that up so the target does not
+* linger in the tab order. For `<body>` the attribute is removed immediately (body stays the active
+* element regardless). For a normal element — a `#hash` heading — removing `tabindex` while it is
+* focused would BLUR it back to `<body>`, so the cleanup is deferred to the element's next `blur`.
+*/
+function focus_reset(el) {
+	const is_body = el === document.body || el === document.documentElement;
+	const had = el.hasAttribute("tabindex");
+	const prev = el.getAttribute("tabindex");
+	const restore = () => {
+		if (had) el.setAttribute("tabindex", prev);
+		else el.removeAttribute("tabindex");
+	};
+	el.tabIndex = -1;
+	el.focus({ preventScroll: true });
+	if (is_body) restore();
+	else el.addEventListener("blur", () => restore(), { once: true });
+}
+/** Head nodes that must never be adopted from SPA HTML (rewrite relative fetches / CSP). */
+function is_dangerous_head_node(node) {
+	const tag = node.tagName;
+	if (tag === "BASE") return true;
+	if (tag === "META") {
+		const http_equiv = (node.getAttribute("http-equiv") || "").toLowerCase();
+		if (http_equiv === "refresh" || http_equiv === "content-security-policy" || http_equiv === "content-security-policy-report-only") return true;
+	}
+	return false;
+}
+const page_cache = new PageCache({
+	ttlMs: PREFETCH_TTL_MS,
+	maxEntries: PAGE_CACHE_MAX_ENTRIES,
+	maxBytes: PAGE_CACHE_MAX_BYTES
+});
+const inflight = /* @__PURE__ */ new Map();
+/** Prefetches still waiting in the load scheduler's queue, by href (a click promotes its one). */
+const queued_prefetch = /* @__PURE__ */ new Map();
+/** requested href → the FINAL href a fetch landed on after following server redirects, when it
+*  differs. One-shot: `navigate()` reads it to correct the address bar (a redirect is invisible to
+*  `fetch` beyond `response.url`), then deletes it. See {@link fetch_page}. */
+const final_url = /* @__PURE__ */ new Map();
+/** Hrefs whose prefetched HTML was already scanned for island entries — parse once. (URL-level
+*  import dedupe lives in the shared `warm_island_module`.) */
+const warmed_pages = /* @__PURE__ */ new Set();
+/** (Hard SPA navigations cancel through the router's own handle, `r.nav_gen` / `r.nav_abort`, so a
+*  "same document" decision there can stop one in flight: SpaRouter.supersede.) */
+/** Soft invalidate fetches only — aborting these must not cancel a real click nav. */
+let soft_gen = 0;
+let soft_abort = null;
+/** The visually-hidden `aria-live` region that announces each navigation to screen readers. Created
+*  lazily on the first nav and reused (a live region must persist so assistive tech observes its
+*  mutations). It lives in `<body>` but is DETACHED before each body swap so the reconcile never
+*  removes it, then re-attached. See {@link announce} / {@link reset_focus}. */
+let announcer = null;
+function bust_page_cache() {
+	page_cache.clear();
+	inflight.clear();
+	final_url.clear();
+}
+function page_cache_size() {
+	return page_cache.size;
+}
+/**
+* Bust the SPA HTML cache after any successful Kit remote mutation (command/form POST).
+* Forms also call `invalidateAll` (soft seed refresh + bust); commands only refresh queries —
+* without this fetch hook, prefetched pages stay stale. Installed once, when this chunk loads —
+* before it there is no cache to bust.
+*/
+function install_remote_mutation_cache_bust() {
+	if (typeof window === "undefined" || typeof window.fetch !== "function") return;
+	const orig = window.fetch.bind(window);
+	window.fetch = async (input, init) => {
+		const res = await orig(input, init);
+		try {
+			const method = (init?.method || (typeof Request !== "undefined" && input instanceof Request ? input.method : "GET")).toUpperCase();
+			if (method !== "GET" && method !== "HEAD" && res.ok) {
+				const href = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+				if (REMOTE_MUTATION_PATH.test(href)) bust_page_cache();
+			}
+		} catch {}
+		return res;
+	};
+}
+install_remote_mutation_cache_bust();
+function fetch_page(href, signal, purpose = "nav") {
+	const cached = page_cache.get(href);
+	if (cached != null) return Promise.resolve(cached);
+	const pending = inflight.get(href);
+	if (pending) {
+		if (purpose === "nav") queued_prefetch.get(href)?.promote("user");
+		return pending;
+	}
+	final_url.delete(href);
+	const go = () => fetch(href, {
+		signal,
+		headers: nav_headers(purpose),
+		...purpose === "prefetch" ? { priority: "low" } : {}
+	});
+	let fetched;
+	if (purpose === "prefetch") {
+		const slot = boot_link().load_slot({
+			kind: "content",
+			cls: "speculative",
+			label: href
+		});
+		queued_prefetch.set(href, slot.ticket);
+		fetched = slot.ready.then((release) => {
+			queued_prefetch.delete(href);
+			return go().finally(release);
+		});
+	} else fetched = go();
+	const settled = fetched.then(async (res) => {
+		if (!(res.headers.get("content-type") || "").includes("text/html")) return {
+			html: null,
+			cacheable: false
+		};
+		if (res.redirected && res.url && res.url !== href) final_url.set(href, res.url);
+		const html = await res.text();
+		const cc = res.headers.get("cache-control") || "";
+		return {
+			html,
+			cacheable: spa_html_cacheable(cc, res.headers.has("set-cookie"))
+		};
+	}).catch((err) => {
+		if (err && err.name === "AbortError") throw err;
+		return {
+			html: null,
+			cacheable: false
+		};
+	});
+	const html_p = settled.then((r) => r.html);
+	if (!signal) {
+		inflight.set(href, html_p);
+		html_p.finally(() => {
+			if (inflight.get(href) === html_p) inflight.delete(href);
+		});
+		settled.then((r) => {
+			if (r.html == null) return;
+			if (r.cacheable) page_cache.set(href, r.html);
+			warm_modules(href, r.html);
+		}).catch(() => {});
+	}
+	return html_p;
+}
+/**
+* Kick off import() for every island module the prefetched page will hydrate, so they are in the
+* browser's module cache before the click. `import()` is idempotent (the loader dedupes by URL),
+* and a warmed-URL guard skips re-parsing / re-importing across repeated hover+viewport triggers.
+* A cheap attribute scan avoids building a whole detached Document during the hover window.
+*/
+function warm_modules(href, html) {
+	if (warmed_pages.has(href)) return;
+	warmed_pages.add(href);
+	ISLAND_GRAPH_SCRIPT_G.lastIndex = 0;
+	let g;
+	while (g = ISLAND_GRAPH_SCRIPT_G.exec(html)) register_island_graph(g[1], new URL(href, location.href).href);
+	REGION_OPEN_TAG_G.lastIndex = 0;
+	let m;
+	while (m = REGION_OPEN_TAG_G.exec(html)) {
+		const entry = tag_attr(m[1], "entry");
+		if (!entry) continue;
+		note_entry_location(entry, tag_attr(m[1], "src"), href);
+		warm_island_module(entry, href);
+	}
+}
+/**
+* PREFLIGHT — the incoming document's read-only preparation, in the task BEFORE the transition:
+*  • `<link rel="modulepreload">` hints for modules this page already warmed are dropped, so the
+*    head merge never re-issues a fetch for bytes the module map holds;
+*  • reconcile keys are stamped on the incoming regions (the fingerprint reads, off the DOM change);
+*  • the incoming page seed is parsed once, on the document (runtime/seeds.ts) — a kept island's
+*    props absorb and the soft-invalidate both reuse that parse inside the transition.
+*/
+function preflight(doc, dest) {
+	for (const l of Array.from(doc.querySelectorAll("link[rel=\"modulepreload\"]"))) {
+		const href = l.getAttribute("href");
+		if (href && is_warmed_module(href, dest.href)) l.remove();
+	}
+	stamp_region_keys(doc.body);
+	page_seed_of(doc);
+}
+async function navigate(r, url, from, { push = true, pop_scroll = null, type = "link", replace = false } = {}) {
+	if (!r.run_before(from, url, type)) {
+		if (r.nav_target === url.href) r.nav_target = null;
+		return;
+	}
+	const dt_t0 = DEVTOOLS ? dt_now() : 0;
+	let dt_reconciled = false;
+	const nav_t0 = performance.now();
+	let nav_fetched = nav_t0;
+	let nav_styled = nav_t0;
+	if (DEVTOOLS) emit({
+		domain: "nav",
+		name: "nav.start",
+		from: from.pathname + from.search,
+		to: url.pathname + url.search,
+		type
+	});
+	r.nav_abort?.abort();
+	r.nav_abort = new AbortController();
+	const { signal } = r.nav_abort;
+	const gen = ++r.nav_gen;
+	r.nav_target = url.href;
+	signal.addEventListener("abort", () => {
+		if (r.nav_target === url.href) r.nav_target = null;
+	});
+	if (replace) replace_state({
+		...history.state,
+		ogygia: true
+	}, url.href);
+	else if (push) {
+		replace_state({
+			...history.state,
+			scroll: {
+				x: scrollX,
+				y: scrollY
+			}
+		});
+		push_state({ ogygia: true }, url.href);
+	}
+	const purpose = type === "popstate" ? "history" : "nav";
+	let html;
+	try {
+		html = await fetch_page(url.href, signal, purpose);
+	} catch (err) {
+		if (err?.name === "AbortError" || gen !== r.nav_gen) return;
+		location.href = url.href;
+		return;
+	}
+	if (gen !== r.nav_gen) return;
+	if (html == null) {
+		location.href = url.href;
+		return;
+	}
+	nav_fetched = performance.now();
+	page_cache.delete(url.href);
+	let dest = url;
+	const landed = final_url.get(url.href);
+	final_url.delete(url.href);
+	if (landed) try {
+		dest = new URL(landed, url);
+	} catch {
+		dest = url;
+	}
+	const hand_off = () => {
+		location.href = url.href;
+	};
+	if (dest.origin !== location.origin) return hand_off();
+	const doc = new DOMParser().parseFromString(html, "text/html");
+	if (KitBoot.document_has(doc)) return hand_off();
+	const marker = doc.querySelector("meta[name=\"ogygia-router\"]");
+	if (!marker) return hand_off();
+	if (doc.querySelector("meta[name=\"ogygia-first-load\"]")) return hand_off();
+	globalThis.__og_restore?.(doc);
+	if (dest !== url) replace_state({
+		...history.state,
+		ogygia: true
+	}, dest.href);
+	const prefer_reduced_motion = typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+	const use_vt = marker.getAttribute("content") !== "plain" && !prefer_reduced_motion;
+	for (const el of doc.querySelectorAll("ogygia-region")) pin_region_urls(el, dest.href);
+	batch_regions(doc, dest.href);
+	preflight(doc, dest);
+	await preload_stylesheets(doc.head);
+	if (gen !== r.nav_gen) return;
+	nav_styled = performance.now();
+	await yield_task();
+	if (gen !== r.nav_gen) return;
+	const reconcile = !!slots.morph && !regions_in_shadow() && !document.body.querySelector("[data-og-no-reconcile]") && !doc.body.querySelector("[data-og-no-reconcile]");
+	const swap = () => {
+		if (gen !== r.nav_gen) return;
+		announcer?.remove();
+		document.dispatchEvent(new Event("og:before-swap"));
+		merge_head(doc.head);
+		if (gen !== r.nav_gen) return;
+		if (slots.forms.enabled && r.current_url) slots.forms.snapshot(document.body, r.current_url.pathname);
+		prepare_spa_document();
+		apply_soft_invalidate_doc(doc);
+		if (gen !== r.nav_gen) return;
+		if (reconcile) {
+			reconcile_body(document.body, doc.body, slots.morph);
+			dt_reconciled = true;
+			document.title = doc.title;
+			session().settle_lakes_in(document.body);
+		} else {
+			if (DEVTOOLS) emit({
+				domain: "nav",
+				name: "nav.fallback",
+				reason: !slots.morph ? "no-morph" : "shadow-region"
+			});
+			swap_body(document.body, doc.body);
+			document.title = doc.title;
+			session().settle_lakes_in(document.body);
+			dispose_scope("page");
+		}
+		globalThis.__og_restore_adopt?.();
+		session().retire_page_head_copies();
+		apply_late_templates(document.body);
+		finish_spa_document();
+		if (slots.forms.enabled) slots.forms.restore(url.pathname);
+		document.dispatchEvent(new Event("og:after-swap"));
+	};
+	if (use_vt && document.startViewTransition) {
+		const restore_vt_names = fold_orphan_vt_names(document.body, doc.body);
+		const t = document.startViewTransition(swap);
+		t.ready?.catch(() => {});
+		(t.finished ?? Promise.resolve()).then(restore_vt_names, restore_vt_names);
+		await t.updateCallbackDone.catch(() => {});
+	} else swap();
+	if (gen !== r.nav_gen) return;
+	r.doc_key = document_key(dest);
+	r.current_url = dest;
+	r.nav_target = null;
+	boot_link().beacon_nav({
+		from: from.pathname + from.search,
+		to: dest.pathname + dest.search,
+		type,
+		t: nav_t0,
+		fetched: nav_fetched,
+		styled: nav_styled,
+		swapped: performance.now(),
+		href: url.href
+	});
+	if (DEVTOOLS) emit({
+		domain: "nav",
+		name: "nav.finish",
+		to: dest.pathname + dest.search,
+		ms: dt_now() - dt_t0,
+		reconciled: dt_reconciled,
+		vt: !!(use_vt && document.startViewTransition)
+	});
+	if (replace) {} else if (pop_scroll) {
+		const html_el = document.documentElement;
+		const prev = html_el.style.scrollBehavior;
+		html_el.style.scrollBehavior = "auto";
+		try {
+			window.scrollTo(pop_scroll.x, pop_scroll.y);
+		} finally {
+			html_el.style.scrollBehavior = prev;
+		}
+	} else jump_to_hash(dest.hash);
+	announce(dest);
+	reset_focus(dest.hash);
+	r.run_after(from, dest, type);
+	document.dispatchEvent(new Event("og:page-load"));
+	if (gen === r.nav_gen) {
+		r.nav_abort = null;
+		if (r.nav_target === url.href) r.nav_target = null;
+	}
+	r.scan_preload_links();
+}
+/**
+* Soft invalidate: refresh page/remote seeds for the current URL without navigation.
+*
+* Kit's `invalidateAll` re-runs loads in place — it is **not** a navigation (no
+* `beforeNavigate` / `afterNavigate`). Remote `form()` always calls this on success; a
+* full SPA navigate+VT here was wiping live island state. We bust the HTML cache,
+* re-fetch, merge head, and refresh document seeds only — no VT, no body swap, no
+* island remount, no live query-map clear, no auto-refresh of live queries. Islands
+* that need query updates use `.refresh()`, or `submit().updates(q)` with server
+* `requested(q).refreshAll()` (updates alone does not populate response `q`).
+*
+* Uses a separate abort/generation from hard `navigate()` so soft fetches never cancel
+* an in-flight click navigation (and vice versa).
+*/
+async function invalidate_all() {
+	bust_page_cache();
+	const url = new URL(location.href);
+	soft_abort?.abort();
+	soft_abort = new AbortController();
+	const { signal } = soft_abort;
+	const gen = ++soft_gen;
+	let html;
+	try {
+		html = await fetch_page(url.href, signal);
+	} catch (err) {
+		if (err?.name === "AbortError" || gen !== soft_gen) return;
+		return;
+	}
+	if (gen !== soft_gen || html == null) return;
+	const doc = new DOMParser().parseFromString(html, "text/html");
+	if (KitBoot.document_has(doc)) return;
+	if (!doc.querySelector("meta[name=\"ogygia-router\"]")) return;
+	merge_head(doc.head);
+	apply_soft_invalidate_doc(doc);
+}
+/**
+* ACCESSIBILITY — announce the new page. A body swap is invisible to assistive tech: no document
+* `load`, so a screen reader is never told the page changed. Mirror what a full navigation (and
+* SvelteKit) give for free — a visually-hidden `aria-live` region whose text becomes the new
+* `<title>`, so the page is spoken on arrival. The region is created once and reused (it must
+* already be in the DOM when its text changes for AT to observe it); it was detached before the
+* swap so the reconcile couldn't remove it, and is re-attached here before its text is set.
+*/
+function announce(dest) {
+	let el = announcer;
+	if (!el) {
+		el = document.createElement("div");
+		el.setAttribute("data-ogygia-announcer", "");
+		el.setAttribute("aria-live", "assertive");
+		el.setAttribute("aria-atomic", "true");
+		el.style.cssText = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0";
+		announcer = el;
+	}
+	if (el.parentNode !== document.body) document.body.appendChild(el);
+	el.textContent = document.title || dest.pathname;
+}
+/**
+* ACCESSIBILITY — reset keyboard focus after a navigation, so a keyboard or screen-reader user
+* lands at the top of the new page instead of wherever focus was on the old one (a full navigation
+* does this natively; a body swap does not). SvelteKit's algorithm: a `[autofocus]` element wins;
+* else a `#hash` target; else focus falls back to `<body>` (made momentarily focusable). The one
+* ogygia twist: a control INSIDE kept/persisted chrome (`data-ogygia-keep` / `data-persist`) that
+* survived the nav is left focused — the visitor is still using that persistent widget.
+*/
+function reset_focus(hash) {
+	const active = document.activeElement;
+	if (active && active !== document.body && active.isConnected && active.closest("[data-ogygia-keep],[data-persist]")) return;
+	if (hash) {
+		const id = decodeURIComponent(hash.slice(1));
+		const target = id ? document.getElementById(id) : null;
+		if (target) return focus_reset(target);
+	}
+	const autofocus = document.querySelector("[autofocus]");
+	if (autofocus) {
+		autofocus.focus();
+		return;
+	}
+	focus_reset(document.body);
+}
+/** Merge <head>: keep nodes present in both, remove stale, add new. Keeps runtime scripts alive. */
+function merge_head(new_head) {
+	const current = document.head;
+	const owned = session().page_head;
+	const current_nodes = /* @__PURE__ */ new Map();
+	for (const node of Array.from(current.children)) if (owned.has(node)) current_nodes.set(head_node_key(node), node);
+	const next_keys = /* @__PURE__ */ new Set();
+	for (const node of Array.from(new_head.children)) {
+		if (is_dangerous_head_node(node)) continue;
+		next_keys.add(head_node_key(node));
+	}
+	for (const [key, node] of current_nodes) {
+		if (next_keys.has(key)) continue;
+		if (keep_head_node_across_spa(node)) continue;
+		node.remove();
+	}
+	const anchor = current.firstChild;
+	for (const node of Array.from(new_head.children)) {
+		if (is_dangerous_head_node(node)) continue;
+		const key = head_node_key(node);
+		const existing = current_nodes.get(key);
+		if (key === "STYLE:data-sveltekit") {
+			existing?.remove();
+			install_head_style(node, current, anchor);
+			continue;
+		}
+		if (existing) continue;
+		if (node.tagName === "STYLE") install_head_style(node, current, anchor);
+		else session().claim_page_head(current.appendChild(node.cloneNode(true)));
+	}
+}
+/**
+* Load the destination page's stylesheets into the live `<head>` and resolve once they have
+* applied — call this BEFORE the body swap. A freshly appended `<link rel="stylesheet">` loads
+* asynchronously, so swapping the body first shows the new route unstyled (e.g. a content column
+* at full width) until the sheet arrives. That window is invisible on a warm cache but flashes on
+* the first visit after a deploy, when the route CSS isn't cached yet. Preloading here closes it;
+* `merge_head` then dedupes these by key so nothing is added twice. Capped so a stalled sheet
+* can't hang navigation.
+*/
+function preload_stylesheets(new_head) {
+	const present = /* @__PURE__ */ new Set();
+	for (const node of Array.from(document.head.children)) if (node.tagName === "LINK" && node.getAttribute("rel") === "stylesheet") present.add(head_node_key(node));
+	const pending = [];
+	for (const node of Array.from(new_head.children)) {
+		if (node.tagName !== "LINK" || node.getAttribute("rel") !== "stylesheet") continue;
+		if (is_dangerous_head_node(node)) continue;
+		if (node.hasAttribute("disabled")) continue;
+		const key = head_node_key(node);
+		if (present.has(key)) continue;
+		present.add(key);
+		const link = node.cloneNode(true);
+		pending.push(new Promise((resolve) => {
+			link.addEventListener("load", () => resolve(), { once: true });
+			link.addEventListener("error", () => resolve(), { once: true });
+		}));
+		session().claim_page_head(link);
+		document.head.insertBefore(link, document.head.firstChild);
+	}
+	if (!pending.length) return Promise.resolve();
+	return Promise.race([Promise.all(pending), new Promise((resolve) => setTimeout(resolve, STYLESHEET_WAIT_MS))]);
+}
+/**
+* SINGLE-FLIGHT NAVIGATION. Collect the incoming page's deferred, load-timed region calls and stream them as
+* one batch. Reads the RENDERED holes (`<ogygia-region render="defer" endpoint>`), so it covers
+* both placed server islands and held `region()` deferred regions alike — authoring syntax is
+* irrelevant. Only `when="load"` (or unset) is batched: a region scheduled `visible`/`idle`/media
+* stays lazy and fetches on its own trigger, so dynamic schedules are preserved, not eagerly pulled.
+*/
+/** `base`: the fetched page's own URL (its relative hrefs resolve against it). */
+function batch_regions(doc, base) {
+	const endpoints = [];
+	const batched = /* @__PURE__ */ new Set();
+	for (const el of Array.from(doc.querySelectorAll("ogygia-region[render=\"defer\"][endpoint]"))) {
+		if ((el.getAttribute("when") || "load") !== "load") continue;
+		const ep = el.getAttribute("endpoint");
+		if (ep) {
+			endpoints.push(ep);
+			batched.add(ep);
+		}
+	}
+	if (!endpoints.length) return;
+	const same_url = (href) => {
+		try {
+			const u = new URL(href, base);
+			return u.pathname + u.search;
+		} catch {
+			return href;
+		}
+	};
+	const batched_urls = new Set(Array.from(batched, same_url));
+	for (const link of Array.from(doc.querySelectorAll("link[rel=\"preload\"][as=\"fetch\"]"))) if (batched_urls.has(same_url(link.getAttribute("href") || ""))) link.remove();
+	if (DEVTOOLS) emit({
+		domain: "nav",
+		name: "nav.batch",
+		count: endpoints.length
+	});
+	slots.frames?.stream?.(endpoints);
+}
+export { DOCUMENT_ACCEPT, apply_late_templates, bust_page_cache, fetch_page, head_node_key, install_head_style, invalidate_all, keep_head_node_across_spa, navigate, page_cache_size, tag_attr };