@ogygia/core 0.0.0 → 0.11.0

package/dist/runtime/session.js

@@ -0,0 +1,130 @@
+import { ConcurrencyGate } from "./concurrency.js";
+import { FROZEN_SELECTOR } from "./region-attrs.js";
+// src/runtime/session.ts
+/**
+* Document-scoped runtime session: lake caches, seed flags, kit-page probe, server-island gate.
+* Cleared on SPA body swap via `reset()` so connecting regions never see the previous page.
+*/
+/** Soft cap on lake cache entries (unique lake ids). Evict oldest insertion on overflow. */
+const LAKE_CACHE_MAX = 64;
+/**
+* WHO OWNS EACH NODE IN `<head>` — the rule every head write and removal follows.
+*
+*   - The PAGE owns the head the server sent and everything the router or the runtime puts there for
+*     the page (merged heads, hoisted region sheets, preload links, hints). A navigation replaces
+*     page-owned nodes, and only those.
+*   - An ISLAND owns what its `<svelte:head>` renders live (csr=false: the island hydrates alone, so
+*     its head block renders fresh — hydrate-core.ts `neutralize_head_hydration_markers`). Only the
+*     island's own teardown removes those: Svelte deletes a head block by walking from its first node
+*     to its last, and if anyone else removes the last one first, the walk runs to the end of <head>
+*     and deletes the next page's tags with it (field: description / canonical / og:* gone after a
+*     client navigation).
+*   - Anything else (a third-party or dev-tooling inject) is not ours and is never removed — the rule
+*     SvelteKit's own router follows.
+*
+* And ONE copy: while an island's head content is live, the page's identical server copy of it is
+* retired (field: two identical JSON-LD blocks, duplicated inline CSS and preloads). Only page-owned
+* copies are ever retired — never an island's live node — and never a stylesheet link (removing either
+* copy could unstyle the page for a frame; a doubled sheet is harmless).
+*/
+const STYLESHEET_REL_RE = /(?:^|\s)stylesheet(?:\s|$)/i;
+var RuntimeSession = class {
+	/** Page-owned head nodes (see above). Survives `reset()`: it is the document's, not a page's. */
+	page_head = /* @__PURE__ */ new WeakSet();
+	/** Island-owned head ELEMENTS still to watch (pruned when they leave the document). */
+	island_head = /* @__PURE__ */ new Set();
+	/** Mark a node this document's page owns (the router / runtime inserted it for the page). */
+	claim_page_head(node) {
+		this.page_head.add(node);
+	}
+	/** At boot: everything already in <head> came from the server — the page owns it. */
+	adopt_document_head() {
+		if (typeof document === "undefined") return;
+		for (const n of document.head.children) this.page_head.add(n);
+	}
+	/** After an island's hydrate: the head elements it added (not in `before`, not page-owned) are
+	*  that island's; then retire the page's copies of them. */
+	record_island_head(before) {
+		let added = false;
+		for (const n of document.head.children) if (!before.has(n) && !this.page_head.has(n)) {
+			this.island_head.add(n);
+			added = true;
+		}
+		if (added) this.retire_page_head_copies();
+	}
+	/**
+	* Remove every PAGE-owned head element that duplicates a live island-owned one (same markup), and
+	* the page's `<title>` once an island renders its own (the browser honours the first title, and
+	* the island's is the reactive one). Runs after an island hydrates and after a navigation merge.
+	*/
+	retire_page_head_copies() {
+		const live = /* @__PURE__ */ new Set();
+		let island_title = false;
+		for (const el of this.island_head) {
+			if (!el.isConnected) {
+				this.island_head.delete(el);
+				continue;
+			}
+			live.add(el.outerHTML);
+			if (el.localName === "title") island_title = true;
+		}
+		if (live.size === 0) return;
+		for (const el of Array.from(document.head.children)) {
+			if (!this.page_head.has(el)) continue;
+			if (el.localName === "link" && STYLESHEET_REL_RE.test(el.getAttribute("rel") ?? "")) continue;
+			if (island_title && el.localName === "title" || live.has(el.outerHTML)) el.remove();
+		}
+	}
+	lake_cache = /* @__PURE__ */ new Map();
+	settled_lakes = /* @__PURE__ */ new WeakSet();
+	initialized_lakes = /* @__PURE__ */ new Set();
+	server_gate = new ConcurrencyGate(3);
+	/** The page facts answers rendered with (server/render-page.ts), queued at the answer seam
+	*  (`region_fragment`) for the next hydrate to merge into the page store (seeds.ts). */
+	page_facts = [];
+	#remote_seeded = false;
+	#page_seeded = false;
+	#kit_page;
+	get remote_seeded() {
+		return this.#remote_seeded;
+	}
+	mark_remote_seeded() {
+		this.#remote_seeded = true;
+	}
+	get page_seeded() {
+		return this.#page_seeded;
+	}
+	mark_page_seeded() {
+		this.#page_seeded = true;
+	}
+	get kit_page() {
+		return this.#kit_page;
+	}
+	set kit_page(v) {
+		this.#kit_page = v;
+	}
+	/** Insert/replace a lake cache entry; evict oldest if over LAKE_CACHE_MAX. */
+	set_lake_cache(id, entry) {
+		if (this.lake_cache.has(id)) this.lake_cache.delete(id);
+		this.lake_cache.set(id, entry);
+		while (this.lake_cache.size > LAKE_CACHE_MAX) {
+			const oldest = this.lake_cache.keys().next().value;
+			if (oldest == null) break;
+			this.lake_cache.delete(oldest);
+		}
+	}
+	settle_lakes_in(root) {
+		if (root instanceof Element && root.matches?.("ogygia-region[wake=\"none\"]")) this.settled_lakes.add(root);
+		for (const lake of root.querySelectorAll(FROZEN_SELECTOR)) this.settled_lakes.add(lake);
+	}
+	reset() {
+		this.#kit_page = void 0;
+		this.#remote_seeded = false;
+		this.#page_seeded = false;
+		this.lake_cache.clear();
+		this.initialized_lakes.clear();
+	}
+};
+/** Process-wide session for the islands runtime (one client module graph). */
+const runtime_session = new RuntimeSession();
+export { RuntimeSession, runtime_session };

package/dist/runtime/sidecar.d.ts

@@ -0,0 +1,3 @@
+/** Attach a remembered props sidecar to a region whose DOM carries none (see above). */
+export declare function restore_props_sidecar(region: Element, sidecar: HTMLScriptElement): void;
+export declare function props_sidecar_of(region: Element): HTMLScriptElement | null;

package/dist/runtime/sidecar.js

@@ -0,0 +1,56 @@
+// src/runtime/sidecar.ts
+/**
+* Where a region's props sidecar (`<script type="application/ogygia-props" data-ogygia-props>`) is.
+*
+* Two placements, ONE lookup:
+*  - KEYED, at the end of `<body>`: an island rendered in Kit's own page pass records its sidecar
+*    into the request (Region.svelte → the handle), which emits every island's props once, after
+*    the content, keyed by the region's fingerprint (`data-og-fp` on the element ==
+*    `data-ogygia-props="<fp>"` AND `id="og-props-<fp>"` on the script). Bytes the browser must
+*    download before the hero used to sit right after each island — a landing page carried 480 KB
+*    of props above its LCP image. Identical islands (same entry + props → same fp) share one script.
+*    Found by `getElementById` — the browser's id map, O(1); an attribute `querySelector` per island
+*    was a full light-DOM walk each (150 islands × 2,000 elements on a measured page).
+*  - ADJACENT, the next element sibling (skipping `<link>` CSS hints): every other render root —
+*    a hole response, a baked held region, a streamed late region, a router document, a foreign
+*    fragment, a snippet crossing into an island — keeps the sidecar right after the region, so the
+*    HTML stays self-contained wherever it is spliced. Keyed by attribute only, NEVER by id: its
+*    fingerprint may repeat one the tail (or another root) carries, and an id must be unique.
+* The tail's id lookup runs first, then the sibling walk; a whole-tree attribute query only on a
+* miss. Server islands and held deferred regions carry no `data-og-fp` and always ride adjacent.
+*
+* A third source, checked first: a sidecar RESTORED onto a region that has none in the DOM — a
+* hydrating hole Kit rendered again in the browser after it gave up hydrating the document (the
+* client leg renders no sidecar; the runtime remembered the SSR one under the hole's identity and
+* attaches the clone here, off the DOM, so Kit's tree is never edited under it).
+*/
+const restored_sidecars = /* @__PURE__ */ new WeakMap();
+/** Attach a remembered props sidecar to a region whose DOM carries none (see above). */
+function restore_props_sidecar(region, sidecar) {
+	restored_sidecars.set(region, sidecar);
+}
+function props_sidecar_of(region) {
+	const restored = restored_sidecars.get(region);
+	if (restored) return restored;
+	const fp = region.getAttribute("data-og-fp");
+	const root = region.getRootNode();
+	if (fp && "getElementById" in root) {
+		const keyed = root.getElementById("og-props-" + fp);
+		if (keyed) return keyed;
+	}
+	let sib = region.nextElementSibling;
+	while (sib) {
+		if (sib.tagName === "SCRIPT" && sib.hasAttribute("data-ogygia-props")) return sib;
+		if (sib.tagName === "LINK") {
+			sib = sib.nextElementSibling;
+			continue;
+		}
+		break;
+	}
+	if (fp) {
+		const found = root.querySelector?.(`script[data-ogygia-props="${fp}"]`);
+		if (found) return found;
+	}
+	return null;
+}
+export { props_sidecar_of, restore_props_sidecar };

package/dist/runtime/slots.d.ts

@@ -0,0 +1,183 @@
+import { KitBoot, kit_hydrates_page } from "./kit-boot.js";
+import { register_island_graph } from "./island-graph-preload.js";
+import { is_warmed_module, warm_island_module } from "./region-endpoint-url.js";
+import { note_entry_location } from "./entry-locations.js";
+import { props_sidecar_of } from "./sidecar.js";
+import { parse_region_html } from "./parse-html.js";
+import { runtime_session } from "./session.js";
+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 { document_key, jump_to_hash, push_state, replace_state } from "./router.js";
+import { resolve_address } from "./interaction.js";
+import { sync_attributes } from "./morph.js";
+import { Frame } from "../frame.js";
+import { Component } from "svelte";
+/** Frozen SSR DOM detached before hydrate. */
+export type LiftedLake = {
+  id: string;
+  frag: DocumentFragment;
+  endpoint: string;
+  when: string;
+  maxAgeMs: number;
+};
+/** Region schedule hooks lakes need without importing the custom element. */
+export type LakeArm = {
+  idle: (fire: () => void) => void;
+  visible: (fire: () => void, margin?: string) => void;
+  media: (when: string, fire: () => void) => void;
+  fetch_revalidate: () => void;
+  wake_children: () => void;
+};
+export type LakeOps = {
+  on_frozen_connect(el: HTMLElement, arm: LakeArm): boolean;
+  wait_for_boundary(el: HTMLElement, boundary: Element | null): boolean;
+  lift(parent: Element): LiftedLake[];
+  restore(parent: Element, lifted: LiftedLake[]): void;
+  settle_in(root: ParentNode): void;
+  mark_frozen_settled(region: HTMLElement): void;
+  after_html_swap(region: HTMLElement, opts: {
+    revalidate?: boolean;
+  }): void;
+  after_fetch_exhausted(region: HTMLElement, opts: {
+    revalidate?: boolean;
+  }, wake_children: () => void): void;
+};
+export type FormOps = {
+  enabled: boolean;
+  snapshot(root: ParentNode, pathKey: string): void;
+  restore(pathKey: string): void;
+};
+/** 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). */
+export type MorphFn = (parent: Element, nodes: ArrayLike<Node>, options?: {
+  target?: "live" | "walk";
+}) => void;
+export type WireOps = {
+  /** THE hub key (`OgygiaRef`) — every transportable kind crosses under it. */
+  REF_WIRE_KEY: string;
+  /** Hub resolve: ref → live value (kind-dispatched; browser remembers, server never). */
+  resolve: (ref: never, remember: boolean) => unknown;
+};
+export type RemoteSeedOps = {
+  seed_query_responses(text: string): void;
+  clear_remote_seeds(): void;
+  clear_remote_instances(): void;
+};
+/**
+ * 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
+ * bundles the store. Null until the feature installs → core's frame calls are optional-chained.
+ */
+export type FrameOps = {
+  subscribe(a: string, cb: (f: Frame) => void): () => void;
+  ensure(a: string, fetcher: (signal: AbortSignal) => Promise<string>, opts?: {
+    force?: boolean;
+  }): Promise<string>;
+  abandon(a: string): void;
+  /**
+   * SINGLE-FLIGHT NAVIGATION: batch a page's signed deferred endpoints into the store as one streamed response. Lives
+   * on the seam (not a static router import) so an app with `router` but no deferred/live/lake region
+   * — hence no `frames` feature — never bundles the frame store. The router optional-chains this: no
+   * frames feature ⇒ no `render="defer"` holes to batch ⇒ the call never fires anyway.
+   */
+  stream(endpoints: string[]): Promise<void>;
+  /** Holes that start fetching in the same task go out as one batch (frame-nav.ts `join_batch`);
+   *  await it, then `ensure` joins the batch's reservation. */
+  join?(endpoint: string): Promise<void>;
+  /** How the batch that carried a hole timed it (frame-nav.ts; the measuring browser only). */
+  batch_times?(endpoint: string): {
+    left: number;
+    at: number;
+    size: number;
+  } | undefined;
+};
+/**
+ * SPA navigation, filled by the router feature. Read by the kit-remote client stub (used by the
+ * always-on remote-seeds feature) so a remote COMMAND can navigate/invalidate WITHOUT the stub
+ * statically importing `router.js` (~10 KB). Null when no router loaded → callers full-page fallback.
+ */
+export type NavOps = {
+  goto(url: string | URL, opts?: unknown): Promise<void>;
+  invalidateAll(): Promise<void>;
+};
+/**
+ * BOOT → LAZY LINKS. The runtime's lazy chunks — the hydrate core, the router's navigation,
+ * interaction replay — use a handful of boot helpers and the boot's session state. They reach them
+ * HERE, never by importing a boot module: a module the boot and a lazy chunk both import is shared,
+ * and Kit's client build (`preserveEntrySignatures: 'strict'`) forbids the runtime chunk from
+ * exporting it, so the bundler splits every such module into a file of its own — the runtime's
+ * boot arrived as nine. Each link is filled before its lazy chunk can load: `boot` by core's boot
+ * (./boot-link.ts), `router_link` and `interaction_link` by the very loader that imports their chunk
+ * (the router's `nav()`, interaction's `replay()`), `sync_attributes` by morph's install. Types only
+ * below (erased), so this registry imports none of them.
+ * `test/runtime-boot-svelte-free.test.ts` pins that no lazy chunk imports a boot module.
+ */
+export type BootLink = {
+  kit_hydrates_page: typeof kit_hydrates_page;
+  KitBoot: typeof KitBoot;
+  ABSOLUTE_URL_SCHEME: RegExp;
+  register_island_graph: typeof register_island_graph;
+  is_warmed_module: typeof is_warmed_module;
+  warm_island_module: typeof warm_island_module;
+  note_entry_location: typeof note_entry_location;
+  props_sidecar_of: typeof props_sidecar_of;
+  parse_region_html: typeof parse_region_html;
+  runtime_session: typeof runtime_session;
+  regions_in_shadow: typeof regions_in_shadow;
+  yield_task: typeof yield_task;
+  /** the router's navigation, timed for the profiler's beacon (a no-op without it) */
+  beacon_nav: typeof beacon_nav;
+  /** the load scheduler's queue (./load-scheduler.ts) */
+  load_slot: typeof load_slot;
+  /** 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;
+};
+export type RouterLink = {
+  document_key: typeof document_key;
+  jump_to_hash: typeof jump_to_hash;
+  push_state: typeof push_state;
+  replace_state: typeof replace_state;
+};
+export type InteractionLink = {
+  resolve_address: typeof resolve_address;
+};
+export type Slots = {
+  lakes: LakeOps;
+  forms: FormOps;
+  interaction: ArmFn | null;
+  morph: MorphFn | null;
+  live: Component<Record<string, unknown>> | null;
+  /** a kept island's host (the live feature fills it beside `live`) */
+  keep: Component<Record<string, unknown>> | null;
+  wire: WireOps | null;
+  remoteSeeds: RemoteSeedOps | null;
+  frames: FrameOps | null;
+  nav: NavOps | null;
+  /**
+   * Cross-island context bridge, filled by the `context` feature. Walks the DOM from an island up
+   * to seed its `getContext` from a `<Provide>` / drop-in-`setContext` marker above it. Null when the
+   * build detected no ogygia context provider — a plain app never bundles the ~4.7 kB bridge, and
+   * core's call optional-chains to `undefined` (exactly "no provider above", the existing empty case).
+   */
+  context: ((start: Element | null) => Map<string, unknown> | undefined) | null;
+  /** Boot helpers + session for the lazy chunks (see {@link BootLink}). */
+  boot: BootLink | null;
+  /** The router's history/scroll helpers for its navigation chunk (see {@link RouterLink}). */
+  router_link: RouterLink | null;
+  /** Interaction's address resolver for its replay chunk (see {@link InteractionLink}). */
+  interaction_link: InteractionLink | null;
+  /** Morph's attribute sync, for the navigation's body reconcile. */
+  sync_attributes: typeof sync_attributes | null;
+};
+/** The live registry. A feature's `install()` assigns its slot; core/router read them. */
+export declare const slots: Slots;
+export declare const boot_link: () => BootLink;
+export declare const router_link: () => RouterLink;
+export declare const interaction_link: () => InteractionLink;
+export declare const morph_sync_attributes: () => NonNullable<Slots["sync_attributes"]>;

package/dist/runtime/slots.js

@@ -0,0 +1,44 @@
+import { is_frozen } from "./region-attrs.js";
+// src/runtime/slots.ts
+/** The live registry. A feature's `install()` assigns its slot; core/router read them. */
+const slots = {
+	lakes: {
+		on_frozen_connect: (el) => is_frozen(el),
+		wait_for_boundary: () => false,
+		lift: () => [],
+		restore: () => {},
+		settle_in: () => {},
+		mark_frozen_settled: () => {},
+		after_html_swap: () => {},
+		after_fetch_exhausted: () => {}
+	},
+	forms: {
+		enabled: false,
+		snapshot: () => {},
+		restore: () => {}
+	},
+	interaction: null,
+	morph: null,
+	live: null,
+	keep: null,
+	wire: null,
+	remoteSeeds: null,
+	frames: null,
+	nav: null,
+	context: null,
+	boot: null,
+	router_link: null,
+	interaction_link: null,
+	sync_attributes: null
+};
+/** A link a lazy chunk needs, or a loud error: every link is filled before its chunk can load, so a
+*  missing one means a chunk ran without the boot that owns it (a test that skipped `link_boot()`). */
+function linked(link, name) {
+	if (link === null) throw new Error(`[ogygia] runtime chunk used \`slots.${name}\` before the boot linked it`);
+	return link;
+}
+const boot_link = () => linked(slots.boot, "boot");
+const router_link = () => linked(slots.router_link, "router_link");
+const interaction_link = () => linked(slots.interaction_link, "interaction_link");
+const morph_sync_attributes = () => linked(slots.sync_attributes, "sync_attributes");
+export { boot_link, interaction_link, morph_sync_attributes, router_link, slots };

package/dist/runtime/spa-cacheable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether a fetch response may warm the SPA page-HTML cache.
+ * @param cacheControl - Response `Cache-Control` header value.
+ * @param setCookie - True if the response included `Set-Cookie`.
+ * @returns False when the response is private / no-store / no-cache or set a cookie.
+ */
+export declare function spa_html_cacheable(cacheControl: string, setCookie: boolean): boolean;

package/dist/runtime/spa-cacheable.js

@@ -0,0 +1,18 @@
+// src/runtime/spa-cacheable.ts
+/**
+* Whether an SPA navigation's HTML response may warm the page cache. A dependency-free leaf: the
+* lazy navigation chunk (./router-nav.ts) applies it, and `ogygia/app` exports it — island code —
+* so it must not live in the router's boot module (island code never imports a boot module).
+*/
+/** Responses that must never warm the SPA HTML cache (personalized / must revalidate). */
+const CC_UNCACHEABLE = /(?:^|,)\s*(?:private|no-store|no-cache)\b/i;
+/**
+* Whether a fetch response may warm the SPA page-HTML cache.
+* @param cacheControl - Response `Cache-Control` header value.
+* @param setCookie - True if the response included `Set-Cookie`.
+* @returns False when the response is private / no-store / no-cache or set a cookie.
+*/
+function spa_html_cacheable(cacheControl, setCookie) {
+	return !CC_UNCACHEABLE.test(cacheControl || "") && !setCookie;
+}
+export { spa_html_cacheable };

package/dist/runtime/speculate-hint.d.ts

@@ -0,0 +1 @@
+export declare function speculate_url(url: string | URL, kind: "prefetch" | "prerender"): void;

package/dist/runtime/speculate-hint.js

@@ -0,0 +1,35 @@
+// src/runtime/speculate-hint.ts
+/**
+* Per-URL Speculation Rules hints — the MPA-mode (`router: false`) legs of `preloadData` /
+* `preloadCode`. With no SPA router there is no swap-readable page cache to warm, and the browser
+* owns navigation — so the honest preload primitives are the platform's: `preloadData(url)`
+* speculates a PRERENDER (Chromium activates it on the real navigation — instant), `preloadCode(url)`
+* a PREFETCH (Firefox supports this leg; a prerender-capable browser treats prefetch as its first
+* stage). Where Speculation Rules are unsupported (Safari) this is a silent no-op — a hint API has
+* no failure mode, and the un-hinted navigation still works.
+*
+* LEAF module: no feature imports (usable from the `$app/navigation` shim without dragging the
+* router graph). List rules (not document rules) so each hint targets exactly the asked URL.
+*/
+const hinted = /* @__PURE__ */ new Set();
+function speculate_url(url, kind) {
+	if (typeof document === "undefined") return;
+	if (!HTMLScriptElement.supports || !HTMLScriptElement.supports("speculationrules")) return;
+	let target;
+	try {
+		target = new URL(url, location.href);
+	} catch {
+		return;
+	}
+	if (target.origin !== location.origin) return;
+	const href = target.pathname + target.search;
+	const key = kind + "\0" + href;
+	if (hinted.has(key)) return;
+	hinted.add(key);
+	const script = document.createElement("script");
+	script.type = "speculationrules";
+	script.setAttribute("data-ogygia-speculate-hint", "");
+	script.textContent = JSON.stringify({ [kind]: [{ urls: [href] }] });
+	document.head.appendChild(script);
+}
+export { speculate_url };

package/dist/runtime/svelte-warnings.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SVELTE'S HYDRATION WARNINGS, KEPT — in dev, Svelte says in the console when the server and the
+ * browser disagreed while an island hydrated (`hydration_html_changed`, `hydration_attribute_changed`,
+ * `hydration_mismatch`…). Svelte keeps the server's value, so nothing on screen shows it: the console
+ * line is the only trace. This keeps each one (with the island hydrating at the time) for the devtools
+ * and the profiler's browser half. Dev only (production Svelte has no such warnings); the console line
+ * itself goes out unchanged. No regex: warnings are rare, read by string search.
+ */
+export interface SvelteWarning {
+  code: string;
+  message: string;
+  file?: string;
+  fp?: string;
+  t: number;
+}
+/** core.ts marks the island whose hydrate step is running. Svelte raises some warnings as the
+ *  step's effects flush (a microtask after it returns): the mark holds until the task ends, and
+ *  islands hydrate one per task, so the next one never inherits it. */
+export declare function set_hydrating(el: Element): void;
+export declare function svelte_warnings(): SvelteWarning[];
+export declare function on_svelte_warning(cb: (w: SvelteWarning) => void): void;
+/** `%c[svelte] code\n%cmessage …` → the parts (null: not a Svelte hydration warning). */
+export declare function parse_svelte_warning(text: string): {
+  code: string;
+  message: string;
+  file?: string;
+} | null;
+export declare function tap_svelte_warnings(): void;

package/dist/runtime/svelte-warnings.js

@@ -0,0 +1,71 @@
+// src/runtime/svelte-warnings.ts
+let tapped = false;
+let hydrating = null;
+const kept = [];
+const listeners = [];
+/** core.ts marks the island whose hydrate step is running. Svelte raises some warnings as the
+*  step's effects flush (a microtask after it returns): the mark holds until the task ends, and
+*  islands hydrate one per task, so the next one never inherits it. */
+function set_hydrating(el) {
+	hydrating = el;
+	setTimeout(() => {
+		if (hydrating === el) hydrating = null;
+	}, 0);
+}
+function svelte_warnings() {
+	return kept.slice();
+}
+function on_svelte_warning(cb) {
+	listeners.push(cb);
+}
+/** `%c[svelte] code\n%cmessage …` → the parts (null: not a Svelte hydration warning). */
+function parse_svelte_warning(text) {
+	const at = text.indexOf("[svelte] ");
+	if (at === -1) return null;
+	let rest = text.slice(at + 9);
+	let end = 0;
+	while (end < rest.length && rest.charCodeAt(end) > 32) end++;
+	const code = rest.slice(0, end);
+	if (!code.startsWith("hydration")) return null;
+	rest = rest.slice(end).trim();
+	if (rest.startsWith("%c")) rest = rest.slice(2);
+	const line_end = rest.indexOf("\nhttps://");
+	const message = (line_end === -1 ? rest : rest.slice(0, line_end)).trim().slice(0, 400);
+	let file;
+	const dot = message.indexOf(".svelte");
+	if (dot !== -1) {
+		let start = dot;
+		while (start > 0 && message.charCodeAt(start - 1) > 32 && message[start - 1] !== "`") start--;
+		file = message.slice(start, dot + 7).split("​").join("");
+	}
+	return {
+		code,
+		message,
+		...file ? { file } : {}
+	};
+}
+function tap_svelte_warnings() {
+	if (tapped || typeof console === "undefined") return;
+	tapped = true;
+	const warn = console.warn;
+	console.warn = function(...args) {
+		try {
+			const first = args[0];
+			if (typeof first === "string" && first.includes("[svelte] hydration")) {
+				const p = parse_svelte_warning(args.filter((a) => typeof a === "string").join("\n"));
+				if (p && kept.length < 100) {
+					const fp = hydrating?.getAttribute("data-og-fp") ?? void 0;
+					const w = {
+						...p,
+						...fp ? { fp } : {},
+						t: Math.round(performance.now() * 10) / 10
+					};
+					kept.push(w);
+					for (const cb of listeners) cb(w);
+				}
+			}
+		} catch {}
+		return warn.apply(this, args);
+	};
+}
+export { on_svelte_warning, parse_svelte_warning, set_hydrating, svelte_warnings, tap_svelte_warnings };

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

@@ -0,0 +1,3 @@
+/** 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

@@ -0,0 +1,69 @@
+import { props_sidecar_of } from "./sidecar.js";
+import { yield_task } from "./schedule.js";
+import { wire_all, wire_loaders } from "virtual:ogygia/transportables";
+// src/runtime/wire-classes.ts
+/**
+* THE TRANSPORTABLE CLASSES AN ISLAND NEEDS, loaded before it decodes its props. An `[ogygia.wire]`
+* class revives through its registered codec, and its module registers it when it loads. Every island
+* page used to load every transportable class of the app up front (each island entry imported them
+* all); now the client build carries only a map of lazy loaders (`virtual:ogygia/transportables`), and
+* an island loads just what it carries:
+* - its props: the server stamped the classes on the props sidecar (`data-og-wire`, tag paths);
+* - the context it reads: the `<ogygia-provide>` payloads around it and the page's context root;
+* - the page's seeds (`page.data`, the remote-query seed), checked once per document.
+* 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.
+*/
+const loaders = wire_loaders;
+const paths = Object.keys(loaders);
+const loading = /* @__PURE__ */ new Map();
+function load(path) {
+	let p = loading.get(path);
+	if (!p) {
+		const loader = loaders[path];
+		p = loader ? yield_task().then(loader).catch(() => void 0) : Promise.resolve();
+		loading.set(path, p);
+	}
+	return p;
+}
+/** The classes a text names (`"<tag path>#…` appears in it), into `want`. */
+function scan(text, want) {
+	if (!text) return;
+	for (const p of paths) if (!want.has(p) && text.indexOf("\"" + p + "#") !== -1) want.add(p);
+}
+/** The document's seeds, checked once per document (a router swap brings new ones). */
+let seed_classes = null;
+function classes_in_seeds(doc) {
+	if (seed_classes?.doc === doc) return seed_classes.want;
+	const want = /* @__PURE__ */ new Set();
+	for (const s of doc.querySelectorAll("script[type=\"application/ogygia-page\"], script[type=\"application/ogygia-remote\"]")) scan(s.textContent, want);
+	seed_classes = {
+		doc,
+		want
+	};
+	return want;
+}
+if (typeof document !== "undefined") document.addEventListener("og:after-swap", () => seed_classes = null);
+/** 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). */
+function wire_classes_for(region) {
+	if (!paths.length) return null;
+	const want = /* @__PURE__ */ new Set();
+	if (wire_all) for (const p of paths) want.add(p);
+	else {
+		const stamp = props_sidecar_of(region)?.getAttribute("data-og-wire");
+		if (stamp) {
+			for (const p of stamp.split(" ")) if (p) want.add(p);
+		}
+		for (let el = region.parentElement; el; el = el.parentElement) if (el.tagName === "OGYGIA-PROVIDE") scan(el.querySelector(":scope > script[data-ogygia-provide]")?.textContent, want);
+		const doc = region.ownerDocument;
+		scan(doc.querySelector("script[data-ogygia-provide-page]")?.textContent, want);
+		for (const p of classes_in_seeds(doc)) want.add(p);
+	}
+	if (!want.size) return null;
+	const pending = [];
+	for (const p of want) pending.push(load(p));
+	return Promise.all(pending);
+}
+export { wire_classes_for };