@ogygia/core 0.11.4 → 0.11.5

package/dist/nested.js

@@ -0,0 +1,19 @@
+import { getContext, setContext } from "svelte";
+// src/nested.ts
+const NESTED_KEY = Symbol.for("ogygia.nested-island");
+/**
+* Mark the current subtree's hydration state. `true` = inside a hydrated island (nested islands
+* degrade). `false` = a LAKE resets its subtree to "dead", so an island inside the lake self-
+* hydrates again (the nearest-boundary rule — DESIGN.md).
+*/
+function setNested(value = true) {
+	setContext(NESTED_KEY, value);
+}
+/**
+* True when an ancestor island wrapper already marked the subtree. `getContext` returns `undefined`
+* when no ancestor set it (a top-level island) — that absence is exactly "not nested".
+*/
+function isNested() {
+	return getContext(NESTED_KEY) === true;
+}
+export { isNested, setNested };

package/dist/ref-sink.d.ts

@@ -0,0 +1,15 @@
+/**
+ * RESOLVE SINK (reconciler R3) — a hook the runtime installs during an island's hydration to learn
+ * which page-scoped ids that island resolves, WITHOUT the hub knowing anything about the DOM.
+ * `resolve()` (ref.ts) calls the current sink with each id it freshly remembers in the page scope;
+ * the runtime's sink attributes it to the island currently hydrating (region → id-set), so a
+ * reconcile nav can dispose exactly the ids owned by REMOVED regions. Null when no island is
+ * hydrating.
+ *
+ * A leaf of its own (ref.ts re-exports the setter): the hydrate core installs the sink around every
+ * island, wired values or not, and shares modules with Kit's client graph, which uses the rest of
+ * the hub. A shared module ships whole, so reaching the sink through ref.ts sent every island page
+ * the hub's registry and minting.
+ */
+export declare let resolve_sink: ((id: string) => void) | null;
+export declare function set_resolve_sink(fn: ((id: string) => void) | null): void;

package/dist/ref-sink.js

@@ -0,0 +1,19 @@
+// src/ref-sink.ts
+/**
+* RESOLVE SINK (reconciler R3) — a hook the runtime installs during an island's hydration to learn
+* which page-scoped ids that island resolves, WITHOUT the hub knowing anything about the DOM.
+* `resolve()` (ref.ts) calls the current sink with each id it freshly remembers in the page scope;
+* the runtime's sink attributes it to the island currently hydrating (region → id-set), so a
+* reconcile nav can dispose exactly the ids owned by REMOVED regions. Null when no island is
+* hydrating.
+*
+* A leaf of its own (ref.ts re-exports the setter): the hydrate core installs the sink around every
+* island, wired values or not, and shares modules with Kit's client graph, which uses the rest of
+* the hub. A shared module ships whole, so reaching the sink through ref.ts sent every island page
+* the hub's registry and minting.
+*/
+let resolve_sink = null;
+function set_resolve_sink(fn) {
+	resolve_sink = fn;
+}
+export { resolve_sink, set_resolve_sink };

package/dist/ref.d.ts

@@ -1,3 +1,4 @@
+import { set_resolve_sink } from "./ref-sink.js";
 import { batch, notify, watch, watcher_count } from "./ref-watch.js";
 /**
  * THE HUB — ogygia's identity layer. One primitive carries everything that crosses an
@@ -78,7 +79,6 @@ export declare function register_kind(kind: RefKind): void;
  * silently mis-read as one). Same instance → same id, always.
  */
 export declare function mint(value: unknown, only?: ReadonlySet<string>): Ref | undefined;
-export declare function set_resolve_sink(fn: ((id: string) => void) | null): void;
 /**
  * DISPOSE a whole scope (hub v2, phase D) — tear down every instance in its bucket via the
  * instance's `kind.dispose`, run any registered scope-disposers (side-effect cleanups like the
@@ -121,4 +121,4 @@ export declare const REF_WIRE_KEY = "OgygiaRef";
 export declare function ref_reducer(only?: ReadonlySet<string>): (value: unknown) => Ref | undefined;
 /** Devalue reviver for a seam. Browser passes `remember: true`; the server must pass `false`. */
 export declare function ref_reviver(remember: boolean): (ref: Ref) => unknown;
-export { batch, notify, watch, watcher_count };
+export { batch, notify, set_resolve_sink, watch, watcher_count };

package/dist/ref.js

@@ -1,5 +1,6 @@
 import { emit } from "./events/bus.js";
 import { batch, notify, watch, watcher_count, watchers } from "./ref-watch.js";
+import { resolve_sink, set_resolve_sink } from "./ref-sink.js";
 // src/ref.ts
 const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
 const REGISTRY_KEY = Symbol.for("ogygia.hub");
@@ -62,17 +63,6 @@ function mint(value, only) {
 		return ref;
 	}
 }
-/**
-* RESOLVE SINK (reconciler R3) — a hook the runtime installs during an island's hydration to learn
-* which page-scoped ids that island resolves, WITHOUT the hub knowing anything about the DOM.
-* `resolve()` calls the current sink with each id it freshly remembers in the page scope; the
-* runtime's sink attributes it to the island currently hydrating (region → id-set), so a reconcile
-* nav can dispose exactly the ids owned by REMOVED regions. Null when no island is hydrating.
-*/
-let resolve_sink = null;
-function set_resolve_sink(fn) {
-	resolve_sink = fn;
-}
 /** The live bucket for a scope (never 'request' — that scope is never stored). */
 function bucket(reg, scope) {
 	let b = reg.instances.get(scope);

package/dist/runtime/core.js

@@ -1,7 +1,6 @@
 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";
@@ -10,7 +9,6 @@ import { is_awake, is_deferred, is_frozen, ours_on_kit_document, phase2_hydrate_
 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;
@@ -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,7 +1125,6 @@ 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();

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/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/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/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

@@ -64,10 +64,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
@@ -156,7 +168,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 };