@ogygia/core 0.11.4 → 0.12.0

package/dist/runtime/reconcile.js

@@ -1,5 +1,5 @@
 import { dispose_ids } from "../ref.js";
-import { boot_link, morph_sync_attributes } from "./slots.js";
+import { boot_link, morph_sync_attributes, slots } from "./slots.js";
 import { region_owned_ids } from "./region-ids.js";
 import { emit } from "../events/bus.js";
 import { endpoint_key, fingerprint_of, fnv1a, signature_of } from "./hash.js";
@@ -27,22 +27,48 @@ import { endpoint_key, fingerprint_of, fnv1a, signature_of } from "./hash.js";
 const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
 const props_sidecar_of = (region) => boot_link().props_sidecar_of(region);
 /**
-* `<body>`'s attributes have two owners (runtime/ownership.ts): the server, page by page (a theme
-* class, a layout flag), and the scripts living on the page (a scroll lock, a consent banner's state,
-* an analytics marker). A navigation moves the server's attributes to the new page's — and removes
-* only those the PREVIOUS page's server sent that the new one doesn't. An attribute a script set is
-* not the server's to take away (before this, every navigation stripped them all). The server's set
-* starts as the body's attributes when this module loads, which the runtime does before the page's
-* own scripts (head-presence.ts puts it first).
+* `<body>` has two owners (runtime/ownership.ts): the server, page by page (a theme class, a layout
+* flag, the content), and the scripts living on the page (a scroll lock, a consent banner's state; a
+* component mounted into the body, such as a popover's portal). A navigation moves the server's part
+* to the new page's and leaves the page's part alone:
+*  - ATTRIBUTES: it removes only those the PREVIOUS page's server sent that the new one doesn't;
+*  - CHILDREN: the morph steps over a child the server never sent (a portal's mount anchor: taking
+*    it away leaves the portal inserting its content beside a detached node, so a popover in a kept
+*    island never opens again).
+* ONE record per reconciled root (ownership.ts `record_server_body`), reached through the boot
+* registry like every boot helper this lazy chunk uses: the router takes the body's when it starts,
+* before any island wakes; each reconcile renews its root's (a harness driving it on its own root
+* gets one from its first call). A root with no record yet is all the server's: every child is
+* matched, and no attribute is taken away.
 */
-const attr_names = (el) => new Set(Array.from(el.attributes, (a) => a.name));
-let server_body_attrs = typeof document !== "undefined" && document.body ? attr_names(document.body) : null;
+/** The record of what the server last sent `live`, or null while there is none. */
+function body_record(live) {
+	const link = slots.boot;
+	return link && link.server_body_attributes(live) !== null ? link : null;
+}
 function sync_body_attributes(live, next) {
 	morph_sync_attributes()(live, next, true);
-	if (server_body_attrs) {
-		for (const name of server_body_attrs) if (!next.hasAttribute(name)) live.removeAttribute(name);
+	const sent = body_record(live)?.server_body_attributes(live);
+	if (sent) {
+		for (const name of sent) if (!next.hasAttribute(name)) live.removeAttribute(name);
 	}
-	server_body_attrs = attr_names(next);
+}
+/** The live body's children that are the page's own, not the server's (none without a record). */
+function page_own_children(live) {
+	const own = /* @__PURE__ */ new Set();
+	const record = body_record(live);
+	if (record === null) return own;
+	for (let n = live.firstChild; n; n = n.nextSibling) if (!record.server_body_child(n)) own.add(n);
+	return own;
+}
+/** After a navigation the server's body is the new page's: its attributes, and every live child that
+*  is not the page's own. */
+function renew_server_body(live, next, own) {
+	const link = slots.boot;
+	if (!link) return;
+	const children = [];
+	for (let n = live.firstChild; n; n = n.nextSibling) if (!own.has(n)) children.push(n);
+	link.record_server_body(live, next, children);
 }
 /** The `<script data-ogygia-props>` seed text of a region — keyed at the end of the body or the
 *  adjacent sibling (runtime/sidecar.ts) — or '' — the same lookup the hydrator uses, read-only.
@@ -143,6 +169,7 @@ function dt_emit_reconcile(live, next) {
 function reconcile_body(live, next, morph) {
 	stamp_region_keys(live);
 	stamp_region_keys(next);
+	const own = page_own_children(live);
 	sync_body_attributes(live, next);
 	if (DEVTOOLS) dt_emit_reconcile(live, next);
 	const next_keys = /* @__PURE__ */ new Set();
@@ -158,7 +185,8 @@ function reconcile_body(live, next, morph) {
 		if (set !== void 0) for (const id of set) removed_ids.push(id);
 	}
 	absorb_kept_props(live, next);
-	morph(live, next.childNodes);
+	morph(live, next.childNodes, own.size > 0 ? { stays: (n) => own.has(n) } : void 0);
+	renew_server_body(live, next, own);
 	if (removed_ids.length > 0) dispose_ids(removed_ids);
 }
 /**
@@ -168,12 +196,20 @@ function reconcile_body(live, next, morph) {
 * 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.
 */
 function swap_body(live, next) {
+	const own = page_own_children(live);
 	sync_body_attributes(live, next);
-	live.replaceChildren();
+	if (own.size === 0) live.replaceChildren();
+	else for (let n = live.firstChild; n;) {
+		const here = n;
+		n = n.nextSibling;
+		if (!own.has(here)) live.removeChild(here);
+	}
 	while (next.firstChild) live.appendChild(next.firstChild);
+	renew_server_body(live, next, own);
 }
 /** For each live region whose reconcile key also appears in `next`, push the incoming region's
 *  props into the live island (kept regions only — a re-mounting region gets its props on mount). */

package/dist/runtime/region-endpoint-url.js

@@ -143,6 +143,7 @@ function warm_key(url) {
 function warm_island_module(entry, base, cls = "speculative") {
 	const url = island_module_url(entry, base);
 	if (!url) return;
+	if (!entry_location(entry, base) && url.includes("/ogygia/og-region.")) return;
 	const key = warm_key(url);
 	if (warmed_modules.has(key)) return;
 	warmed_modules.add(key);

package/dist/runtime/region-ids.js

@@ -1,8 +1,8 @@
-import { set_resolve_sink } from "../ref.js";
+import { set_resolve_sink } from "../ref-sink.js";
 // src/runtime/region-ids.ts
 /**
 * R3 OWNERSHIP: which page-scoped hub ids each region's island resolved during hydration. The
-* hydrate core installs a resolve-sink (ref.set_resolve_sink) around each island's sync prop +
+* hydrate core installs a resolve-sink (ref-sink.ts `set_resolve_sink`) around each island's sync prop +
 * context decode that funnels ids here, keyed by the region element; the reconciler (a navigation)
 * disposes exactly the ids of REMOVED regions. WeakMap → a removed element's set is GC'd with it.
 * Its own module so the boot-time reconciler and the lazily loaded hydrate core share one map

package/dist/runtime/remote-seeds.js

@@ -1,4 +1,4 @@
-import { slots } from "./slots.js";
+import { boot_link, slots } from "./slots.js";
 import { seed_query_responses } from "../shims/kit-remote/client-stub.js";
 import { clear_remote_instances, clear_remote_seeds } from "../shims/kit-remote/remote-cache.js";
 // src/runtime/remote-seeds.ts
@@ -7,12 +7,23 @@ import { clear_remote_instances, clear_remote_seeds } from "../shims/kit-remote/
 * `application/ogygia-remote` side-channel (zero-flash hydration), and clear it across SPA swaps.
 *
 * A HYDRATE-phase feature (link/runtime-entry.ts): installed by the hydrate core, never the boot —
-* only `seeds.ts` (hydrate core) reads the slot, and the decoder imports the APP's transport codecs
-* (its own `src/hooks.ts`), which reach Svelte.
+* only the hydrate core (and the navigation's seeds.ts) reads the slot, and the decoder imports the
+* APP's transport codecs (its own `src/hooks.ts`), which reach Svelte. Installed only in an app that
+* has a remote function at all.
 */
+const REMOTE_SEED_SELECTOR = "script[type=\"application/ogygia-remote\"]";
+function seed_once() {
+	const session = boot_link().runtime_session;
+	if (session.remote_seeded) return;
+	session.mark_remote_seeded();
+	if (typeof document === "undefined") return;
+	const text = document.querySelector(REMOTE_SEED_SELECTOR)?.textContent;
+	if (text) seed_query_responses(text);
+}
 /** Feature entry: fill the `remoteSeeds` slot. */
 function install() {
 	slots.remoteSeeds = {
+		seed_once,
 		seed_query_responses,
 		clear_remote_seeds,
 		clear_remote_instances

package/dist/runtime/router-nav.js

@@ -389,6 +389,18 @@ function preflight(doc, dest) {
 	stamp_region_keys(doc.body);
 	page_seed_of(doc);
 }
+/**
+* Which client build a document belongs to: its runtime script's file and its location map's
+* (server/document-tail.ts `runtime_bootstrap_tags`) — both content-hashed, so a deploy that changed
+* any island, Svelte or the runtime names another. By file name: a `src` written relative to its
+* page reads the same from any address. Null: the document names no runtime (no island on it).
+*/
+function build_of(d) {
+	const s = d.querySelector("script[data-ogygia-runtime]");
+	if (!s) return null;
+	const file = (v) => v ? v.slice(v.lastIndexOf("/") + 1) : "";
+	return file(s.getAttribute("src")) + " " + file(s.getAttribute("data-og-locations"));
+}
 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;
@@ -460,6 +472,9 @@ async function navigate(r, url, from, { push = true, pop_scroll = null, type = "
 	if (KitBoot.document_has(doc)) return hand_off();
 	const marker = doc.querySelector("meta[name=\"ogygia-router\"]");
 	if (!marker) return hand_off();
+	const next_build = build_of(doc);
+	const this_build = next_build === null ? null : build_of(document);
+	if (this_build !== null && next_build !== this_build) return hand_off();
 	if (doc.querySelector("meta[name=\"ogygia-first-load\"]")) return hand_off();
 	globalThis.__og_restore?.(doc);
 	if (dest !== url) replace_state({

package/dist/runtime/router.js

@@ -2,6 +2,7 @@ import { kit_hydrates_page } from "./kit-boot.js";
 import { slots } from "./slots.js";
 import { publish_nav } from "./nav-handle.js";
 import { nearest_attr } from "./nearest-attr.js";
+import { record_server_body } from "./ownership.js";
 // src/runtime/router.ts
 /**
 * Minimal SPA router for ogygia (Astro's ClientRouter equivalent).
@@ -300,6 +301,8 @@ var SpaRouter = class {
 		this.#started = true;
 		this.doc_key = document_key(new URL(location.href));
 		this.current_url = new URL(location.href);
+		const body = document.body;
+		if (body) record_server_body(body, body, Array.from(body.childNodes));
 		document.addEventListener("click", (event) => {
 			const anchor = anchor_of(event);
 			const url = this.#should_intercept(event, anchor);

package/dist/runtime/seeds.d.ts

@@ -1,8 +1,14 @@
+import { parse_sidecar_text } from "./wire-format.js";
 import { PageSnapshot } from "../shims/page-store.svelte.js";
 export declare const PAGE_SEED_SELECTOR = "script[type=\"application/ogygia-page\"]";
-/** A seed or props script's payload, in its lane (wire-format.ts): JSON when the server marked
- *  it plain, devalue with `revivers` otherwise. Every seed / props read goes through here. */
-export declare function parse_sidecar_text(el: Element, revivers?: Record<string, (d: never) => unknown>): unknown;
+/**
+ * The PAGE feature (link/runtime-entry.ts, hydrate phase): what island code sees of its page — the
+ * page seed behind `$app/state` / `$app/stores`, the seed references in island props, and, on a
+ * Kit-hydrated document, the wait for Kit's own page. Installed only when island code can reach
+ * Kit's world (the driver's island-closure walk, failing open on anything it cannot follow): an app
+ * whose islands never read their page gets no seed from the server and ships none of this.
+ */
+export declare function install(): void;
 type PageSeed = Partial<Omit<PageSnapshot, "url"> & {
   url: string | URL;
 }>;
@@ -19,7 +25,6 @@ export declare function page_seed_of(doc: Document): PageSeed | null;
  * on first ask), the once-parsed seed for a foreign one. `undefined` when the document has no seed.
  */
 export declare function seed_data_of(doc: Document): unknown;
-export declare function seed_remote_once(): void;
 /** Document-level page seed (one script from ogygiaHandle) — once per document; then any page facts
  *  an answer brought since. Every hydrate calls it, before the island reads `page`. */
 export declare function seed_page_once(): void;
@@ -47,4 +52,4 @@ export declare function prepare_spa_document(): void;
  * already spent (`once`) — that reuse never opens SSE again and leaves "connecting…".
  */
 export declare function finish_spa_document(): void;
-export {};
+export { parse_sidecar_text };

package/dist/runtime/seeds.js

@@ -1,8 +1,9 @@
-import { parse_wire_text, wire_is_json } from "./wire-format.js";
+import { parse_sidecar_text, parse_wire_text } from "./wire-format.js";
 import { page_state, reset_page, set_page } from "../shims/page-store.svelte.js";
 import { kit_bridge } from "../shims/kit-bridge.js";
 import { install_page_defer, page_defer_revivers } from "./page-defer.js";
 import { transport_decoders } from "./app-transport.js";
+import { kit_page_thread } from "./kit-page-thread.svelte.js";
 import { boot_link, slots } from "./slots.js";
 // src/runtime/seeds.ts
 /**
@@ -38,10 +39,19 @@ const session = () => boot_link().runtime_session;
 const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
 const PAGE_SEED_SELECTOR = "script[type=\"application/ogygia-page\"]";
 const REMOTE_SEED_SELECTOR = "script[type=\"application/ogygia-remote\"]";
-/** A seed or props script's payload, in its lane (wire-format.ts): JSON when the server marked
-*  it plain, devalue with `revivers` otherwise. Every seed / props read goes through here. */
-function parse_sidecar_text(el, revivers) {
-	return parse_wire_text(el.textContent ?? "", wire_is_json(el), revivers);
+/**
+* The PAGE feature (link/runtime-entry.ts, hydrate phase): what island code sees of its page — the
+* page seed behind `$app/state` / `$app/stores`, the seed references in island props, and, on a
+* Kit-hydrated document, the wait for Kit's own page. Installed only when island code can reach
+* Kit's world (the driver's island-closure walk, failing open on anything it cannot follow): an app
+* whose islands never read their page gets no seed from the server and ships none of this.
+*/
+function install() {
+	slots.page = {
+		seed_page_once,
+		seed_data_of,
+		kit_page_thread
+	};
 }
 let parses = 0;
 /** Test seam: how many page-seed scripts were parsed since boot (one per document is the law). */
@@ -106,12 +116,6 @@ function apply_remote_seed_text(text) {
 	if (!text) return;
 	slots.remoteSeeds?.seed_query_responses(text);
 }
-function seed_remote_once() {
-	if (session().remote_seeded) return;
-	session().mark_remote_seeded();
-	if (typeof document === "undefined") return;
-	apply_remote_seed_text(document.querySelector(REMOTE_SEED_SELECTOR)?.textContent);
-}
 /** Document-level page seed (one script from ogygiaHandle) — once per document; then any page facts
 *  an answer brought since. Every hydrate calls it, before the island reads `page`. */
 function seed_page_once() {
@@ -205,4 +209,4 @@ function prepare_spa_document() {
 function finish_spa_document() {
 	slots.remoteSeeds?.clear_remote_instances();
 }
-export { PAGE_SEED_SELECTOR, apply_soft_invalidate_doc, finish_spa_document, page_seed_of, parse_sidecar_text, prepare_spa_document, seed_data_of, seed_page_once, seed_parse_count, seed_remote_once };
+export { PAGE_SEED_SELECTOR, apply_soft_invalidate_doc, finish_spa_document, install, page_seed_of, parse_sidecar_text, prepare_spa_document, seed_data_of, seed_page_once, seed_parse_count };

package/dist/runtime/slots.d.ts

@@ -9,7 +9,7 @@ import { regions_in_shadow } from "./connected.js";
 import { yield_task } from "./schedule.js";
 import { beacon_nav } from "./beacon.js";
 import { load_slot } from "./load-scheduler.js";
-import { is_self_owned, walk_enters } from "./ownership.js";
+import { is_self_owned, record_server_body, server_body_attributes, server_body_child, walk_enters } from "./ownership.js";
 import { document_key, jump_to_hash, push_state, replace_state } from "./router.js";
 import { resolve_address } from "./interaction.js";
 import { sync_attributes } from "./morph.js";
@@ -53,9 +53,11 @@ export type FormOps = {
 /** Wake a cold island when interaction lands inside it; returns a disarm fn. */
 export type ArmFn = (el: HTMLElement, fire: () => void) => void | (() => void);
 /** `target: 'walk'` = the hydration repair (the server sequence Svelte's walk binds); default = a live
- *  morph toward a new answer. Same ownership rules either way (runtime/ownership.ts). */
+ *  morph toward a new answer. Same ownership rules either way (runtime/ownership.ts). `stays`: a
+ *  child of `parent` the morph steps over (the page's own, beside the render's). */
 export type MorphFn = (parent: Element, nodes: ArrayLike<Node>, options?: {
   target?: "live" | "walk";
+  stays?: (node: Node) => boolean;
 }) => void;
 export type WireOps = {
   /** THE hub key (`OgygiaRef`) — every transportable kind crosses under it. */
@@ -64,10 +66,22 @@ export type WireOps = {
   resolve: (ref: never, remember: boolean) => unknown;
 };
 export type RemoteSeedOps = {
+  /** this document's remote seed into the query cache, once per document */
+  seed_once(): void;
   seed_query_responses(text: string): void;
   clear_remote_seeds(): void;
   clear_remote_instances(): void;
 };
+/** The page as island code sees it, filled by the `page` feature (./seeds.ts). Null when no island
+ *  code can read its page: the server ships no seed then, so there is nothing to parse or wait for. */
+export type PageOps = {
+  /** the document's page seed into the page store (once), then any page facts answers brought */
+  seed_page_once(): void;
+  /** the `page.data` a seed reference in island props resolves against */
+  seed_data_of(doc: Document): unknown;
+  /** on a Kit-hydrated document: the wait for Kit to apply its page (`null` once applied) */
+  kit_page_thread(): Promise<void> | null;
+};
 /**
  * The client frame store, filled by the `frames` feature. Core reads it ONLY on the deferred /
  * live / SWR-lake paths (a region with a signed `endpoint`), so a plain load-hydrated app never
@@ -137,6 +151,10 @@ export type BootLink = {
   /** DOM ownership (./ownership.ts): which children Svelte's walk enters, and self-owned elements */
   walk_enters: typeof walk_enters;
   is_self_owned: typeof is_self_owned;
+  /** `<body>`'s two owners (./ownership.ts): the router's record of what the server sent it */
+  record_server_body: typeof record_server_body;
+  server_body_attributes: typeof server_body_attributes;
+  server_body_child: typeof server_body_child;
 };
 export type RouterLink = {
   document_key: typeof document_key;
@@ -156,7 +174,11 @@ export type Slots = {
   /** a kept island's host (the live feature fills it beside `live`) */
   keep: Component<Record<string, unknown>> | null;
   wire: WireOps | null;
+  /** The transportable classes an island's props, context and seeds need, loaded before it
+   *  decodes (./wire-classes.ts). Null in an app without transportable classes: nothing to load. */
+  wire_classes: ((region: Element) => Promise<unknown> | null) | null;
   remoteSeeds: RemoteSeedOps | null;
+  page: PageOps | null;
   frames: FrameOps | null;
   nav: NavOps | null;
   /**

package/dist/runtime/slots.js

@@ -22,7 +22,9 @@ const slots = {
 	live: null,
 	keep: null,
 	wire: null,
+	wire_classes: null,
 	remoteSeeds: null,
+	page: null,
 	frames: null,
 	nav: null,
 	context: null,

package/dist/runtime/wire-classes.d.ts

@@ -1,3 +1,5 @@
+/** Feature entry: fill the `wire_classes` slot. */
+export declare function install(): void;
 /** The loads this island's props, context and page seeds need, or `null` when none (the common
  *  case: an app without transportables, or an island that carries none). */
 export declare function wire_classes_for(region: Element): Promise<unknown> | null;

package/dist/runtime/wire-classes.js

@@ -1,5 +1,6 @@
 import { props_sidecar_of } from "./sidecar.js";
 import { yield_task } from "./schedule.js";
+import { slots } from "./slots.js";
 import { wire_all, wire_loaders } from "virtual:ogygia/transportables";
 // src/runtime/wire-classes.ts
 /**
@@ -14,7 +15,15 @@ import { wire_all, wire_loaders } from "virtual:ogygia/transportables";
 * The small texts are checked for each class's tag path (`"<path>#`). An app that sends wired values
 * through Kit's `transport` (`wire_all`: remote functions, loads) gets every class with every island,
 * as before: those values decode synchronously whenever they arrive. Each module loads once.
+*
+* A BOOT-phase feature (link/runtime-entry.ts), installed only when the app has transportable
+* classes: without one the loader map is empty, but the bundler cannot see that through the virtual
+* module, so this code shipped to every island page for a lookup that always found nothing.
 */
+/** Feature entry: fill the `wire_classes` slot. */
+function install() {
+	slots.wire_classes = wire_classes_for;
+}
 const loaders = wire_loaders;
 const paths = Object.keys(loaders);
 const loading = /* @__PURE__ */ new Map();
@@ -66,4 +75,4 @@ function wire_classes_for(region) {
 	for (const p of want) pending.push(load(p));
 	return Promise.all(pending);
 }
-export { wire_classes_for };
+export { install, wire_classes_for };

package/dist/runtime/wire-format.d.ts

@@ -4,4 +4,7 @@ export declare const WIRE_FORMAT_JSON = "json";
 export declare function wire_is_json(el: Element): boolean;
 /** Parse a side-channel's text in its lane: `JSON.parse` for the JSON lane (nothing to revive by
  *  construction), devalue `parse` with the caller's revivers otherwise. */
-export declare function parse_wire_text(text: string, json: boolean, revivers?: Record<string, (value: never) => unknown>): unknown;
+export declare function parse_wire_text(text: string, json: boolean, revivers?: Record<string, (value: never) => unknown>): unknown;
+/** A seed or props script's payload, in its lane: JSON when the server marked it plain, devalue
+ *  with `revivers` otherwise. Every seed / props read goes through here. */
+export declare function parse_sidecar_text(el: Element, revivers?: Record<string, (d: never) => unknown>): unknown;

package/dist/runtime/wire-format.js

@@ -19,4 +19,9 @@ function wire_is_json(el) {
 function parse_wire_text(text, json, revivers) {
 	return json ? JSON.parse(text) : parse(text, revivers);
 }
-export { WIRE_FORMAT_ATTR, WIRE_FORMAT_JSON, parse_wire_text, wire_is_json };
+/** A seed or props script's payload, in its lane: JSON when the server marked it plain, devalue
+*  with `revivers` otherwise. Every seed / props read goes through here. */
+function parse_sidecar_text(el, revivers) {
+	return parse_wire_text(el.textContent ?? "", wire_is_json(el), revivers);
+}
+export { WIRE_FORMAT_ATTR, WIRE_FORMAT_JSON, parse_sidecar_text, parse_wire_text, wire_is_json };

package/dist/seed-ref-reviver.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The CLIENT half of seed references (seed-refs.ts): the devalue type tag and the reviver that
+ * resolves a reference against the page seed. Its own module because the hydrate core is a lazy
+ * runtime chunk that shares modules with Kit's client graph (route components compiled for the
+ * browser, never loaded on a csr=false page). The bundler keeps a shared module whole — every
+ * export ANY importer uses — so while the reviver lived beside the server-side index and planner,
+ * every island page downloaded the planner (~4 kB) for the Kit graph's sake. A leaf holds only
+ * what the hydrate core runs.
+ */
+/** The devalue type tag. */
+export declare const SEED_REF_KEY = "OgygiaSeedRef";
+export type SeedPath = (string | number)[];
+/** Client: the node a path points at, or `undefined` when the seed does not have it. */
+export declare function resolve_seed_ref(data: unknown, path: SeedPath): unknown;
+/**
+ * Client reviver for the devalue type: resolve BY REFERENCE. The island receives the seed's own
+ * node — the same object its `page.data` read would hand it, shared exactly the way `page.data`
+ * already is between islands. A deep copy per reference (129 of them on a measured page) bought
+ * nothing: island props are a snapshot either way, and the DEV mutation guard the runtime wraps
+ * every island's props in (`PropMutationGuard`) already warns on a write into them. `get_data` is
+ * called lazily, once per reviver — the first reference resolves the seed. A dangling path (no seed,
+ * or a seed that does not carry the node) revives to `undefined` and, in dev, says why.
+ */
+export declare function seed_ref_reviver(get_data: () => unknown): (path: SeedPath) => unknown;

package/dist/seed-ref-reviver.js

@@ -0,0 +1,44 @@
+// src/seed-ref-reviver.ts
+/**
+* The CLIENT half of seed references (seed-refs.ts): the devalue type tag and the reviver that
+* resolves a reference against the page seed. Its own module because the hydrate core is a lazy
+* runtime chunk that shares modules with Kit's client graph (route components compiled for the
+* browser, never loaded on a csr=false page). The bundler keeps a shared module whole — every
+* export ANY importer uses — so while the reviver lived beside the server-side index and planner,
+* every island page downloaded the planner (~4 kB) for the Kit graph's sake. A leaf holds only
+* what the hydrate core runs.
+*/
+/** The devalue type tag. */
+const SEED_REF_KEY = "OgygiaSeedRef";
+/** Client: the node a path points at, or `undefined` when the seed does not have it. */
+function resolve_seed_ref(data, path) {
+	let cur = data;
+	for (const key of path) {
+		if (cur === null || typeof cur !== "object") return void 0;
+		cur = cur[key];
+	}
+	return cur;
+}
+/**
+* Client reviver for the devalue type: resolve BY REFERENCE. The island receives the seed's own
+* node — the same object its `page.data` read would hand it, shared exactly the way `page.data`
+* already is between islands. A deep copy per reference (129 of them on a measured page) bought
+* nothing: island props are a snapshot either way, and the DEV mutation guard the runtime wraps
+* every island's props in (`PropMutationGuard`) already warns on a write into them. `get_data` is
+* called lazily, once per reviver — the first reference resolves the seed. A dangling path (no seed,
+* or a seed that does not carry the node) revives to `undefined` and, in dev, says why.
+*/
+function seed_ref_reviver(get_data) {
+	let data;
+	let resolved = false;
+	return (path) => {
+		if (!resolved) {
+			data = get_data();
+			resolved = true;
+		}
+		const node = resolve_seed_ref(data, path);
+		if (node === void 0 && typeof console !== "undefined" && import.meta.env?.DEV) console.warn(`[ogygia] island props reference page.data at ${JSON.stringify(path)} but the page seed does not carry it — the island receives undefined there.`);
+		return node;
+	};
+}
+export { SEED_REF_KEY, resolve_seed_ref, seed_ref_reviver };

package/dist/seed-refs.d.ts

@@ -1,6 +1,4 @@
-/** The devalue type tag. */
-export declare const SEED_REF_KEY = "OgygiaSeedRef";
-export type SeedPath = (string | number)[];
+import { SEED_REF_KEY, SeedPath, resolve_seed_ref, seed_ref_reviver } from "./seed-ref-reviver.js";
 export interface SeedIndex {
   /** node → its path from `page.data` (identity matches: the app passed the seed's own object).
    *  The path is materialised on the first ask — an indexed node that no island references
@@ -90,16 +88,4 @@ export interface SeedRefPlan {
  * no walk of its own beyond the pointer lookups.
  */
 export declare function plan_seed_refs(index: SeedIndex, props: unknown, min_bytes?: number): SeedRefPlan;
-/** Client: the node a path points at, or `undefined` when the seed does not have it. */
-export declare function resolve_seed_ref(data: unknown, path: SeedPath): unknown;
-/**
- * Client reviver for the devalue type: resolve BY REFERENCE. The island receives the seed's own
- * node — the same object its `page.data` read would hand it, shared exactly the way `page.data`
- * already is between islands. A deep copy per reference (129 of them on a measured page) bought
- * nothing: island props are a snapshot either way, and the DEV mutation guard the runtime wraps
- * every island's props in (`PropMutationGuard`) already warns on a write into them. `get_data` is
- * called lazily, once per reviver — the first reference resolves the seed. A dangling path (no seed,
- * or a seed that does not carry the node) revives to `undefined` and, in dev, says why.
- */
-export declare function seed_ref_reviver(get_data: () => unknown): (path: SeedPath) => unknown;
-export {};
+export { SEED_REF_KEY, type SeedPath, resolve_seed_ref, seed_ref_reviver };

package/dist/seed-refs.js

@@ -1,4 +1,5 @@
 import { fnv1a } from "./runtime/hash.js";
+import { SEED_REF_KEY, resolve_seed_ref, seed_ref_reviver } from "./seed-ref-reviver.js";
 // src/seed-refs.ts
 /**
 * SEED REFERENCES — island props that point into the page seed instead of copying it.
@@ -43,8 +44,6 @@ import { fnv1a } from "./runtime/hash.js";
 * Universal module (no Node imports): the index + reducer run on the server, the resolver on the
 * client, and the unit tests exercise both ends against a real devalue round trip.
 */
-/** The devalue type tag. */
-const SEED_REF_KEY = "OgygiaSeedRef";
 /** A node the codec may reference: a plain object or an array (own prototype only). */
 function is_plain(v) {
 	if (v === null || typeof v !== "object") return false;
@@ -453,35 +452,4 @@ function plan_seed_refs(index, props, min_bytes = 96) {
 		keys
 	};
 }
-/** Client: the node a path points at, or `undefined` when the seed does not have it. */
-function resolve_seed_ref(data, path) {
-	let cur = data;
-	for (const key of path) {
-		if (cur === null || typeof cur !== "object") return void 0;
-		cur = cur[key];
-	}
-	return cur;
-}
-/**
-* Client reviver for the devalue type: resolve BY REFERENCE. The island receives the seed's own
-* node — the same object its `page.data` read would hand it, shared exactly the way `page.data`
-* already is between islands. A deep copy per reference (129 of them on a measured page) bought
-* nothing: island props are a snapshot either way, and the DEV mutation guard the runtime wraps
-* every island's props in (`PropMutationGuard`) already warns on a write into them. `get_data` is
-* called lazily, once per reviver — the first reference resolves the seed. A dangling path (no seed,
-* or a seed that does not carry the node) revives to `undefined` and, in dev, says why.
-*/
-function seed_ref_reviver(get_data) {
-	let data;
-	let resolved = false;
-	return (path) => {
-		if (!resolved) {
-			data = get_data();
-			resolved = true;
-		}
-		const node = resolve_seed_ref(data, path);
-		if (node === void 0 && typeof console !== "undefined" && import.meta.env?.DEV) console.warn(`[ogygia] island props reference page.data at ${JSON.stringify(path)} but the page seed does not carry it — the island receives undefined there.`);
-		return node;
-	};
-}
 export { SEED_REF_KEY, analyze, deep_equal_plain, index_seed, json_culprit, plan_seed_refs, resolve_seed_ref, seed_ref_reviver, set_measure_memo_reader };

package/dist/server/document-tail.d.ts

@@ -41,9 +41,10 @@ export declare function modulepreload_tag(href: string): string;
  * module's imports after downloading and parsing it; hinted here, they download ALONGSIDE the
  * runtime instead of one round trip after it. Normal priority — the runtime cannot run without
  * them. `data-ogygia-runtime-dep` keeps them attached to the script when the handle moves it
- * (head-presence.ts `runtime_first`).
+ * (head-presence.ts `runtime_first`). `locations`: the build's location map, which the runtime reads
+ * for a load that arrives with an identity alone (runtime/entry-locations.ts).
  */
-export declare function runtime_bootstrap_tags(src: string, deps: readonly string[]): string;
+export declare function runtime_bootstrap_tags(src: string, deps: readonly string[], locations?: string | null): string;
 /**
  * The island graph (island-graph.ts) as one inert JSON script: entry → the chunks its code needs.
  * The runtime turns an entry's list into modulepreload links when that island wakes. Empty map →

package/dist/server/document-tail.js

@@ -33,10 +33,11 @@ function modulepreload_tag(href) {
 * module's imports after downloading and parsing it; hinted here, they download ALONGSIDE the
 * runtime instead of one round trip after it. Normal priority — the runtime cannot run without
 * them. `data-ogygia-runtime-dep` keeps them attached to the script when the handle moves it
-* (head-presence.ts `runtime_first`).
+* (head-presence.ts `runtime_first`). `locations`: the build's location map, which the runtime reads
+* for a load that arrives with an identity alone (runtime/entry-locations.ts).
 */
-function runtime_bootstrap_tags(src, deps) {
-	let html = "<script type=\"module\" data-ogygia-runtime src=\"" + src + "\"><\/script>";
+function runtime_bootstrap_tags(src, deps, locations = null) {
+	let html = "<script type=\"module\" data-ogygia-runtime" + (locations ? " data-og-locations=\"" + locations + "\"" : "") + " src=\"" + src + "\"><\/script>";
 	for (const dep of deps) html += "<link rel=\"modulepreload\" href=\"" + dep + "\" data-ogygia-runtime-dep>";
 	return html;
 }