@ogygia/core 0.12.3 → 0.13.0

package/dist/runtime/load-scheduler.js

@@ -1,6 +1,7 @@
 import { after_document_painted, yield_task } from "./schedule.js";
 import { kit_hydrates_page } from "./kit-boot.js";
 import { emit } from "../events/bus.js";
+import { flights, machine, scope } from "@ogygia/machine";
 // src/runtime/load-scheduler.ts
 /**
 * THE LOAD SCHEDULER — every download ogygia starts on its own goes through one queue.
@@ -43,6 +44,12 @@ const RANK = {
 	ahead: 2,
 	speculative: 3
 };
+const CLASSES = [
+	"user",
+	"visible",
+	"ahead",
+	"speculative"
+];
 /** The fetch priority a class downloads at (`fetch(…, { priority })`, `<link fetchpriority>`). */
 function fetch_priority_of(cls) {
 	return cls === "user" ? "high" : cls === "visible" ? "auto" : "low";
@@ -67,23 +74,74 @@ function on_screen(el, depth) {
 	}
 	return crosses && (r.width > 0 || r.height > 0);
 }
-let input_seen = false;
+/**
+* The gate, as a machine:
+*
+*   fresh ─ waiting{t0, resources} ─ settled{report}
+*       ╲ touched ───────────────────╱
+*
+* `fresh`: no wait yet. `touched`: the visitor clicked or typed before the wait began, so it waits on
+* nothing. `waiting`: the wait is up; its visit owns the cap and the resources' listeners, so they go
+* as it settles, however it settles. `settled`: open for good, with how it ended (the beacon reads
+* it). One state in place of `input_seen`, `critical_done`, `release_critical` and the report.
+*/
+const gate_definition = machine()({
+	name: "critical-gate",
+	initial: "fresh",
+	steps: {
+		fresh: [
+			"touched",
+			"waiting",
+			"settled"
+		],
+		touched: ["settled"],
+		waiting: ["settled"],
+		settled: []
+	}
+});
+let gate = gate_definition.create();
 const on_first_input = () => {
-	input_seen = true;
-	release_critical?.();
+	const kind = gate.now.kind;
+	if (kind === "fresh") gate.go("touched");
+	else if (kind === "waiting") settle_critical("input");
 };
 if (typeof document !== "undefined") for (const type of ["pointerdown", "keydown"]) addEventListener(type, on_first_input, {
 	capture: true,
 	passive: true,
 	once: true
 });
-let critical = null;
-let critical_done = false;
-let release_critical = null;
-let critical_report = null;
+/** The critical wait below, once for the document (a test's reset drops it). */
+const critical = flights({
+	name: "critical resources",
+	run: () => until_critical()
+});
+/** The gate is open: the critical wait settled. */
+const critical_done = () => gate.now.kind === "settled";
 /** The critical wait's outcome once it settled (the profiler's beacon reads it), else `null`. */
 function critical_outcome() {
-	return critical_report;
+	const s = gate.now;
+	return s.kind === "settled" ? s.report : null;
+}
+/** The wait ends (once: a gate already settled stays as it settled). */
+function settle_critical(outcome) {
+	const s = gate.now;
+	if (s.kind === "settled") return;
+	const report = s.kind === "waiting" ? {
+		outcome,
+		resources: s.resources,
+		waited_ms: Math.round(now() - s.t0)
+	} : {
+		outcome,
+		resources: 0,
+		waited_ms: 0
+	};
+	gate.go("settled", { report });
+	if (DEVTOOLS) emit({
+		domain: "runtime",
+		name: "load.critical",
+		...report
+	});
+	drain();
 }
 /** Elements carrying the page's critical resources that have not arrived yet: an eager
 *  `img[fetchpriority=high]` not complete, a `link[rel=preload][fetchpriority=high]` not fetched. */
@@ -126,78 +184,97 @@ function preload_urls(link) {
 * wait. A page with no marked resource resolves right after the paint. Once resolved it stays so.
 */
 function critical_settled() {
-	return critical ??= after_document_painted().then(() => new Promise((resolve) => {
-		const t0 = now();
-		const done = (outcome) => {
-			if (critical_done) return;
-			critical_done = true;
-			release_critical = null;
-			clearTimeout(timer);
-			critical_report = {
-				outcome,
-				resources: waiting.length,
-				waited_ms: Math.round(now() - t0)
-			};
-			if (DEVTOOLS) emit({
-				domain: "runtime",
-				name: "load.critical",
-				...critical_report
-			});
-			resolve();
-			drain();
-		};
-		const waiting = input_seen || document.visibilityState === "hidden" ? [] : pending_critical();
-		const timer = waiting.length ? setTimeout(() => done("cap"), CRITICAL_CAP_MS) : void 0;
-		if (!waiting.length) return done("none");
-		release_critical = () => done("input");
+	return critical.get();
+}
+function until_critical() {
+	return after_document_painted().then(async () => {
+		const s = gate.now;
+		if (s.kind === "settled") return;
+		const waiting = s.kind === "touched" || document.visibilityState === "hidden" ? [] : pending_critical();
+		if (!waiting.length) return settle_critical("none");
+		gate.go("waiting", {
+			t0: now(),
+			resources: waiting.length
+		});
+		const wait = gate.scope;
+		wait.timeout(() => settle_critical("cap"), CRITICAL_CAP_MS);
 		let left = waiting.length;
 		const one = () => {
-			if (--left === 0) done("arrived");
+			if (--left === 0) settle_critical("arrived");
 		};
 		for (const el of waiting) {
-			el.addEventListener("load", one, { once: true });
-			el.addEventListener("error", one, { once: true });
+			wait.on(el, "load", one, { once: true });
+			wait.on(el, "error", one, { once: true });
 		}
-	}));
+		await gate.wait("settled");
+	});
 }
+/** The slots waiting, in the order they were asked for (a pass takes out the ones it started when
+*  it ends; `waiting` counts the rest at any moment). */
 const queue = [];
+let waiting = 0;
 let in_flight_background = 0;
-let next_order = 0;
-let scroll_watch = false;
+/** The scroll watch while a queued download waits (its listener and its frame): closed once the
+*  queue is empty. */
+let scroll_watch = null;
 /**
-* 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.
 */
-function load_slot(o) {
-	let forced = null;
-	const read = typeof o.cls === "function" ? o.cls : () => o.cls;
-	const cls = () => {
-		const c = read();
+var LoadSlot = class {
+	kind;
+	label;
+	queued_at = now();
+	ready;
+	/** Still in the queue: a drain takes it out when it starts. */
+	queued = true;
+	#read;
+	#forced = null;
+	#resolve;
+	constructor(o) {
+		this.kind = o.kind;
+		this.label = o.label;
+		this.#read = typeof o.cls === "function" ? o.cls : () => o.cls;
+		this.ready = new Promise((r) => this.#resolve = r);
+		queue.push(this);
+		waiting++;
+		if (typeof o.cls === "function") watch_scroll();
+		if (!critical_done() && waits_for_critical(this.kind, this.cls())) critical_settled();
+		drain();
+	}
+	/** Its class now: the getter's, or the promoted one when that ranks higher. */
+	cls() {
+		const c = this.#read();
+		const forced = this.#forced;
 		return forced !== null && RANK[forced] < RANK[c] ? forced : c;
-	};
-	let resolve;
-	const ready = new Promise((r) => resolve = r);
-	const entry = {
-		kind: o.kind,
-		cls,
-		label: o.label,
-		queued_at: now(),
-		order: next_order++,
-		resolve,
-		background: false
-	};
-	queue.push(entry);
-	if (typeof o.cls === "function") watch_scroll();
-	if (!critical_done && waits_for_critical(entry.kind, cls())) critical_settled();
-	drain();
-	return {
-		ready,
-		ticket: { promote(c) {
-			forced = c;
+	}
+	/** Lift it (a prefetch the visitor then navigates to). */
+	promote(c) {
+		this.#forced = c;
+		drain();
+	}
+	/** Out of the queue: the holder's `ready` resolves, counted in the background window when it
+	*  is one of the guesses. */
+	start(cls, background) {
+		if (background) in_flight_background++;
+		let released = false;
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "load.started",
+			class: cls,
+			kind: this.kind,
+			label: this.label,
+			waited_ms: Math.round(now() - this.queued_at)
+		});
+		this.#resolve(() => {
+			if (released) return;
+			released = true;
+			if (background) in_flight_background--;
 			drain();
-		} }
-	};
-}
+		});
+	}
+};
 function waits_for_critical(kind, cls) {
 	if (cls === "user") return false;
 	if (kit_hydrates_page()) return false;
@@ -210,91 +287,114 @@ function waits_for_critical(kind, cls) {
 * task (52 ms on a 4×-throttled runner). After this much work in one task the drain yields.
 */
 const START_BUDGET_MS = 16;
-let draining = false;
-let drain_again = false;
+/**
+* The queue's drain, as a machine: `idle`, `draining`, or `again` (a drain was asked for while one
+* ran: the one running goes round once more, and asks again when it is done). One state in place of
+* `draining` beside `drain_again`.
+*/
+const drain_definition = machine()({
+	name: "load-drain",
+	initial: "idle",
+	steps: {
+		idle: ["draining"],
+		draining: ["idle", "again"],
+		again: ["idle", "draining"]
+	}
+});
+let drainer = drain_definition.create();
 function drain() {
-	if (draining) {
-		drain_again = true;
+	const kind = drainer.now.kind;
+	if (kind !== "idle") {
+		if (kind === "draining") drainer.go("again");
 		return;
 	}
-	if (!queue.length) return;
-	draining = true;
+	if (!waiting) return;
+	drainer.go("draining");
+	const mine = drainer;
 	drain_queue().finally(() => {
-		draining = false;
-		if (drain_again) {
-			drain_again = false;
-			drain();
-		}
+		if (drainer !== mine) return;
+		const again = drainer.now.kind === "again";
+		drainer.go("idle");
+		if (again) drain();
 	});
 }
+/**
+* One pass goes through the queue by class, then in the order asked, and then through the slots
+* asked for while it ran, in the order asked. The queue is kept in the order asked, so reading each
+* class once and putting the slot in its class's list is that order (a sort compared two classes per
+* step, every pass: passes × queue × log queue reads on a page whose downloads each end a pass).
+*
+* @heisenbench linear
+*/
 async function drain_queue() {
 	let until = now() + START_BUDGET_MS;
 	for (;;) {
-		drain_again = false;
-		queue.sort((a, b) => RANK[a.cls()] - RANK[b.cls()] || a.order - b.order);
+		if (drainer.now.kind === "again") drainer.go("draining");
+		const asked = queue.length;
+		const by_class = [
+			[],
+			[],
+			[],
+			[]
+		];
+		for (let i = 0; i < asked; i++) by_class[RANK[queue[i].cls()]].push(queue[i]);
+		let ran = false;
+		let started = false;
 		let yielded = false;
-		for (let i = 0; i < queue.length;) {
-			const e = queue[i];
-			const cls = e.cls();
-			if (!critical_done && waits_for_critical(e.kind, cls)) {
-				i++;
-				continue;
-			}
-			const background = cls === "ahead" || cls === "speculative";
-			if (background && in_flight_background >= 3) {
-				i++;
-				continue;
-			}
-			queue.splice(i, 1);
-			start(e, cls, background);
-			await Promise.resolve();
-			if (now() >= until) {
-				await yield_task();
-				until = now() + START_BUDGET_MS;
-				yielded = true;
-				break;
+		pass: for (let r = 0; r <= 4; r++) {
+			const list = r < 4 ? by_class[r] : queue;
+			for (let i = r < 4 ? 0 : asked; i < list.length; i++) {
+				const e = list[i];
+				if (!e.queued) continue;
+				const cls = r < 4 && !ran ? CLASSES[r] : e.cls();
+				if (!critical_done() && waits_for_critical(e.kind, cls)) continue;
+				const background = cls === "ahead" || cls === "speculative";
+				if (background && in_flight_background >= 3) continue;
+				e.queued = false;
+				waiting--;
+				started = true;
+				e.start(cls, background);
+				await Promise.resolve();
+				ran = true;
+				if (now() >= until) {
+					leave_queue();
+					await yield_task();
+					until = now() + START_BUDGET_MS;
+					yielded = true;
+					break pass;
+				}
 			}
 		}
-		if (!yielded && !drain_again) return;
+		if (!yielded) {
+			if (started) leave_queue();
+			if (drainer.now.kind !== "again") return;
+		}
 	}
 }
-function start(e, cls, background) {
-	if (background) in_flight_background++;
-	e.background = background;
-	let released = false;
-	if (DEVTOOLS) emit({
-		domain: "runtime",
-		name: "load.started",
-		class: cls,
-		kind: e.kind,
-		label: e.label,
-		waited_ms: Math.round(now() - e.queued_at)
-	});
-	e.resolve(() => {
-		if (released) return;
-		released = true;
-		if (background) in_flight_background--;
-		drain();
-	});
+/** The started slots out of the queue, the rest kept in the order asked. */
+function leave_queue() {
+	let w = 0;
+	for (let i = 0; i < queue.length; i++) if (queue[i].queued) queue[w++] = queue[i];
+	queue.length = w;
 }
 /** While a queued download's class can change with the viewport, re-drain on scroll (one frame). */
 function watch_scroll() {
-	if (scroll_watch || typeof addEventListener === "undefined") return;
-	scroll_watch = true;
+	if (scroll_watch || typeof window === "undefined") return;
+	const watch = scroll_watch = scope();
 	let framed = false;
 	const on_scroll = () => {
 		if (framed) return;
 		framed = true;
-		requestAnimationFrame(() => {
+		watch.timeout(() => {
 			framed = false;
 			drain();
-			if (!queue.length) {
-				removeEventListener("scroll", on_scroll, true);
-				scroll_watch = false;
+			if (!waiting) {
+				watch.close();
+				scroll_watch = null;
 			}
-		});
+		}, "frame");
 	};
-	addEventListener("scroll", on_scroll, {
+	watch.on(window, "scroll", on_scroll, {
 		capture: true,
 		passive: true
 	});
@@ -304,14 +404,14 @@ function now() {
 }
 /** Test seam: a fresh document. */
 function reset_load_scheduler() {
+	for (const s of queue) s.queued = false;
 	queue.length = 0;
+	waiting = 0;
 	in_flight_background = 0;
-	draining = false;
-	drain_again = false;
-	critical = null;
-	critical_done = false;
-	release_critical = null;
-	critical_report = null;
-	input_seen = false;
+	drainer.stop();
+	drainer = drain_definition.create();
+	critical.drop(() => true);
+	gate.stop();
+	gate = gate_definition.create();
 }
-export { BACKGROUND_WINDOW, CRITICAL_CAP_MS, critical_outcome, critical_settled, fetch_priority_of, load_slot, preload_urls, reset_load_scheduler, viewport_class };
+export { BACKGROUND_WINDOW, CRITICAL_CAP_MS, LoadSlot, critical_outcome, critical_settled, fetch_priority_of, preload_urls, reset_load_scheduler, viewport_class };

package/dist/runtime/nav-handle.js

@@ -1,4 +1,8 @@
+import { import_again } from "./import-again.js";
 import { speculate_url } from "./speculate-hint.js";
+import { OgygiaError, warn } from "../messages/core.js";
+import { download } from "../policies.js";
+import { STALE, flights } from "@ogygia/machine";
 // src/runtime/nav-handle.ts
 /**
 * THE NAVIGATION HANDLE — how ISLAND-SIDE code (the `$app/navigation` shim, `ogygia/app`, the
@@ -25,6 +29,21 @@ import { speculate_url } from "./speculate-hint.js";
 * purpose: importing {@link NAV_HANDLE_KEY} would be the very edge this module exists to avoid).
 */
 const NAV_HANDLE_KEY = Symbol.for("ogygia.nav");
+/**
+* THE SOFT REFRESH (./router-nav.ts `invalidate_all`), loaded once, on the first refresh. A
+* download that fails is tried again at once, and a failure is never kept: the next refresh loads
+* it afresh, under a fresh URL (./import-again.ts: the browser keeps the failed one). It once
+* imported the same URL again, which fails at once for the life of the page. (Only the refresh is
+* read from the module, so the bundler leaves the rest of the navigation out of this chunk; the
+* router's own load, ./router.ts, reads all of it.)
+*/
+const load_refresh = flights({
+	name: "soft refresh",
+	run: import_again(() => import("./router-nav.js").then(({ invalidate_all }) => ({ invalidate_all }))),
+	retry: download
+});
+/** The refresh, once its module is in (never STALE: nothing drops it). */
+const invalidate_all = () => load_refresh.get().then((n) => n === STALE ? void 0 : n.invalidate_all());
 /** Feature entry (`mpa-nav`, boot phase): the MPA handle, first — the router's install, later in
 *  the feature order, replaces it. */
 function install() {
@@ -43,14 +62,14 @@ function mpa_nav() {
 	return {
 		goto(url, opts = {}) {
 			const target = new URL(url, location.href);
-			if (target.protocol !== "http:" && target.protocol !== "https:") throw new Error("[ogygia] goto() only supports http(s) URLs");
-			if (target.origin !== location.origin && !opts.external) throw new Error("[ogygia] goto() only supports same-origin URLs (pass { external: true } to leave)");
+			if (target.protocol !== "http:" && target.protocol !== "https:") throw new OgygiaError("goto_not_http");
+			if (target.origin !== location.origin && !opts.external) throw new OgygiaError("goto_cross_origin");
 			if (opts.replaceState) location.replace(target.href);
 			else location.assign(target.href);
 			return Promise.resolve();
 		},
-		invalidate: () => import("./router-nav.js").then((n) => n.invalidate_all()),
-		invalidateAll: () => import("./router-nav.js").then((n) => n.invalidate_all()),
+		invalidate: invalidate_all,
+		invalidateAll: invalidate_all,
 		preloadData(url) {
 			speculate_url(url, "prerender");
 			return Promise.resolve({
@@ -65,10 +84,10 @@ function mpa_nav() {
 		},
 		disableScrollHandling() {},
 		pushState() {
-			console.warn("[ogygia] pushState() shallow routing is not supported; use goto().");
+			warn("shallow_routing_unsupported", { method: "pushState" });
 		},
 		replaceState() {
-			console.warn("[ogygia] replaceState() shallow routing is not supported; use goto().");
+			warn("shallow_routing_unsupported", { method: "replaceState" });
 		},
 		beforeNavigate: () => NO_UNSUBSCRIBE,
 		afterNavigate: () => NO_UNSUBSCRIBE,

package/dist/runtime/navigation.d.ts

@@ -0,0 +1,24 @@
+import { Machine } from "@ogygia/machine";
+type States = {
+  idle: {};
+  claimed: {
+    href: string;
+  };
+  loading: {
+    href: string;
+  };
+  settling: {
+    href: string;
+  };
+};
+declare const steps: {
+  readonly idle: readonly ["claimed"];
+  readonly claimed: readonly ["claimed", "loading", "idle"];
+  readonly loading: readonly ["claimed", "settling", "idle"];
+  readonly settling: readonly ["claimed", "idle"];
+};
+/** The navigation machine the router holds. */
+export type Navigation = Machine<States, typeof steps>;
+/** A navigation machine, idle. */
+export declare function create_navigation(): Navigation;
+export {};

package/dist/runtime/navigation.js

@@ -0,0 +1,24 @@
+import { machine } from "@ogygia/machine";
+const definition = machine()({
+	name: "navigation",
+	initial: "idle",
+	steps: {
+		idle: ["claimed"],
+		claimed: [
+			"claimed",
+			"loading",
+			"idle"
+		],
+		loading: [
+			"claimed",
+			"settling",
+			"idle"
+		],
+		settling: ["claimed", "idle"]
+	}
+});
+/** A navigation machine, idle. */
+function create_navigation() {
+	return definition.create();
+}
+export { create_navigation };

package/dist/runtime/ownership.d.ts

@@ -24,7 +24,7 @@
  *    DOM is not the island drifting).
  *
  * `data-ogygia-keep` on an `<ogygia-region>` is NOT `foreign`: there it names an island that survives
- * navigation (KeepHost) — Svelte owns that island, and it is repaired and hydrated like any other.
+ * navigation (a kept island) — Svelte owns that island, and it is repaired and hydrated like any other.
  *
  * FACETS (note §11): `owner_of` answers who writes INSIDE an element; the same module answers who
  * writes its ATTRIBUTES (`attributes_writer`, `REGION_RENDER_ATTRS`), who ORDERS its children

package/dist/runtime/page-defer.js

@@ -1,5 +1,5 @@
+import { boot_link } from "./slots.js";
 import { PAGE_DEFER_BOOTSTRAP, PAGE_DEFER_GLOBAL, PAGE_DEFER_KEY, PAGE_DEFER_REGISTRY_KEY, PAGE_SETTLED_KEY } from "../page-defer.js";
-import { parse } from "devalue";
 // src/runtime/page-defer.ts
 /**
 * Client side of streaming `$page.data` promises into islands (see `../page-defer.ts` for the why).
@@ -70,13 +70,13 @@ function install_page_defer(extra_revivers) {
 	const r = reg();
 	if (r.live) return;
 	r.revivers = page_defer_revivers(extra_revivers);
-	r.live = (id, ok, encoded) => {
+	r.live = (id, ok, encoded) => boot_link().with_devalue(({ parse }) => {
 		let value = null;
 		try {
 			value = parse(encoded, r.revivers);
 		} catch {}
 		settle(id, ok, value);
-	};
+	});
 	const queued = r.q;
 	r.q = [];
 	if (queued) for (const [id, ok, encoded] of queued) r.live(id, ok, encoded);

package/dist/runtime/parse-html.d.ts

@@ -13,10 +13,21 @@
  * swap-then-blank-then-paint flicker). "Unsafe" means only "no sanitizer"; a region body is our own
  * signed, same-origin SSR (HOLE-TRUST), so it is exactly as trusted as the page itself.
  *
- * NOTE the parse happens in a `<template>`'s inert content, so custom elements do NOT upgrade here
- * (no `connectedCallback`) — attaching a declarative shadow root is a parse step, not an upgrade. That
- * is what `repair_if_drifted` needs: the server copy stays inert, but its light-DOM sequence is now
- * DSD-consistent with a live region whose hosts already carry shadow roots.
+ * INERT BY CONSTRUCTION (#382). The parse runs in a document with no browsing context (one per
+ * runtime, made on first use): it has no custom element registry, so nothing in the answer is built
+ * by a component's constructor before the restore (./restore.ts) puts it in shape, in any engine.
+ * A page-owned `<template>` was inert by a browser detail only: Firefox 159 (scoped registries)
+ * builds custom elements while one parses with `setHTMLUnsafe`, so a host had its constructor's
+ * root before the restore reached it. Attaching a declarative shadow root is a parse step, not an
+ * upgrade: it still happens here. The fragment's nodes belong to that document until they are
+ * inserted (insertion adopts them; they upgrade at connect, constructor then `connectedCallback`,
+ * a declarative root kept). `repair_if_drifted` needs this too: the server copy stays inert, and its
+ * light-DOM sequence is DSD-consistent with a live region whose hosts already carry shadow roots.
+ *
+ * (`Document.parseHTMLUnsafe` would also parse without a registry, but makes a whole document per
+ * call; one shared document and its template is the cheaper of the two.)
+ *
+ * In dev and e2e every parse is checked (`rule_parse_upgraded`, ./rules.ts): nothing built.
  */
 export declare function parse_region_html(html: string): DocumentFragment;
 /** The spec's declarative-shadow-DOM attach step, for engines that render DSD on first parse but predate