@ogygia/core 0.0.0 → 0.11.0

package/dist/runtime/lake-anchors.js

@@ -0,0 +1,19 @@
+// src/runtime/lake-anchors.ts
+/**
+* After lifting lake content into a region, move trailing empty SSR comments
+* (`<!---->`) back into the region. Those are Boundary/host delimiters — not lake
+* content — and hydrate needs them for Boundary+Placeholder.
+*/
+const COMMENT_NODE = 8;
+/** Relocate trailing empty comments from `frag` into `lake`. Returns how many moved. */
+function relocate_trailing_empty_comments(frag, lake) {
+	const moved = [];
+	while (frag.lastChild && frag.lastChild.nodeType === COMMENT_NODE && frag.lastChild.data === "") {
+		const node = frag.lastChild;
+		frag.removeChild(node);
+		moved.unshift(node);
+	}
+	for (const n of moved) lake.appendChild(n);
+	return moved.length;
+}
+export { relocate_trailing_empty_comments };

package/dist/runtime/lakes.d.ts

@@ -0,0 +1,15 @@
+import { LakeArm, LiftedLake } from "./slots.js";
+/** Feature entry: fill the `lakes` slot so core lifts/restores frozen regions. */
+export declare function install(): void;
+export declare function settle_in(root: ParentNode): void;
+export declare function lift(parent: Element): LiftedLake[];
+export declare function restore(parent: Element, lifted: LiftedLake[]): void;
+export declare function on_frozen_connect(el: HTMLElement, arm: LakeArm): boolean;
+export declare function wait_for_boundary(_el: HTMLElement, boundary: Element | null): boolean;
+export declare function mark_frozen_settled(region: HTMLElement): void;
+export declare function after_html_swap(region: HTMLElement, opts: {
+  revalidate?: boolean;
+}): void;
+export declare function after_fetch_exhausted(region: HTMLElement, opts: {
+  revalidate?: boolean;
+}, wake_children: () => void): void;

package/dist/runtime/lakes.js

@@ -0,0 +1,212 @@
+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";
+// src/runtime/lakes.ts
+/** Feature entry: fill the `lakes` slot so core lifts/restores frozen regions. */
+function install() {
+	slots.lakes = {
+		on_frozen_connect,
+		wait_for_boundary,
+		lift,
+		restore,
+		settle_in,
+		mark_frozen_settled,
+		after_html_swap,
+		after_fetch_exhausted
+	};
+}
+function settle_in(root) {
+	runtime_session.settle_lakes_in(root);
+}
+const in_live_snippet = (lake, parent) => {
+	const snippet = lake.parentElement?.closest("ogygia-snippet");
+	return !!snippet && parent.contains(snippet) && !snippet.hasAttribute("data-og-static");
+};
+/** The lakes `parent`'s own hydrate lifts and restores: nearest region is `parent`, outside live snippets. */
+const lifted_lakes_of = (parent) => [...parent.querySelectorAll(FROZEN_SELECTOR)].filter((l) => l.parentElement?.closest("ogygia-region") === parent && !in_live_snippet(l, parent));
+function lift(parent) {
+	const lifted = [];
+	for (const lake of lifted_lakes_of(parent)) {
+		const id = lake.getAttribute("entry") || "";
+		const frag = document.createDocumentFragment();
+		while (lake.firstChild) frag.appendChild(lake.firstChild);
+		relocate_trailing_empty_comments(frag, lake);
+		lifted.push({
+			id,
+			frag,
+			endpoint: lake.getAttribute("endpoint") || "",
+			when: lake.getAttribute("when") || "load",
+			maxAgeMs: region_max_age_ms(lake)
+		});
+	}
+	return lifted;
+}
+function restore(parent, lifted) {
+	const lakes = lifted_lakes_of(parent);
+	for (const lake of parent.querySelectorAll(FROZEN_SELECTOR)) {
+		if (lake.parentElement?.closest("ogygia-region") !== parent || !in_live_snippet(lake, parent)) continue;
+		const id = lake.getAttribute("entry") || "";
+		settle_in(lake);
+		runtime_session.initialized_lakes.add(id);
+		remember(lake, id, {
+			endpoint: lake.getAttribute("endpoint") || "",
+			when: lake.getAttribute("when") || "load",
+			maxAgeMs: region_max_age_ms(lake)
+		});
+		for (const r of lake.querySelectorAll("ogygia-region")) r.connectedCallback?.();
+	}
+	for (let i = 0; i < lifted.length && i < lakes.length; i++) {
+		const lake = lakes[i];
+		const { id, frag, endpoint, when, maxAgeMs } = lifted[i];
+		settle_in(lake);
+		settle_in(frag);
+		runtime_session.initialized_lakes.add(id);
+		lake.appendChild(frag);
+		if (endpoint && !lake.getAttribute("endpoint")) lake.setAttribute("endpoint", endpoint);
+		remember(lake, id, {
+			endpoint,
+			when,
+			maxAgeMs
+		});
+	}
+}
+/** A lake with no AWAKE region host: nothing will ever lift/restore it (that is a host island's
+*  hydrate), so it settles itself and remembers itself. The shapes: a lake ADOPTED under Kit
+*  hydration (csr=true page), a lake inside an inline (Kit-hydrated) island, a top-level lake. */
+function unhosted(el) {
+	const host = el.parentElement?.closest("ogygia-region");
+	return !host || !is_awake(host);
+}
+/**
+* Snapshot a lake's current children into the session cache — the copy a later VACANT connect of
+* the same lake id repaints from (`remount="cache"` / `"swr"`). First snapshot wins: the SSR HTML
+* (or the freshest revalidation, which replaces it in `after_html_swap`).
+*/
+function remember(lake, id, meta) {
+	const policy = region_remount(lake);
+	if (!((policy === "cache" || policy === "swr") && id && !runtime_session.lake_cache.has(id))) return;
+	const cached = document.createDocumentFragment();
+	for (const child of Array.from(lake.childNodes)) cached.appendChild(child.cloneNode(true));
+	runtime_session.set_lake_cache(id, {
+		frag: cached,
+		endpoint: meta.endpoint,
+		when: meta.when,
+		cachedAt: Date.now(),
+		maxAgeMs: meta.maxAgeMs || region_max_age_ms(lake)
+	});
+}
+function on_frozen_connect(el, arm) {
+	if (!is_frozen(el)) return false;
+	const id = el.getAttribute("entry") || "";
+	if (!runtime_session.initialized_lakes.has(id)) {
+		if (region_remount(el) === "swr" && el.getAttribute("endpoint") && document_is_stored()) {
+			const when = el.getAttribute("when") || "load";
+			const fire = () => arm.fetch_revalidate();
+			if (when === "idle") arm.idle(fire);
+			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.`);
+		if (unhosted(el)) {
+			runtime_session.settled_lakes.add(el);
+			if (!region_is_vacant(el)) {
+				remember(el, id, {
+					endpoint: el.getAttribute("endpoint") || "",
+					when: el.getAttribute("when") || "load",
+					maxAgeMs: region_max_age_ms(el)
+				});
+				runtime_session.initialized_lakes.add(id);
+			}
+		}
+		return true;
+	}
+	if (!region_is_vacant(el)) {
+		if (unhosted(el)) runtime_session.settled_lakes.add(el);
+		return true;
+	}
+	const policy = region_remount(el);
+	switch (policy) {
+		case "empty":
+			runtime_session.settled_lakes.add(el);
+			return true;
+		case "cache":
+		case "swr": {
+			const cached = runtime_session.lake_cache.get(id);
+			if (!cached) {
+				runtime_session.settled_lakes.add(el);
+				return true;
+			}
+			const max_age = region_max_age_ms(el) || cached.maxAgeMs || 0;
+			const expired = max_age > 0 && Date.now() - cached.cachedAt > max_age;
+			const on_expire = region_on_expire(el);
+			if (expired && on_expire === "empty") {
+				runtime_session.settled_lakes.add(el);
+				return true;
+			}
+			if (expired && on_expire === "fetch") {
+				if (!cached.endpoint) {
+					runtime_session.settled_lakes.add(el);
+					return true;
+				}
+				el.setAttribute("endpoint", cached.endpoint);
+				const when = el.getAttribute("when") || cached.when || "load";
+				const fire = () => arm.fetch_revalidate();
+				if (when === "idle") arm.idle(fire);
+				else if (when === "visible") arm.visible(fire);
+				else if (when === "load") fire();
+				else arm.media(when, fire);
+				return true;
+			}
+			if (policy === "cache") {
+				runtime_session.settled_lakes.add(el);
+				el.appendChild(cached.frag.cloneNode(true));
+				return true;
+			}
+			el.appendChild(cached.frag.cloneNode(true));
+			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.`);
+				return true;
+			}
+			el.setAttribute("endpoint", cached.endpoint);
+			const when = el.getAttribute("when") || cached.when || "load";
+			const fire = () => arm.fetch_revalidate();
+			if (when === "idle") arm.idle(fire);
+			else if (when === "visible") arm.visible(fire);
+			else if (when === "load") fire();
+			else arm.media(when, fire);
+			return true;
+		}
+		default: return policy;
+	}
+}
+function wait_for_boundary(_el, boundary) {
+	return !!(boundary && is_frozen(boundary) && !runtime_session.settled_lakes.has(boundary));
+}
+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;
+	const id = region.getAttribute("entry") || "";
+	if (!id) return;
+	const cached = document.createDocumentFragment();
+	for (const child of Array.from(region.childNodes)) cached.appendChild(child.cloneNode(true));
+	const prev = runtime_session.lake_cache.get(id);
+	runtime_session.set_lake_cache(id, {
+		frag: cached,
+		endpoint: region.getAttribute("endpoint") || prev?.endpoint || "",
+		when: region.getAttribute("when") || prev?.when || "load",
+		cachedAt: Date.now(),
+		maxAgeMs: region_max_age_ms(region) || prev?.maxAgeMs || 0
+	});
+}
+function after_fetch_exhausted(region, opts, wake_children) {
+	if (opts.revalidate && is_frozen(region) && region.isConnected) {
+		runtime_session.settled_lakes.add(region);
+		wake_children();
+	}
+}
+export { after_fetch_exhausted, after_html_swap, install, lift, mark_frozen_settled, on_frozen_connect, restore, settle_in, wait_for_boundary };

package/dist/runtime/live.d.ts

@@ -0,0 +1,3 @@
+/** 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). */
+export declare function install(): void;

package/dist/runtime/live.js

@@ -0,0 +1,17 @@
+import { slots } from "./slots.js";
+import LiveHost from "../LiveHost.svelte";
+import KeepHost from "../KeepHost.svelte";
+// 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.
+*
+* 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). */
+function install() {
+	slots.live = LiveHost;
+	slots.keep = KeepHost;
+}
+export { install };

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

@@ -0,0 +1,53 @@
+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";
+/** How long background work waits for the page's critical resources at most. */
+export declare const CRITICAL_CAP_MS = 2500;
+/** Background (`ahead` + `speculative`) downloads in flight at once. */
+export declare const BACKGROUND_WINDOW = 3;
+/** The fetch priority a class downloads at (`fetch(…, { priority })`, `<link fetchpriority>`). */
+export declare function fetch_priority_of(cls: LoadClass): "high" | "auto" | "low";
+/**
+ * `visible` when `el` — or, for a region with no area of its own, what it renders — intersects the
+ * viewport now, else `ahead`. A region whose content is out of flow (a `position: fixed` button) or
+ * that is `display: contents` has no area, and where such a box sits says nothing (`display:
+ * contents` reports 0,0), so its descendants' boxes decide first (bounded: the first few levels).
+ */
+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: {
+  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;
+/** The URLs a preload link may fetch: its `href`, else each `imagesrcset` candidate's. */
+export declare function preload_urls(link: HTMLLinkElement): string[];
+/**
+ * Resolves once the document is parsed and painted AND its author-marked critical resources have
+ * 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;
+}
+/**
+ * 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).
+ */
+export declare function load_slot(o: {
+  kind: LoadKind;
+  cls: LoadClass | (() => LoadClass);
+  label?: string;
+}): {
+  ready: Promise<() => void>;
+  ticket: LoadTicket;
+};
+/** Test seam: a fresh document. */
+export declare function reset_load_scheduler(): void;
+export {};

package/dist/runtime/load-scheduler.js

@@ -0,0 +1,317 @@
+import { after_document_painted, yield_task } from "./schedule.js";
+import { kit_hydrates_page } from "./kit-boot.js";
+import { emit } from "../events/bus.js";
+// src/runtime/load-scheduler.ts
+/**
+* THE LOAD SCHEDULER — every download ogygia starts on its own goes through one queue.
+*
+* Island code, a hole's HTML, a hole's prefetch, the module warm on hover, the router's page
+* prefetch: each used to pick its own moment, and on a fast-parsing page they all started together,
+* beside the page's own LCP image — a country home page's hero took 2.27 s instead of 1.19 s while
+* 206 island requests (888 KB) shared its bandwidth. Priority hints alone do not fix that (a
+* throttled or priority-blind connection splits bandwidth evenly); waiting for the right moment,
+* and capping how much background work is in flight, does.
+*
+* Every download carries a CLASS, decided by who is waiting for it:
+*  - `user`        — a visitor's gesture (an `interaction` wake, a click-time navigation, an explicit
+*                    `preload()`): never waits, fetched at high priority.
+*  - `visible`     — on screen now (an island or hole in the viewport): fetched at default priority.
+*  - `ahead`       — not on screen yet (an `idle` island, one screen ahead, a hole prefetch): low
+*                    priority, a small window.
+*  - `speculative` — a guess about the future (the router's page prefetch, its module warm): low
+*                    priority, the same window, behind every `ahead`.
+*
+* And a GATE, decided by signals, not timers ({@link critical_settled}): island CODE and every
+* background class wait until the document is parsed and painted AND the page's critical resources
+* have arrived — the image or preload its author marked `fetchpriority="high"` (the LCP resource;
+* nothing to guess) — or the visitor's first click / key (the browser stops measuring LCP there), or
+* a cap. Visible CONTENT (a hole's HTML on screen) does not wait: it IS what the visitor sees.
+*
+* A queued download's class is re-read when the queue drains, so an island scrolling into view moves
+* from `ahead` to `visible`; `promote()` lifts a queued one by hand (a click on a link whose prefetch
+* still waits). On a Kit-hydrated document Kit's own start sets the pace, so nothing waits on the
+* critical resources there (the window still applies).
+*/
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+/** How long background work waits for the page's critical resources at most. */
+const CRITICAL_CAP_MS = 2500;
+/** Background (`ahead` + `speculative`) downloads in flight at once. */
+const BACKGROUND_WINDOW = 3;
+const RANK = {
+	user: 0,
+	visible: 1,
+	ahead: 2,
+	speculative: 3
+};
+/** The fetch priority a class downloads at (`fetch(…, { priority })`, `<link fetchpriority>`). */
+function fetch_priority_of(cls) {
+	return cls === "user" ? "high" : cls === "visible" ? "auto" : "low";
+}
+/**
+* `visible` when `el` — or, for a region with no area of its own, what it renders — intersects the
+* viewport now, else `ahead`. A region whose content is out of flow (a `position: fixed` button) or
+* that is `display: contents` has no area, and where such a box sits says nothing (`display:
+* contents` reports 0,0), so its descendants' boxes decide first (bounded: the first few levels).
+*/
+function viewport_class(el) {
+	if (typeof innerHeight === "undefined" || !el.isConnected) return "ahead";
+	return on_screen(el, 3) ? "visible" : "ahead";
+}
+function on_screen(el, depth) {
+	const r = el.getBoundingClientRect();
+	const crosses = r.bottom > 0 && r.right > 0 && r.top < innerHeight && r.left < innerWidth;
+	if (r.width > 0 && r.height > 0) return crosses;
+	if (depth > 0) {
+		let seen = 0;
+		for (let c = el.firstElementChild; c && seen < 16; c = c.nextElementSibling, seen++) if (on_screen(c, depth - 1)) return true;
+	}
+	return crosses && (r.width > 0 || r.height > 0);
+}
+let input_seen = false;
+const on_first_input = () => {
+	input_seen = true;
+	release_critical?.();
+};
+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's outcome once it settled (the profiler's beacon reads it), else `null`. */
+function critical_outcome() {
+	return critical_report;
+}
+/** 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. */
+function pending_critical() {
+	const out = [];
+	for (const img of document.querySelectorAll("img[fetchpriority=\"high\" i]")) {
+		if (img.loading === "lazy" || img.complete) continue;
+		out.push(img);
+	}
+	for (const link of document.querySelectorAll("link[rel~=\"preload\"][fetchpriority=\"high\" i]")) {
+		if (link.media && !matchMedia(link.media).matches) continue;
+		const urls = preload_urls(link);
+		if (!urls.length) continue;
+		if (urls.some((u) => performance.getEntriesByName?.(u).length)) continue;
+		out.push(link);
+	}
+	return out;
+}
+/** The URLs a preload link may fetch: its `href`, else each `imagesrcset` candidate's. */
+function preload_urls(link) {
+	if (link.href) return [link.href];
+	const set = link.getAttribute("imagesrcset");
+	if (!set) return [];
+	const out = [];
+	for (const part of set.split(",")) {
+		const candidate = part.trim();
+		let end = 0;
+		while (end < candidate.length && candidate.charCodeAt(end) > 32) end++;
+		const url = candidate.slice(0, end);
+		if (!url) continue;
+		try {
+			out.push(new URL(url, document.baseURI).href);
+		} catch {}
+	}
+	return out;
+}
+/**
+* Resolves once the document is parsed and painted AND its author-marked critical resources have
+* 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.
+*/
+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");
+		let left = waiting.length;
+		const one = () => {
+			if (--left === 0) done("arrived");
+		};
+		for (const el of waiting) {
+			el.addEventListener("load", one, { once: true });
+			el.addEventListener("error", one, { once: true });
+		}
+	}));
+}
+const queue = [];
+let in_flight_background = 0;
+let next_order = 0;
+let scroll_watch = false;
+/**
+* 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).
+*/
+function load_slot(o) {
+	let forced = null;
+	const read = typeof o.cls === "function" ? o.cls : () => o.cls;
+	const cls = () => {
+		const c = read();
+		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;
+			drain();
+		} }
+	};
+}
+function waits_for_critical(kind, cls) {
+	if (cls === "user") return false;
+	if (kit_hydrates_page()) return false;
+	return !(kind === "content" && cls === "visible");
+}
+/**
+* Starts go out across tasks: a start's holder runs its own start-up synchronously (an island adds
+* its graph links and starts its imports; the first one also the runtime's lazy chunks), so when the
+* gate opened on a page of 21 islands, every one of those ran in the task that opened it — one long
+* 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;
+function drain() {
+	if (draining) {
+		drain_again = true;
+		return;
+	}
+	if (!queue.length) return;
+	draining = true;
+	drain_queue().finally(() => {
+		draining = false;
+		if (drain_again) {
+			drain_again = false;
+			drain();
+		}
+	});
+}
+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);
+		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;
+			}
+		}
+		if (!yielded && !drain_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();
+	});
+}
+/** 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;
+	let framed = false;
+	const on_scroll = () => {
+		if (framed) return;
+		framed = true;
+		requestAnimationFrame(() => {
+			framed = false;
+			drain();
+			if (!queue.length) {
+				removeEventListener("scroll", on_scroll, true);
+				scroll_watch = false;
+			}
+		});
+	};
+	addEventListener("scroll", on_scroll, {
+		capture: true,
+		passive: true
+	});
+}
+function now() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+/** Test seam: a fresh document. */
+function reset_load_scheduler() {
+	queue.length = 0;
+	in_flight_background = 0;
+	draining = false;
+	drain_again = false;
+	critical = null;
+	critical_done = false;
+	release_critical = null;
+	critical_report = null;
+	input_seen = false;
+}
+export { BACKGROUND_WINDOW, CRITICAL_CAP_MS, critical_outcome, critical_settled, fetch_priority_of, load_slot, preload_urls, reset_load_scheduler, viewport_class };

package/dist/runtime/morph.d.ts

@@ -0,0 +1,42 @@
+/** Feature entry: fill the `morph` slot (live static-region ticks morph in place). */
+export declare function install(): void;
+/**
+ * Reconcile `parent`'s children toward `new_nodes` (a freshly parsed, detached region). Public slot
+ * shape: `(parent: Element, nodes: Node[]) => void` — a drop-in for the previous implementation.
+ *
+ * `new_nodes` is read but never mutated, so the recursion passes the incoming element's live
+ * `childNodes` straight through (see {@link morph_node}) — no per-level array snapshot. Accessed by
+ * index, so both a real `Array` (the top-level region) and a live `NodeList` (recursion) fit.
+ *
+ * Two phases:
+ *  1. **Lockstep** — walk old and new in parallel while their keys agree (both `null` and compatible,
+ *     or the same non-null key), morphing in place. This is the dominant tick (same structure, values
+ *     changed) and it allocates NOTHING — no key map, no cursor bookkeeping. Reorders/inserts/removals
+ *     break the lockstep at the first divergence and hand the REMAINDER to phase 2.
+ *  2. **Keyed reconcile** — the general move/insert/remove algorithm, run only on the still-unmatched
+ *     tail. The key map indexes just the remaining old children, so a change late in a long list still
+ *     skips indexing the aligned prefix.
+ */
+export declare function morph_children(parent: Element, new_nodes: ArrayLike<Node>, options?: MorphOptions): void;
+/**
+ * One ownership rule (runtime/ownership.ts), two TARGETS.
+ *
+ * - **`live`** (default: a hole re-answer, a router body swap, a live region tick) — the target is the
+ *   new answer, and the DOM stays live afterwards: a child an upgraded element gave itself is foreign
+ *   content, kept (a web component must not lose its own upgrade work).
+ * - **`walk`** (the pre-hydration repair) — the target is the server sequence Svelte's walk binds by
+ *   position, exactly. The same foreign child sitting in a position the walk reads is the node
+ *   Svelte's cursor trips on (`getAttribute is not a function` on a nested web component's own
+ *   residue), so here it is removed; and a subtree the walk never enters (`data-og-opaque`, a slot) is
+ *   left alone — nothing reads it.
+ *
+ * In both targets a declared-foreign element and a hydrated region are matched, never entered, and an
+ * upgraded element's host ATTRIBUTES stay its runtime's.
+ */
+export interface MorphOptions {
+  target?: "live" | "walk";
+}
+/** Add + update + remove attributes so `from` matches `to` exactly. Boolean attrs are attr presence.
+ *  `keep_extra` (a self-owned element, {@link is_self_owned}): add + update only — an attribute the
+ *  element gave itself is not the render's to take away. */
+export declare function sync_attributes(from: Element, to: Element, keep_extra?: boolean): void;