@ogygia/core 0.12.3 → 0.13.0

package/dist/runtime/interaction.js

@@ -1,6 +1,10 @@
+import { import_again } from "./import-again.js";
 import { slots } from "./slots.js";
 import { warm_island_module } from "./region-endpoint-url.js";
 import { island_entry_of } from "./entry-locations.js";
+import { OgygiaError } from "../messages/core.js";
+import { download } from "../policies.js";
+import { STALE, flights } from "@ogygia/machine";
 // src/runtime/interaction.ts
 /**
 * WHAT A VISITOR DOES BEFORE AN ISLAND IS LIVE IS NOT LOST. `wake: 'interaction'` — the island sleeps
@@ -47,12 +51,12 @@ import { island_entry_of } from "./entry-locations.js";
 */
 /** Feature entry: fill the `interaction` slot — wake a cold island on first use, warm on hover. */
 function install() {
-	slots.interaction = (el, fire) => {
+	slots.interaction = (el, fire, owner) => {
 		const warm = () => {
 			const entry = island_entry_of(el);
 			if (entry) warm_island_module(entry, void 0, "user");
 		};
-		return arm_interaction(el, warm, () => Promise.resolve(fire()));
+		return arm_interaction(el, warm, fire, owner);
 	};
 }
 const WAKE_EVENTS = [
@@ -99,12 +103,26 @@ function snapshot_fields(region) {
 	}
 	return out;
 }
+/**
+* Ends an arming: its entry goes, if it is still the region's (a newer arming's stays). `over`: the
+* region left the page while it was woken — the visit that queued its clicks is over, and they go
+* with it (the region that comes back is server markup of a new visit, with a capture of its own).
+*/
+function disarm(a, over) {
+	if (armed.get(a.region) === a) armed.delete(a.region);
+	if (over && a.state === "woken") a.state = "over";
+}
 const armed = /* @__PURE__ */ new Map();
 let installed = false;
-let replay_promise = null;
+const load_replay = flights({
+	name: "interaction replay",
+	run: import_again(() => import("./interaction-replay.js")),
+	retry: download
+});
+/** (Never STALE: nothing drops the replay half.) */
 function replay() {
 	slots.interaction_link ??= { resolve_address };
-	return replay_promise ??= import("./interaction-replay.js");
+	return load_replay.get();
 }
 /** The nearest ARMED region above an event's target (past nested regions that are not armed), never
 *  past a live one: a click inside an awake island is that island's, whatever sleeps around it. */
@@ -136,7 +154,7 @@ function on_warm_event(e) {
 	if (!a || a.warmed) return;
 	a.warmed = true;
 	a.warm();
-	replay();
+	replay().catch(() => {});
 }
 function install_listeners() {
 	if (installed) return;
@@ -176,20 +194,22 @@ function wake(a, e) {
 			});
 		}
 	}
-	if (a.woken) return;
-	a.woken = true;
+	if (a.state !== "armed") return;
+	a.state = "woken";
 	region.setAttribute("data-og-woke", "interaction");
 	const fields = snapshot_fields(region);
 	const active = document.activeElement;
 	const active_addr = active instanceof Element && region.contains(active) ? element_address(region, active) : null;
-	const disarm = () => armed.delete(region);
-	Promise.all([replay(), Promise.resolve(a.fire())]).then(([r]) => {
-		disarm();
-		r.after_wake(region, fields, active_addr, queued);
+	const replayed = replay();
+	Promise.all([replayed, Promise.resolve(a.fire(replayed))]).then(([r]) => {
+		if (a.state === "over") return;
+		disarm(a, false);
+		if (r !== STALE) r.after_wake(region, fields, active_addr, queued, a.owner);
 	}, (err) => {
-		disarm();
-		replay().then((r) => r.replay_clicks(region, queued));
-		console.error("[ogygia] interaction island failed to hydrate — leaving it static.", err);
+		if (a.state === "over") return;
+		disarm(a, false);
+		replay().then((r) => r !== STALE && r.replay_clicks(region, queued, a.owner), (again) => console.error(new OgygiaError("interaction_hydrate_failed"), again));
+		console.error(new OgygiaError("interaction_hydrate_failed"), err);
 	});
 }
 /**
@@ -197,21 +217,24 @@ function wake(a, e) {
 *
 * @param region the `<ogygia-region>` element
 * @param warm   prefetch the island module (no hydrate) — wired to the pointer entering the region
-* @param fire   begin hydration; resolves when the island is live
-* @returns disarm() — forget the region (disconnected before any interaction)
+* @param fire   begin hydration ({@link WakeFn}); resolves when the island is live
+* @param owner  the region's lifetime in the page: the frame its clicks replay in is its
+* @returns disarm(over?) — end this arming (the island is live or failed, or the region left
+*          before any interaction); `over`: the region left while it was woken, so its queued clicks
+*          are dropped instead of replayed
 */
-function arm_interaction(region, warm, fire) {
-	armed.set(region, {
+function arm_interaction(region, warm, fire, owner) {
+	const a = {
 		region,
 		warm,
 		fire,
-		woken: false,
+		owner,
+		state: "armed",
 		warmed: false,
 		queued: []
-	});
-	install_listeners();
-	return () => {
-		armed.delete(region);
 	};
+	armed.set(region, a);
+	install_listeners();
+	return (over = false) => disarm(a, over);
 }
 export { arm_interaction, element_address, install, resolve_address };

package/dist/runtime/kit-page-thread.svelte.d.ts

@@ -1 +1,2 @@
-export declare function kit_page_thread(): Promise<void> | null;
+/** `signal`: the waiter's (an island's wake). Once every waiter has left, the wait ends. */
+export declare function kit_page_thread(signal?: AbortSignal): Promise<unknown> | null;

package/dist/runtime/kit-page-thread.svelte.js

@@ -1,3 +1,5 @@
+import { warn } from "../messages/lazy.js";
+import { flights, scope } from "@ogygia/machine";
 // src/runtime/kit-page-thread.svelte.ts
 /**
 * KIT-WORLD PAGE THREAD (wait side). On a Kit-hydrated (csr=true) document the handle ships no
@@ -39,7 +41,6 @@
 const KIT_PAGE_KEY = Symbol.for("ogygia.kit-page");
 /** Kit constructs its `$app/state` page with this status; `initialize()` replaces it with the real one. */
 const KIT_PRE_START_STATUS = -1;
-let pending = null;
 function bridge_of() {
 	return globalThis[KIT_PAGE_KEY];
 }
@@ -59,24 +60,37 @@ function page_applied(bridge) {
 * Dead code in a production build.
 */
 const DEV_STILL_WAITING_MS = 5e3;
-function kit_page_thread() {
+/** `signal`: the waiter's (an island's wake). Once every waiter has left, the wait ends. */
+function kit_page_thread(signal) {
 	if (page_applied(bridge_of())) return null;
-	return pending ??= new Promise((resolve) => {
-		let slow = null;
-		if (import.meta.env.DEV) slow = setTimeout(() => {
-			const bridge = bridge_of();
-			console.warn(`[ogygia] islands inside a lake / hole answer on this Kit (csr=true) page have waited ${DEV_STILL_WAITING_MS / 1e3}s for Kit to apply its page and are still holding their server HTML. ` + (bridge == null ? `Kit's client entry has not evaluated (no page bridge yet) — Kit's boot script may be blocked, failing, or missing.` : `Kit's client entry evaluated but start() has not applied the page (status is still -1) — Kit's start() may have thrown; check the console above.`) + ` They hydrate the moment Kit does; nothing is discarded meanwhile.`);
-		}, DEV_STILL_WAITING_MS);
-		const done = () => {
-			if (slow !== null) clearTimeout(slow);
-			pending = null;
-			resolve();
-		};
-		await_bridge((bridge) => await_applied(bridge, done));
-	});
+	return pending.get(void 0, { signal });
 }
+/** The wait, shared by every island asking while Kit has not applied its page; kept for nothing
+*  (keep 0): once it lands, the fast path above answers. What it holds (the dev warning's timer, a
+*  sealed global's watch, the effect on Kit's page) is its own scope's: the flight's signal aborts
+*  once the last island waiting left, and that lets go of all of it. */
+const pending = flights({
+	name: "kit page thread",
+	run: (_, signal) => {
+		const wait = scope();
+		wait.on(signal, "abort", () => wait.close());
+		return new Promise((resolve) => {
+			if (import.meta.env.DEV) wait.timeout(() => {
+				warn("kit_page_waiting", {
+					seconds: DEV_STILL_WAITING_MS / 1e3,
+					booted: bridge_of() != null
+				});
+			}, DEV_STILL_WAITING_MS);
+			await_bridge(wait, (bridge) => await_applied(wait, bridge, () => {
+				wait.close();
+				resolve();
+			}));
+		});
+	},
+	keep: 0
+});
 /** Moment 1: the symbol is assigned. Calls back synchronously if it already is. */
-function await_bridge(cb) {
+function await_bridge(wait, cb) {
 	const g = globalThis;
 	if (g[KIT_PAGE_KEY] != null) return cb(g[KIT_PAGE_KEY]);
 	let value;
@@ -98,19 +112,29 @@ function await_bridge(cb) {
 			set: settle
 		});
 	} catch {
-		const tick = () => g[KIT_PAGE_KEY] != null ? settle(g[KIT_PAGE_KEY]) : setTimeout(tick, 50);
-		tick();
+		const stop = wait.every(() => {
+			if (g[KIT_PAGE_KEY] == null) return;
+			stop();
+			cb(g[KIT_PAGE_KEY]);
+		}, 50);
 	}
 }
 /** Moment 2: Kit assigns the real status onto its live page — observed by an effect, resolved once. */
-function await_applied(bridge, done) {
+function await_applied(wait, bridge, done) {
 	if (page_applied(bridge)) return done();
+	let ended = false;
+	const end = () => {
+		if (ended) return;
+		ended = true;
+		queueMicrotask(() => stop());
+	};
 	const stop = $effect.root(() => {
 		$effect(() => {
 			if (!page_applied(bridge)) return;
-			queueMicrotask(stop);
+			end();
 			done();
 		});
 	});
+	wait.defer(end);
 }
 export { kit_page_thread };

package/dist/runtime/lakes.d.ts

@@ -9,7 +9,7 @@ export declare function wait_for_boundary(_el: HTMLElement, boundary: Element |
 export declare function mark_frozen_settled(region: HTMLElement): void;
 export declare function after_html_swap(region: HTMLElement, opts: {
   revalidate?: boolean;
-}): void;
+}, wake_children: () => void): void;
 export declare function after_fetch_exhausted(region: HTMLElement, opts: {
   revalidate?: boolean;
 }, wake_children: () => void): void;

package/dist/runtime/lakes.js

@@ -2,6 +2,7 @@ import { relocate_trailing_empty_comments } from "./lake-anchors.js";
 import { FROZEN_SELECTOR, document_is_stored, is_awake, is_frozen, region_is_vacant, region_max_age_ms, region_on_expire, region_remount } from "./region-attrs.js";
 import { runtime_session } from "./session.js";
 import { slots } from "./slots.js";
+import { warn } from "../messages/core.js";
 // src/runtime/lakes.ts
 /** Feature entry: fill the `lakes` slot so core lifts/restores frozen regions. */
 function install() {
@@ -107,7 +108,7 @@ function on_frozen_connect(el, arm) {
 			else if (when === "visible") arm.visible(fire);
 			else if (when === "load") fire();
 			else arm.media(when, fire);
-		} else if (import.meta.env.DEV && region_remount(el) === "swr" && !el.parentElement?.closest("ogygia-region")) console.warn(`[ogygia] render:'live' region "${id}" has no island host — on regular pages it will never revalidate (only on documents served from a page store). Wrap it in a wake:'load' island to drive remount revalidation.`);
+		} else if (import.meta.env.DEV && region_remount(el) === "swr" && !el.parentElement?.closest("ogygia-region")) warn("live_region_no_host", { id });
 		if (unhosted(el)) {
 			runtime_session.settled_lakes.add(el);
 			if (!region_is_vacant(el)) {
@@ -167,7 +168,7 @@ function on_frozen_connect(el, arm) {
 			if (!cached.endpoint) {
 				runtime_session.settled_lakes.add(el);
 				arm.wake_children();
-				if (import.meta.env.DEV) console.warn(`[ogygia] region "${id}" is render:'live' but no signed endpoint was captured at SSR — painting the cache only.`);
+				if (import.meta.env.DEV) warn("live_region_no_endpoint", { id });
 				return true;
 			}
 			el.setAttribute("endpoint", cached.endpoint);
@@ -182,14 +183,25 @@ function on_frozen_connect(el, arm) {
 		default: return policy;
 	}
 }
+/**
+* The unsettled lakes regions authored inside them are waiting on (they connected, found the lake
+* unsettled, and stopped: `wait_for_boundary`). A lake's settling wakes them, on every path it
+* settles by: a refresh that MORPHS its children in place reconnects none of them (a vacant swr
+* remount's cached copy, refreshed), so nothing else would.
+*/
+const waited_on = /* @__PURE__ */ new WeakSet();
 function wait_for_boundary(_el, boundary) {
-	return !!(boundary && is_frozen(boundary) && !runtime_session.settled_lakes.has(boundary));
+	if (!(boundary && is_frozen(boundary) && !runtime_session.settled_lakes.has(boundary))) return false;
+	waited_on.add(boundary);
+	return true;
 }
 function mark_frozen_settled(region) {
 	if (is_frozen(region)) runtime_session.settled_lakes.add(region);
 }
-function after_html_swap(region, opts) {
-	if (!(opts.revalidate && is_frozen(region))) return;
+function after_html_swap(region, opts, wake_children) {
+	if (!is_frozen(region)) return;
+	if (waited_on.delete(region)) wake_children();
+	if (!opts.revalidate) return;
 	const id = region.getAttribute("entry") || "";
 	if (!id) return;
 	const cached = document.createDocumentFragment();
@@ -206,6 +218,7 @@ function after_html_swap(region, opts) {
 function after_fetch_exhausted(region, opts, wake_children) {
 	if (opts.revalidate && is_frozen(region) && region.isConnected) {
 		runtime_session.settled_lakes.add(region);
+		waited_on.delete(region);
 		wake_children();
 	}
 }

package/dist/runtime/live.d.ts

@@ -1,3 +1,2 @@
-/** Feature entry: fill the `live` slot with {@link LiveHost}, and `keep` with {@link KeepHost} (a
- *  kept island's host: the same pushable props, in a placed island's SSR shape). */
+/** Feature entry: fill the `Pushable` slot with {@link PushableProps}. */
 export declare function install(): void;

package/dist/runtime/live.js

@@ -1,17 +1,15 @@
 import { slots } from "./slots.js";
-import LiveHost from "../LiveHost.svelte";
-import KeepHost from "../KeepHost.svelte";
+import { PushableProps } from "./pushable-props.svelte.js";
 // src/runtime/live.ts
 /**
-* Live-region feature: the props-pushable host a live `<Region>` hydrates through, so later
-* `query.live` ticks push new props into the mounted island (keep-alive) instead of re-hydrating.
+* Live-region feature: the pushable props a live `<Region>` and a kept island hydrate with, so later
+* `query.live` ticks (and the next page's props) reach the mounted island in place instead of
+* re-hydrating it.
 *
 * A HYDRATE-phase feature (link/runtime-entry.ts): installed by the hydrate core, never the boot.
 */
-/** Feature entry: fill the `live` slot with {@link LiveHost}, and `keep` with {@link KeepHost} (a
-*  kept island's host: the same pushable props, in a placed island's SSR shape). */
+/** Feature entry: fill the `Pushable` slot with {@link PushableProps}. */
 function install() {
-	slots.live = LiveHost;
-	slots.keep = KeepHost;
+	slots.Pushable = PushableProps;
 }
 export { install };

package/dist/runtime/load-scheduler.d.ts

@@ -1,3 +1,4 @@
+import { Stale } from "@ogygia/machine";
 export type LoadClass = "user" | "visible" | "ahead" | "speculative";
 /** `code`: an island's modules. `content`: HTML (a hole's answer, a prefetched page). */
 export type LoadKind = "code" | "content";
@@ -17,13 +18,13 @@ export declare function viewport_class(el: Element): "visible" | "ahead";
 /** How the critical-resources wait ended: they `arrived` (or failed), the visitor's first `input`,
  *  the `cap`, or `none` were pending. */
 export type CriticalOutcome = "arrived" | "input" | "cap" | "none";
-declare let critical_report: {
+type CriticalReport = {
   outcome: CriticalOutcome;
   resources: number;
   waited_ms: number;
-} | null;
+};
 /** The critical wait's outcome once it settled (the profiler's beacon reads it), else `null`. */
-export declare function critical_outcome(): typeof critical_report;
+export declare function critical_outcome(): CriticalReport | null;
 /** The URLs a preload link may fetch: its `href`, else each `imagesrcset` candidate's. */
 export declare function preload_urls(link: HTMLLinkElement): string[];
 /**
@@ -31,23 +32,33 @@ export declare function preload_urls(link: HTMLLinkElement): string[];
  * arrived (or failed) — or at the visitor's first click or key, or {@link CRITICAL_CAP_MS} into the
  * wait. A page with no marked resource resolves right after the paint. Once resolved it stays so.
  */
-export declare function critical_settled(): Promise<void>;
-/** A queued download: its current class, and a way to lift it. */
-export interface LoadTicket {
-  promote(cls: LoadClass): void;
-}
+export declare function critical_settled(): Promise<void | Stale>;
 /**
- * Ask for a slot. `ready` resolves with a `release` to call when the download is done (settled,
- * success or not). `cls` may be a getter, re-read whenever the queue drains (viewport changes).
+ * A queued download: asking for one queues it. `ready` resolves with a `release` to call when the
+ * download is done (settled, success or not). `cls` may be a getter, re-read whenever the queue
+ * drains (viewport changes); `promote` lifts it.
  */
-export declare function load_slot(o: {
-  kind: LoadKind;
-  cls: LoadClass | (() => LoadClass);
-  label?: string;
-}): {
-  ready: Promise<() => void>;
-  ticket: LoadTicket;
-};
+export declare class LoadSlot {
+  #private;
+  readonly kind: LoadKind;
+  readonly label: string | undefined;
+  readonly queued_at: number;
+  readonly ready: Promise<() => void>;
+  /** Still in the queue: a drain takes it out when it starts. */
+  queued: boolean;
+  constructor(o: {
+    kind: LoadKind;
+    cls: LoadClass | (() => LoadClass);
+    label?: string;
+  });
+  /** Its class now: the getter's, or the promoted one when that ranks higher. */
+  cls(): LoadClass;
+  /** Lift it (a prefetch the visitor then navigates to). */
+  promote(c: LoadClass): void;
+  /** Out of the queue: the holder's `ready` resolves, counted in the background window when it
+   *  is one of the guesses. */
+  start(cls: LoadClass, background: boolean): void;
+}
 /** Test seam: a fresh document. */
 export declare function reset_load_scheduler(): void;
 export {};