@ogygia/core 0.11.4 → 0.12.0

package/dist/runtime/core.js

@@ -1,16 +1,14 @@
 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 { import_entry, island_entry_of, on_entry_fallback, pin_build_map, 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";
@@ -24,6 +22,7 @@ import { on_svelte_warning, set_hydrating, tap_svelte_warnings } from "./svelte-
 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 { 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;
@@ -95,7 +94,7 @@ const ON_DEMAND_EVENTS = [
 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
+* (five listeners per hole used to be five hundred on a page of nav-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();
@@ -353,7 +352,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 		connected_regions.add(this);
 		pin_region_urls(this);
 		if (this.hasAttribute("live")) return;
-		if (this.#minted_endpoint === null && is_deferred(this)) {
+		if (FRAMES && this.#minted_endpoint === null && is_deferred(this)) {
 			const minted = this.getAttribute("endpoint");
 			if (minted) this.#minted_endpoint = minted;
 			else {
@@ -427,6 +426,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* nothing left to warm.
 	*/
 	#prefetch_html() {
+		if (!FRAMES) return;
 		if (this.#done || this.#fetching || !this.isConnected) return;
 		const endpoint = this.#endpoint();
 		if (!endpoint || !is_allowed_region_endpoint(endpoint)) return;
@@ -592,6 +592,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* island), schedule phase-2 hydrate — coalescing matching schedules to immediate load.
 	*/
 	async #server() {
+		if (!FRAMES) return;
 		const endpoint = this.#endpoint();
 		if (endpoint && !this.#frame_unsub) {
 			const address = this.#frame_address = frameAddress(endpoint);
@@ -718,6 +719,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* not (the endpoint answers `cache-control: private, max-age=30`, and stale is the whole point).
 	*/
 	async #fetch_html(opts = {}) {
+		if (!FRAMES) return;
 		if (this.#fetching || this.#done && !opts.revalidate) return;
 		const endpoint = this.#endpoint();
 		if (!endpoint) return;
@@ -879,7 +881,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 				[mod, core] = await Promise.all([
 					load_island(entry, cls()),
 					hydrate_core(),
-					wire_classes_for(this)
+					slots.wire_classes?.(this)
 				]);
 			} finally {
 				release();
@@ -952,6 +954,7 @@ var OgygiaRegion = class OgygiaRegion extends HTMLElement {
 	* - **Later tick, module changed:** unmount, swap, re-hydrate.
 	*/
 	async applyLive(desc) {
+		if (!FRAMES) return;
 		this.setAttribute("render", "defer");
 		this.setAttribute("entry", desc.module || desc.id);
 		if (desc.url) this.setAttribute("endpoint", desc.url);
@@ -1122,10 +1125,10 @@ function apply_dev_head_region_css() {
 	});
 }
 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();
+	pin_build_map();
 	on_entry_fallback((report) => {
 		if (DEVTOOLS) emit({
 			domain: "runtime",

package/dist/runtime/entry-locations.d.ts

@@ -11,6 +11,13 @@ export declare function on_entry_fallback(reporter: (report: EntryFallbackReport
 export declare function note_entry_location(entry: string | null | undefined, src: string | null | undefined, base?: string): void;
 /** The known location of an entry, or undefined. */
 export declare function entry_location(entry: string, base?: string): string | undefined;
+/**
+ * Pin the build map's address to the page that wrote it, as `pin_region_urls` pins a region's: with
+ * Kit's default `paths.relative` it is written relative to that page, and it is read lazily — after a
+ * client navigation to another depth, resolved against the new address, it named a file that is not
+ * there. The runtime calls this at boot, before any navigation.
+ */
+export declare function pin_build_map(): void;
 /**
  * PIN A REGION'S URLS TO THE PAGE THAT WROTE THEM. With Kit's default `paths.relative`, the server
  * writes `entry` / `src` / `endpoint` relative to the page it rendered (`../../_app/immutable/…`,
@@ -26,8 +33,8 @@ export declare function pin_region_urls(el: Element, base?: string): void;
 /** An island element's identity, its location noted on the way (the one read every loader uses). */
 export declare function island_entry_of(el: Element): string | null;
 /**
- * Import an entry: its location when known, else `url` (what the caller resolved for the identity);
- * the location failing, once, the identity fetched fresh — so an island on a page that outlived its
- * build still wakes, on the current code. No location known → the error stands.
+ * Import an entry: its location when known (else this build's map names it, once read); failing that,
+ * or with none anywhere, the CURRENT build's location — so an island on a page that outlived its build
+ * still wakes, on the current code. `url`: what the caller resolved for the identity.
  */
 export declare function import_entry<T>(entry: string, url?: string): Promise<T>;

package/dist/runtime/entry-locations.js

@@ -6,9 +6,9 @@
 * fingerprint, the devtools' names). The file to import is its LOCATION — content-hashed, so an
 * `immutable` cache never serves a stale one. The server writes it beside the identity: the region
 * element's `src`, and the island graph's `s` map for an entry no element carries (a portable
-* snippet's). Every loader resolves through `island_module_url` (region-endpoint-url.ts), which asks
-* here first: the location once one is known, else the identity (the dev server, or a page from
-* before hashing — whose stable name is a shim that reaches the current build).
+* snippet's), and the build's location maps for the rest (`import_entry`). Every loader resolves
+* through `island_module_url` (region-endpoint-url.ts), which asks here first: the location once one
+* is known, else the identity (on the dev server, the module itself; in a build, a name, no file).
 */
 /** absolute identity → absolute location */
 const locations = /* @__PURE__ */ new Map();
@@ -43,6 +43,48 @@ function note_entry_location(entry, src, base) {
 function entry_location(entry, base) {
 	return locations.size ? locations.get(absolute(entry, base)) : void 0;
 }
+/**
+* THIS BUILD'S LOCATION MAP (compiler/link/location-map.ts, the content-hashed one): every island entry's
+* location by identity, for a load that arrives with an identity alone — a region the browser
+* rendered, a held region from the wire, a snippet whose host carried no graph. The runtime's script
+* names it (`data-og-locations`); it is read once, on the first such load. Content-hashed, so no
+* cache serves it stale. It only fills gaps: a location a page wrote (a later build's, after a
+* navigation) always wins over the map of the build the runtime came from. No map, or it failed
+* (the dev server, a page that outlived its build): the identity is loaded, as before. A failed read
+* is not kept: the next identity-only load asks again (a blip must not cost the page every later one).
+*/
+const BUILD_MAP_ATTR = "data-og-locations";
+let build_map = null;
+/**
+* Pin the build map's address to the page that wrote it, as `pin_region_urls` pins a region's: with
+* Kit's default `paths.relative` it is written relative to that page, and it is read lazily — after a
+* client navigation to another depth, resolved against the new address, it named a file that is not
+* there. The runtime calls this at boot, before any navigation.
+*/
+function pin_build_map() {
+	if (typeof document === "undefined") return;
+	const script = document.querySelector(`script[${BUILD_MAP_ATTR}]`);
+	const href = script?.getAttribute(BUILD_MAP_ATTR);
+	if (script && href) script.setAttribute(BUILD_MAP_ATTR, absolute(href));
+}
+function read_build_map() {
+	if (build_map) return build_map;
+	if (typeof document === "undefined") return null;
+	const href = document.querySelector(`script[${BUILD_MAP_ATTR}]`)?.getAttribute(BUILD_MAP_ATTR);
+	if (!href) return null;
+	const url = absolute(href);
+	const read = fetch(url).then((res) => res.ok ? res.json() : null).catch(() => null).then((map) => {
+		if (!map) {
+			if (build_map === read) build_map = null;
+			return;
+		}
+		for (const stable in map) {
+			const identity = absolute(stable, url);
+			if (!locations.has(identity)) locations.set(identity, absolute(map[stable], url));
+		}
+	});
+	return build_map = read;
+}
 /** The region attributes that hold a URL: its identity, its location, its hole's endpoint. */
 const REGION_URL_ATTRS = [
 	"entry",
@@ -80,32 +122,101 @@ function island_entry_of(el) {
 	return entry;
 }
 /**
-* The identity itself, past every cache: what a load falls back to when its location failed (a page
-* a cache kept outlived the build that made it, and that build's files are gone). The stable name
-* is a shim of the CURRENT build's file; the query makes the browser fetch it fresh rather than the
-* copy an `immutable` cache may hold. Null when no location was known (nothing to fall back to).
+* THE CURRENT BUILD'S MAP (compiler/link/location-map.ts): the one file at a fixed name, in the app
+* dir of the identities it maps (`<appDir>/ogygia.json`), so any app's is found from an identity alone.
+* A page that outlived its build reads it when its own files are gone (or it never named a map) and
+* wakes on the current code. Revalidated (a host serves it as any changing file; `no-cache` past one
+* that kept it anyway), read once per document per app. Only an ogygia identity has one: the dev
+* server's module URLs never ask.
 */
-function fresh_identity_url(entry, base) {
-	if (!entry_location(entry, base)) return null;
-	const identity = absolute(entry, base);
-	return identity + (identity.includes("?") ? "&" : "?") + "og-fresh=" + Date.now().toString(36);
+const current_maps = /* @__PURE__ */ new Map();
+/** A build's island identity (`…/<appDir>/ogygia/og-region.<id>.js`): a name, no file. */
+function is_build_identity(entry) {
+	return absolute(entry).includes("/ogygia/og-region.");
 }
+/** The current map's file for an identity (`<appDir>/ogygia.json`), or null: not a build's identity. */
+function current_map_file(identity) {
+	const dir = identity.lastIndexOf("/ogygia/og-region.");
+	return dir === -1 ? null : identity.slice(0, dir) + "/ogygia.json";
+}
+/** The current build's location for `entry`: null when its map has none, undefined when the map
+*  could not be read (that read is not kept: the next ask reads again). */
+async function current_location(entry) {
+	const identity = absolute(entry);
+	const file = current_map_file(identity);
+	if (!file) return null;
+	let map = current_maps.get(file);
+	if (!map) {
+		map = fetch(file, { cache: "no-cache" }).then((res) => res.ok ? res.json() : null).catch(() => null);
+		current_maps.set(file, map);
+	}
+	const pairs = await map;
+	if (!pairs) {
+		forget_current_map(file, map);
+		return;
+	}
+	for (const name in pairs) if (absolute(name, file) === identity) return absolute(pairs[name], file);
+	return null;
+}
+function forget_current_map(file, map = current_maps.get(file)) {
+	if (current_maps.get(file) === map) current_maps.delete(file);
+}
+/** The host says this file is not there (it does not say so of a file that failed another way). */
+function is_gone(url) {
+	return fetch(url, {
+		method: "HEAD",
+		cache: "no-store"
+	}).then((res) => res.status === 404 || res.status === 410, () => false);
+}
+/** How long a recovery waits before each ask of the current map: a rollover settles in seconds. */
+const RECOVERY_WAITS = [
+	0,
+	1e3,
+	3e3,
+	9e3
+];
 /**
-* Import an entry: its location when known, else `url` (what the caller resolved for the identity);
-* the location failing, once, the identity fetched fresh — so an island on a page that outlived its
-* build still wakes, on the current code. No location known → the error stands.
+* The current build's file for a build's identity whose file just failed to load. A deploy's rollover
+* is exactly when this is asked, so an answer that cannot be the current one is asked again while it
+* settles: a map that could not be read (a 404, a 5xx), and a map that names the very file that just
+* failed when the host says that file is gone — an edge still answering with the old build's map. A
+* file that failed some other way (the network, a broken module) is not asked about again.
+*/
+async function recover_location(entry, failed) {
+	let current;
+	for (const wait of RECOVERY_WAITS) {
+		if (wait) await new Promise((resolve) => setTimeout(resolve, wait));
+		current = await current_location(entry);
+		if (current === void 0) continue;
+		if (current !== failed || !await is_gone(failed)) break;
+		forget_current_map(current_map_file(absolute(entry)));
+	}
+	return current ?? null;
+}
+/**
+* Import an entry: its location when known (else this build's map names it, once read); failing that,
+* or with none anywhere, the CURRENT build's location — so an island on a page that outlived its build
+* still wakes, on the current code. `url`: what the caller resolved for the identity.
 */
 function import_entry(entry, url = entry_location(entry) ?? entry) {
-	const loaded = import(
+	if (entry_location(entry)) return load_entry(entry, url);
+	return (read_build_map() ?? Promise.resolve()).then(async () => {
+		const located = entry_location(entry);
+		if (located) return load_entry(entry, located);
+		return load_entry(entry, await current_location(entry) || url);
+	});
+}
+function load_entry(entry, url) {
+	return import(
 		/* @vite-ignore */
 		url
-);
-	const fresh = fresh_identity_url(entry);
-	if (!fresh) return loaded;
-	return loaded.catch(() => {
+).catch(async (error) => {
+		const failed = absolute(url);
+		const current = is_build_identity(entry) ? await recover_location(entry, failed) : absolute(entry);
+		if (!current || current === failed) throw error;
 		const retry = import(
 			/* @vite-ignore */
-			fresh
+			current
 );
 		const report = (recovered) => fallback_reporter?.({
 			entry,
@@ -116,4 +227,4 @@ function import_entry(entry, url = entry_location(entry) ?? entry) {
 		return retry;
 	});
 }
-export { entry_location, import_entry, island_entry_of, note_entry_location, on_entry_fallback, pin_region_urls };
+export { entry_location, import_entry, island_entry_of, note_entry_location, on_entry_fallback, pin_build_map, pin_region_urls };

package/dist/runtime/full.js

@@ -5,13 +5,15 @@ import { install as install$2 } from "./morph.js";
 import { install as install$3 } from "./interaction.js";
 import { install as install$4 } from "./form-continuity.js";
 import { install as install$5 } from "./router.js";
+import { install as install$6 } from "./wire-classes.js";
+import { install as install$7 } from "./nav-handle.js";
 // src/runtime/full.ts
 /**
 * Kitchen-sink browser runtime — every BOOT-phase feature installed. The dev / no-marks entry: the
 * ogygia compiler injects `bootDev()` (see the plugin's `virtual:ogygia-runtime`); a per-app production
 * build instead emits a generated entry (see `vite/runtime-entry.ts`) that boots only the features it
 * uses. Both boot through {@link ./core.js core} in the same {@link ../vite/runtime-entry.js FEATURE_ORDER}.
-* HYDRATE-phase features (context, live, wire, remote-seeds) are never in the boot, dev included: the
+* HYDRATE-phase features (context, live, wire, remote-seeds, page) are never in the boot, dev included: the
 * hydrate core installs them from `virtual:ogygia/hydrate-features` (every one, in dev).
 *
 * Exposed as an explicit FUNCTION, not a top-level side effect: the compiler always calls it, so the
@@ -21,11 +23,13 @@ import { install as install$5 } from "./router.js";
 *  Idempotent via {@link ./core.js boot}. */
 function bootDev(client_plugins = []) {
 	boot([
+		install$6,
 		install,
 		install$1,
 		install$2,
 		install$3,
 		install$4,
+		install$7,
 		install$5
 	], client_plugins);
 }

package/dist/runtime/hydrate-core.d.ts

@@ -1,6 +1,7 @@
-import { seed_page_once, seed_remote_once } from "./seeds.js";
-import { kit_page_thread } from "./kit-page-thread.svelte.js";
 import { Component } from "svelte";
+export declare const seed_page_once: () => void;
+export declare const seed_remote_once: () => void;
+export declare const kit_page_thread: () => Promise<void> | null;
 /** A hydrated island as the element holds it: how to tear it down, and (keep / live hosts) how to
  *  push the next page's props into it. */
 export type IslandHandle = {
@@ -97,5 +98,4 @@ export declare function hydrate_island(region: HTMLElement, entry: string, mod:
  * HTML comes from svelte `render()` (both envelope layers) — same as the deferred swap path, so it
  * is NOT wrapped in extra `[..]` hydration comments. `null` when the live feature is absent.
  */
-export declare function hydrate_live(region: HTMLElement, entry: string, mod: IslandModule, props: Record<string, unknown>): IslandHandle | null;
-export { kit_page_thread, seed_page_once, seed_remote_once };
+export declare function hydrate_live(region: HTMLElement, entry: string, mod: IslandModule, props: Record<string, unknown>): IslandHandle | null;

package/dist/runtime/hydrate-core.js

@@ -1,13 +1,12 @@
 import { set_current_region, set_foreign_hydrate } from "../current-region.js";
 import { capture_region_ids } from "./region-ids.js";
 import { foreign_region_prop_revivers } from "./foreign-props.js";
-import { SEED_REF_KEY, seed_ref_reviver } from "../seed-refs.js";
-import { parse_sidecar_text, seed_data_of, seed_page_once, seed_remote_once } from "./seeds.js";
+import { SEED_REF_KEY, seed_ref_reviver } from "../seed-ref-reviver.js";
+import { parse_sidecar_text } from "./wire-format.js";
 import { is_deferred, ours_on_kit_document, region_ssr_truncated } from "./region-attrs.js";
 import { boot_link, slots } from "./slots.js";
 import { keep_host_classes, note_host_classes } from "./host-classes.js";
 import { emit } from "../events/bus.js";
-import { kit_page_thread } from "./kit-page-thread.svelte.js";
 import { hydrate, unmount } from "svelte";
 import NestedProvider from "../NestedProvider.svelte";
 import { install } from "virtual:ogygia/hydrate-features";
@@ -24,6 +23,9 @@ import { install } from "virtual:ogygia/hydrate-features";
 * Stateless towards the element: the element owns its handle (`IslandHandle`) and its flags; this
 * module owns the how.
 */
+const seed_page_once = () => slots.page?.seed_page_once();
+const seed_remote_once = () => slots.remoteSeeds?.seed_once();
+const kit_page_thread = () => slots.page?.kit_page_thread() ?? null;
 install();
 const kit_hydrates_page = () => boot_link().kit_hydrates_page();
 const props_sidecar_of = (region) => boot_link().props_sidecar_of(region);
@@ -335,9 +337,10 @@ function read_region_props(region, foreign = false) {
 	if (!sidecar) return {};
 	const base = foreign ? foreign_region_prop_revivers() : region_prop_revivers();
 	const doc = sidecar.ownerDocument;
-	const revivers = foreign ? base : {
+	const page = slots.page;
+	const revivers = foreign || !page ? base : {
 		...base,
-		[SEED_REF_KEY]: seed_ref_reviver(() => seed_data_of(doc))
+		[SEED_REF_KEY]: seed_ref_reviver(() => page.seed_data_of(doc))
 	};
 	return parse_sidecar_text(sidecar, revivers);
 }

package/dist/runtime/morph.d.ts

@@ -35,6 +35,13 @@ export declare function morph_children(parent: Element, new_nodes: ArrayLike<Nod
  */
 export interface MorphOptions {
   target?: "live" | "walk";
+  /**
+   * A child of the ROOT that is not the render's (the router's body reconcile: a node a script put
+   * in `<body>`, such as a portal's mount anchor; ownership.ts `server_body_child`). The morph steps
+   * over it: never matched, never moved, never removed. The render's children around it reconcile
+   * as usual. Root level only; below the root the ownership rules decide.
+   */
+  stays?: (node: Node) => boolean;
 }
 /** Add + update + remove attributes so `from` matches `to` exactly. Boolean attrs are attr presence.
  *  `keep_extra` (a self-owned element, {@link is_self_owned}): add + update only — an attribute the

package/dist/runtime/morph.js

@@ -95,7 +95,7 @@ function morph_children(parent, new_nodes, options) {
 		const owner = owner_of(parent);
 		if (owner !== "walk" && owner !== "region") return;
 	}
-	reconcile(parent, new_nodes, build_id_sets(parent, new_nodes), walk);
+	reconcile(parent, new_nodes, build_id_sets(parent, new_nodes), walk, options?.stays);
 	clear_aria_hidden_over_focus(parent);
 }
 /**
@@ -191,18 +191,24 @@ function reserved_for_later(sets, new_inner, cursor, idx) {
 * ({@link reconcile_by_identity}). Toward Svelte's walk, positions are always the render's (the walk
 * binds by position).
 */
-function reconcile(parent, new_nodes, sets, walk) {
+function reconcile(parent, new_nodes, sets, walk, stays) {
 	if (!walk && order_owner(parent) === "element") reconcile_by_identity(parent, new_nodes, sets);
-	else reconcile_children(parent, new_nodes, sets, walk);
+	else reconcile_children(parent, new_nodes, sets, walk, stays);
 }
 /**
 * The render's sequence, by position.
 * @param walk the {@link MorphOptions.target} is Svelte's walk (the repair), threaded unchanged down
 * the recursion — a subtree the walk never enters is skipped.
+* @param stays the root's children that are not the render's ({@link MorphOptions.stays}): the
+* cursor steps over them, so they are never matched, moved or removed. Not threaded down.
 */
-function reconcile_children(parent, new_nodes, sets, walk = false) {
+function reconcile_children(parent, new_nodes, sets, walk = false, stays) {
 	const count = new_nodes.length;
-	let cursor = parent.firstChild;
+	const step = (n) => {
+		if (stays) while (n && stays(n)) n = n.nextSibling;
+		return n;
+	};
+	let cursor = step(parent.firstChild);
 	let idx = 0;
 	while (idx < count && cursor) {
 		const next = new_nodes[idx];
@@ -213,11 +219,11 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 			if (!same_node(cursor, next)) break;
 			if (sets !== null && !id_sets_agree(sets, cursor, next)) break;
 			const here = cursor;
-			cursor = cursor.nextSibling;
+			cursor = step(cursor.nextSibling);
 			morph_same(here, next, sets, walk);
 		} else {
 			const here = cursor;
-			cursor = cursor.nextSibling;
+			cursor = step(cursor.nextSibling);
 			morph_node(here, next, sets, walk);
 		}
 		idx++;
@@ -225,7 +231,7 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 	if (idx >= count) {
 		while (cursor) {
 			const gone = cursor;
-			cursor = cursor.nextSibling;
+			cursor = step(cursor.nextSibling);
 			parent.removeChild(gone);
 		}
 		return;
@@ -236,7 +242,7 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 	}
 	let old_keys = null;
 	let old_inner = null;
-	for (let n = cursor; n; n = n.nextSibling) {
+	for (let n = cursor; n; n = step(n.nextSibling)) {
 		const k = key_of(n);
 		if (k !== null) (old_keys ??= /* @__PURE__ */ new Map()).set(k, n);
 		else if (sets !== null && n.nodeType === ELEMENT) {
@@ -260,7 +266,7 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 		const next = new_nodes[idx];
 		if (cursor && key_of(next) === null && same_node(cursor, next)) {
 			const here = cursor;
-			cursor = cursor.nextSibling;
+			cursor = step(cursor.nextSibling);
 			morph_same(here, next, sets, walk);
 		} else parent.insertBefore(clone(next), cursor);
 	}
@@ -271,7 +277,7 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 			const matched = old_keys?.get(next_key);
 			if (matched !== void 0) {
 				old_keys.delete(next_key);
-				if (matched === cursor) cursor = cursor.nextSibling;
+				if (matched === cursor) cursor = step(cursor.nextSibling);
 				else parent.insertBefore(matched, cursor);
 				morph_node(matched, next, sets, walk);
 				continue;
@@ -281,7 +287,7 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 			const holder = wanted === void 0 ? null : find_holder(old_inner, wanted, next);
 			if (holder !== null) {
 				release_holder(old_inner, sets, holder);
-				if (holder === cursor) cursor = cursor.nextSibling;
+				if (holder === cursor) cursor = step(cursor.nextSibling);
 				else parent.insertBefore(holder, cursor);
 				morph_same(holder, next, sets, walk);
 				continue;
@@ -291,11 +297,11 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 		while (cursor) {
 			cur_key = key_of(cursor);
 			if (cur_key === null || old_keys === null || !old_keys.has(cur_key)) break;
-			cursor = cursor.nextSibling;
+			cursor = step(cursor.nextSibling);
 		}
 		if (cursor && next_key === null && cur_key === null && same_node(cursor, next) && (old_inner === null || !reserved_for_later(sets, new_inner, cursor, idx))) {
 			const here = cursor;
-			cursor = cursor.nextSibling;
+			cursor = step(cursor.nextSibling);
 			if (old_inner !== null) release_holder(old_inner, sets, here);
 			morph_same(here, next, sets, walk);
 			continue;
@@ -304,7 +310,7 @@ function reconcile_children(parent, new_nodes, sets, walk = false) {
 	}
 	while (cursor) {
 		const gone = cursor;
-		cursor = cursor.nextSibling;
+		cursor = step(cursor.nextSibling);
 		parent.removeChild(gone);
 	}
 	if (old_keys) {

package/dist/runtime/nav-handle.d.ts

@@ -16,6 +16,9 @@ export type NavHandle = {
   afterNavigate(fn: AfterNavigateCallback): () => void;
   bust_page_cache(): void;
 };
+/** Feature entry (`mpa-nav`, boot phase): the MPA handle, first — the router's install, later in
+ *  the feature order, replaces it. */
+export declare function install(): void;
 /** Publish the document's navigation handle (the router's replaces the MPA one). */
 export declare function publish_nav(handle: NavHandle): void;
 /**

package/dist/runtime/nav-handle.js

@@ -13,16 +13,23 @@ import { speculate_url } from "./speculate-hint.js";
 * from the global realm (the same pattern as the Kit page bridge, `Symbol.for('ogygia.kit-page')`),
 * and `test/runtime-boot-svelte-free.test.ts` pins that no island-side module imports a boot module.
 *
-* Who publishes it, always, on a document ogygia boots:
+* Who publishes it, on a document ogygia boots:
 * - the ROUTER feature (./router.ts `install`) — the SPA router's API;
-* - otherwise core (`boot`) publishes {@link mpa_nav}: the browser navigates, preloads become
-*   Speculation Rules hints, and `invalidateAll` is still the soft seed refresh (./router-nav.ts,
-*   loaded on first use) — exactly what `router: false` apps got before.
+* - otherwise the `mpa-nav` feature ({@link install}) publishes {@link mpa_nav}: the browser
+*   navigates, preloads become Speculation Rules hints, and `invalidateAll` is still the soft seed
+*   refresh (./router-nav.ts, loaded on first use) — exactly what `router: false` apps got before.
+*   Installed only when island code can reach the handle (the `page` mark: `$app/navigation`,
+*   `ogygia/app`, or anything the build could not follow): with none of those, nothing reads it.
 *
 * Island code reads it as `globalThis[Symbol.for('ogygia.nav')]` (the key is repeated there on
 * purpose: importing {@link NAV_HANDLE_KEY} would be the very edge this module exists to avoid).
 */
 const NAV_HANDLE_KEY = Symbol.for("ogygia.nav");
+/** Feature entry (`mpa-nav`, boot phase): the MPA handle, first — the router's install, later in
+*  the feature order, replaces it. */
+function install() {
+	if (typeof document !== "undefined" && !(NAV_HANDLE_KEY in globalThis)) publish_nav(mpa_nav());
+}
 /** Publish the document's navigation handle (the router's replaces the MPA one). */
 function publish_nav(handle) {
 	globalThis[NAV_HANDLE_KEY] = handle;
@@ -68,4 +75,4 @@ function mpa_nav() {
 		bust_page_cache() {}
 	};
 }
-export { NAV_HANDLE_KEY, mpa_nav, publish_nav };
+export { NAV_HANDLE_KEY, install, mpa_nav, publish_nav };

package/dist/runtime/ownership.d.ts

@@ -98,4 +98,13 @@ export declare function mark_render_made(node: Node): void;
  * produces at this level (`render_tags`) is render output — a runtime does not make the render's
  * elements. Anything else is the element's own: never matched, never removed.
  */
-export declare function render_made(node: Node, render_tags: ReadonlySet<string>): boolean;
+export declare function render_made(node: Node, render_tags: ReadonlySet<string>): boolean;
+/** Record what the server sent `root` (`<body>`): the attribute names on `sent` (the root as the
+ *  server rendered it), and `children` (the live root's nodes that are the server's) as render output. */
+export declare function record_server_body(root: Element, sent: Element, children: Iterable<Node>): void;
+/** The attribute names the server last sent `root`, or null for a root with no record yet (all of
+ *  it is then taken to be the server's). */
+export declare function server_body_attributes(root: Element): ReadonlySet<string> | null;
+/** Is `node`, a child of `<body>`, the server's? Recorded, or an `<ogygia-region>`. Anything else
+ *  the page's scripts put there: a navigation neither matches nor removes it. */
+export declare function server_body_child(node: Node): boolean;

package/dist/runtime/ownership.js

@@ -112,4 +112,22 @@ function render_made(node, render_tags) {
 	const name = node.localName;
 	return name === REGION || render_tags.has(name);
 }
-export { BAKED_ATTR, HTML_PARENT_ATTR, OPAQUE_ATTR, REGION_RENDER_ATTRS, attributes_writer, is_declared_foreign, is_region_owned, is_self_owned, is_upgraded_ce, mark_render_made, order_owner, owner_of, render_made, slots_light_dom, walk_enters };
+const NO_TAGS = /* @__PURE__ */ new Set();
+const server_attrs = /* @__PURE__ */ new WeakMap();
+/** Record what the server sent `root` (`<body>`): the attribute names on `sent` (the root as the
+*  server rendered it), and `children` (the live root's nodes that are the server's) as render output. */
+function record_server_body(root, sent, children) {
+	server_attrs.set(root, new Set(Array.from(sent.attributes, (a) => a.name)));
+	for (const n of children) mark_render_made(n);
+}
+/** The attribute names the server last sent `root`, or null for a root with no record yet (all of
+*  it is then taken to be the server's). */
+function server_body_attributes(root) {
+	return server_attrs.get(root) ?? null;
+}
+/** Is `node`, a child of `<body>`, the server's? Recorded, or an `<ogygia-region>`. Anything else
+*  the page's scripts put there: a navigation neither matches nor removes it. */
+function server_body_child(node) {
+	return render_made(node, NO_TAGS);
+}
+export { BAKED_ATTR, HTML_PARENT_ATTR, OPAQUE_ATTR, REGION_RENDER_ATTRS, attributes_writer, is_declared_foreign, is_region_owned, is_self_owned, is_upgraded_ce, mark_render_made, order_owner, owner_of, record_server_body, render_made, server_body_attributes, server_body_child, slots_light_dom, walk_enters };

package/dist/runtime/reconcile.d.ts

@@ -27,7 +27,9 @@ export declare function stamp_region_keys(root: ParentNode): void;
  * here, on either document.
  */
 export declare const NO_RECONCILE_SELECTOR = "[data-og-no-reconcile]";
-export declare function reconcile_body(live: Element, next: Element, morph: (parent: Element, nodes: ArrayLike<Node>) => void): void;
+export declare function reconcile_body(live: Element, next: Element, morph: (parent: Element, nodes: ArrayLike<Node>, options?: {
+  stays?: (node: Node) => boolean;
+}) => void): void;
 /**
  * outerSync body swap — the FALLBACK path (reconcile off, or a region trapped in a shadow root the
  * morph can't pierce). The old code did `document.body.replaceWith(doc.body)`, which THROWS AWAY the
@@ -35,7 +37,8 @@ export declare function reconcile_body(live: Element, next: Element, morph: (par
  * analytics, a scroll library) attached to `document.body`. htmx 4 boosts land the same way and use
  * `outerSync` for exactly this reason: keep the element, sync its attributes, replace its children.
  * So we do too — the live body node survives, only its guts change. Incoming children are moved out
- * of the parsed document (insertion adopts them across documents).
+ * of the parsed document (insertion adopts them across documents). The page's own children (a
+ * portal's anchor) stay, as in the reconcile; the server's are replaced.
  */
 export declare function swap_body(live: HTMLElement, next: HTMLElement): void;
 export { endpoint_key, fingerprint_of, fnv1a, signature_of };