@ogygia/core 0.12.2 → 0.13.0

package/dist/policies.js

@@ -0,0 +1,66 @@
+import { policy } from "@ogygia/machine";
+// src/policies.ts
+/**
+* EVERY RETRY, BACKOFF AND DEADLINE OF THE RUNTIME AND THE SERVER, NAMED ONCE (#313). Each is a
+* `policy()` of `@ogygia/machine` named for what it protects, with the reason for its numbers
+* beside it: the work that tries again reads them from here, never a number of its own.
+*
+* These are the numbers the code used before they were named (no behavior moved with them), so
+* tuning one is a change here and nowhere else. Each is marked pure: a bundle keeps only the ones
+* its code reads (the browser runtime does not ship the server's render and stream deadlines).
+*/
+/** A lazy chunk of the runtime (the hydrate core, the navigation chunk, devalue): one more try at
+*  once when its download fails, under a fresh URL (`import_again`). A dropped download is usually
+*  a blip; a second failure is a real outage, and the caller's own recovery takes over. */
+const download = /* @__PURE__ */ policy({
+	attempts: 2,
+	backoff: 0,
+	jitter: 0,
+	deadline: Infinity
+});
+/** devalue's download for a read that runs once (a streamed value's resolver): asked for again
+*  after 1, 2, 4 and 8 s, then left (the network is down; the reads wait, as before). */
+const devalue_download = /* @__PURE__ */ policy({
+	attempts: 5,
+	backoff: 1e3,
+	jitter: 0,
+	deadline: Infinity
+});
+/** A hole's fetch of its region: three tries, 0.5 s then 1 s apart, before it keeps its fallback.
+*  Long enough for a server restart's blip, short enough that a broken hole settles fast. */
+const region_fetch = /* @__PURE__ */ policy({
+	attempts: 3,
+	backoff: [500, 1e3],
+	jitter: 0,
+	deadline: Infinity
+});
+/** A region's server render, its wait for a render slot included: one try within 10 s (#195). A
+*  render stuck on a hung upstream past it is abandoned, so it never holds a slot for good. */
+const render = /* @__PURE__ */ policy({
+	attempts: 1,
+	backoff: 0,
+	jitter: 0,
+	deadline: 1e4
+});
+/** A batch stream of holes: given up after 10 s with no bytes (#214). The server sends a hole's part
+*  only once it has rendered, so a few quiet seconds are a slow render, not a dead stream; the
+*  `render` deadline bounds each render, so a stream quiet for as long is dead. */
+const stream = /* @__PURE__ */ policy({
+	attempts: 1,
+	backoff: 0,
+	jitter: 0,
+	deadline: 1e4
+});
+/** An island file's recovery during a deploy's rollover: the current build's map asked at once,
+*  then after 1, 3 and 9 s while it settles (a rollover settles in seconds). */
+const rollover = /* @__PURE__ */ policy({
+	attempts: 4,
+	backoff: [
+		1e3,
+		3e3,
+		9e3
+	],
+	jitter: 0,
+	deadline: Infinity
+});
+export { devalue_download, download, region_fetch, render, rollover, stream };

package/dist/preference.js

@@ -1,4 +1,5 @@
 import { script } from "./script.js";
+import { OgygiaError } from "./messages/island.js";
 // src/preference.ts
 /**
 * `preference()` — a persisted, site-wide client CHOICE that flips a CSS state, with zero shipped JS
@@ -44,7 +45,11 @@ function preference_switch() {
 }
 /** Declare a site-wide client preference. Throws at creation if `default` isn't one of `values`. */
 function preference_impl(spec) {
-	if (!spec.values.includes(spec.default)) throw new Error(`[ogygia] preference('${spec.name}'): default '${spec.default}' is not one of values [${spec.values.join(", ")}]`);
+	if (!spec.values.includes(spec.default)) throw new OgygiaError("preference_default_invalid", {
+		name: spec.name,
+		fallback: spec.default,
+		values: spec.values.join(", ")
+	});
 	const name = spec.name;
 	const values = spec.values;
 	const def = spec.default;

package/dist/preload.js

@@ -1,6 +1,7 @@
 import { REGION_BRAND } from "./region-brand.js";
 import { frameAddress } from "./frame.js";
-import { ensure } from "./runtime/frame-store.js";
+import { ensure, renew } from "./runtime/frame-store.js";
+import { fetch_hole } from "./runtime/hole-fetch.js";
 // src/preload.ts
 function preload(region) {
 	if (typeof document === "undefined") return;
@@ -9,13 +10,9 @@ function preload(region) {
 	const url = typeof r.url === "string" ? r.url : "";
 	if (!url || r.html != null) return;
 	const address = frameAddress(url);
-	ensure(address, async (signal) => {
-		const res = await fetch(url, {
-			credentials: "same-origin",
-			signal
-		});
-		if (!res.ok) throw new Error("status " + res.status);
-		return res.text();
-	}).catch(() => {});
+	ensure(address, (signal) => fetch_hole(url, {
+		signal,
+		renewed: (fresh) => renew(address, fresh)
+	})).catch(() => {});
 }
 export { preload };

package/dist/ref-watch.d.ts

@@ -1,13 +1,3 @@
-/**
- * THE HUB'S WATCH CHANNEL (hub v2, phases W and B) — split out of ref.ts so the boot, which needs only
- * "subscribe to an id / tell its watchers" (runtime/frame-store.ts: region frames), never carries the
- * whole identity hub. ref.ts re-exports all of it: one channel either way.
- *
- * WATCH — subscribe to fresh data settling for a hub id. THE one subscription primitive: region
- * frames, streamed page-data, live refresh — every "a value arrives later for this identity" channel
- * routes through here instead of owning its own subscriber set. Browser-only in practice (the
- * request-scoped server never re-settles an id within one render).
- */
 type Watcher = (live: unknown) => void;
 export declare function watchers(): Map<string, Set<Watcher>>;
 /** Subscribe to fresh data settling for `id`. Returns an unsubscribe fn. */

package/dist/ref-watch.js

@@ -1,4 +1,15 @@
+import { report_thrown } from "./report-thrown.js";
 // src/ref-watch.ts
+/**
+* THE HUB'S WATCH CHANNEL (hub v2, phases W and B) — split out of ref.ts so the boot, which needs only
+* "subscribe to an id / tell its watchers" (runtime/frame-store.ts: region frames), never carries the
+* whole identity hub. ref.ts re-exports all of it: one channel either way.
+*
+* WATCH — subscribe to fresh data settling for a hub id. THE one subscription primitive: region
+* frames, streamed page-data, live refresh — every "a value arrives later for this identity" channel
+* routes through here instead of owning its own subscriber set. Browser-only in practice (the
+* request-scoped server never re-settles an id within one render).
+*/
 /** id → callbacks. One per realm (a second bundle evaluating this module shares it). */
 const WATCHERS_KEY = Symbol.for("ogygia.hub.watchers");
 function watchers() {
@@ -36,7 +47,9 @@ function notify_now(id, live) {
 	if (set === void 0) return;
 	for (const cb of Array.from(set)) try {
 		cb(live);
-	} catch {}
+	} catch (error) {
+		report_thrown(error);
+	}
 }
 let batch_depth = 0;
 let batch_pending = null;

package/dist/ref.js

@@ -1,6 +1,8 @@
 import { emit } from "./events/bus.js";
 import { batch, notify, watch, watcher_count, watchers } from "./ref-watch.js";
 import { resolve_sink, set_resolve_sink } from "./ref-sink.js";
+import { OgygiaError } from "./messages/island.js";
+import { report_thrown } from "./report-thrown.js";
 // src/ref.ts
 const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
 const REGISTRY_KEY = Symbol.for("ogygia.hub");
@@ -104,14 +106,18 @@ function dispose_scope(scope) {
 			const kind = reg.kinds.get(reg.instance_kind.get(inst) ?? "");
 			try {
 				kind?.dispose?.(inst);
-			} catch {}
+			} catch (error) {
+				report_thrown(error);
+			}
 		}
 		b.clear();
 	}
 	const ds = reg.scope_disposers.get(scope);
 	if (ds !== void 0) for (const fn of Array.from(ds)) try {
 		fn();
-	} catch {}
+	} catch (error) {
+		report_thrown(error);
+	}
 }
 /**
 * DISPOSE specific page-scoped ids (reconciler R3) — the SELECTIVE counterpart to dispose_scope.
@@ -136,7 +142,9 @@ function dispose_ids(ids) {
 		reg.instance_kind.delete(inst);
 		try {
 			kind?.dispose?.(inst);
-		} catch {}
+		} catch (error) {
+			report_thrown(error);
+		}
 	}
 	if (DEVTOOLS && dt_disposed > 0) emit({
 		domain: "hub",
@@ -192,14 +200,18 @@ function resolve(ref, scope_or_remember) {
 		}
 	}
 	const kind = reg.kinds.get(ref.k);
-	if (kind === void 0) throw new Error(`[ogygia] cannot resolve a "${ref.k}" ref: no such kind is registered on this side. The module that registers it must be imported as a VALUE in this bundle.`);
+	if (kind === void 0) throw new OgygiaError("ref_kind_missing", { kind: String(ref.k) });
 	if (remember) {
 		const name = kind.keep_name?.(ref);
 		if (typeof name === "string") {
 			const tag = ref.t ?? ref.k;
 			const owner = reg.keep_owner.get(name);
 			if (owner === void 0) reg.keep_owner.set(name, tag);
-			else if (owner !== tag && typeof console !== "undefined") console.error(`[ogygia] two transportables both use continuity id "${name}" ("${owner}" and "${tag}"). A continuity id must be unique per class — rename one, or they will clobber each other in the session Keep.`);
+			else if (owner !== tag && typeof console !== "undefined") console.error(new OgygiaError("continuity_id_collision", {
+				name,
+				owner,
+				tag
+			}));
 			const kept = bucket(reg, "session").get(name);
 			if (kept !== void 0) {
 				kind.merge?.(kept, ref);

package/dist/region-snippet.js

@@ -5,6 +5,7 @@ import { PORTABLE_FORM, with_portable_forms } from "./portable-form.js";
 import { analyze } from "./seed-refs.js";
 import { fnv1a, fnv1a32 } from "./runtime/hash.js";
 import { import_entry } from "./runtime/entry-locations.js";
+import { OgygiaError } from "./messages/island.js";
 import { createRawSnippet, getAllContexts, hydrate, unmount } from "svelte";
 import { render } from "svelte/server";
 import { BROWSER, DEV } from "esm-env";
@@ -168,7 +169,10 @@ function capture_static(snippet, label) {
 		}).body;
 	} catch (e) {
 		const where = label ? `prop \`${label}\`` : "a function prop";
-		throw new Error(`[ogygia] ${where} is a function that can't cross the island boundary — ${e instanceof Error ? e.message : String(e)}. Island props must be SERIALIZABLE; a function crosses only as a Svelte snippet that freezes to HTML, and this one didn't. Usually one of:\n  • it's a PLAIN function (an event handler / callback) — those can't cross into an island; pass serializable data as props and keep the behavior inside the island component;\n  • it's a snippet WITH PARAMETERS — declare it as a {#snippet} so it crosses LIVE, or pass its data as props;\n  • it's children containing a NESTED island — keep those out of frozen children for now.`);
+		throw new OgygiaError("function_prop_cannot_cross", {
+			where,
+			reason: e instanceof Error ? e.message : String(e)
+		});
 	}
 	return make({
 		m: "static",
@@ -204,11 +208,13 @@ function og_portable(native, Entry, props, url) {
 /** Lift a parameterless snippet, or a raw `{ render, setup?, captures? }`, into a region snippet. */
 function region_snippet(input) {
 	if (typeof input === "function" && !BROWSER) return capture_static(input);
-	if (typeof input === "function") throw new Error("[ogygia] region_snippet(fn) freezes a snippet by server-rendering it — call it during SSR, not on the client. Pass a raw { render, setup } region snippet for client-constructed regions.");
+	if (typeof input === "function") throw new OgygiaError("region_snippet_on_client");
 	const caps = input.captures ?? [];
 	const snip = createRawSnippet(() => ({
 		render: () => WRAP_OPEN + input.render(...caps) + WRAP_CLOSE,
-		setup: input.setup ? (el) => void input.setup(el, ...caps) : () => {}
+		setup: input.setup ? (el) => {
+			input.setup(el, ...caps);
+		} : () => {}
 	}));
 	snip.__ogRegion = {
 		m: "static",

package/dist/region.js

@@ -3,6 +3,7 @@ import { with_portable_forms } from "./portable-form.js";
 import { REGION_BRAND } from "./region-brand.js";
 import { kit_page_facts_tail, kit_page_ready, kit_render_context } from "./server/kit-context.js";
 import { region_css_tags } from "./server/html-scan.js";
+import { OgygiaError } from "./messages/island.js";
 import RawHtml from "./RawHtml.svelte";
 // src/region.ts
 /** Brand so the transport can recognize a region without false-matching plain objects. */
@@ -28,7 +29,7 @@ function make_region(component, props, opts, content_id) {
 				props: p,
 				...content_id ? { content_id } : {}
 			});
-			throw new Error("[ogygia] a `with { region: 'raw' }` component must be turned into a region on the server (the signer lives server-side). Call region() in a load / remote / render context, not in client code.");
+			throw new OgygiaError("raw_region_on_client");
 		}
 		const hydrate = o?.wake ?? component.__hydrate;
 		const hydrateMargin = o?.margin ?? component.__hydrateMargin;

package/dist/report-thrown.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AN APP'S CALLBACK THAT THREW where the loop it ran in must go on (a ref watcher, a scope disposer,
+ * a page store subscriber, a navigation hook, a receipt seam, a devtools sink): the others still
+ * run, and its error is not dropped. On a page it goes to the page's error handler (`reportError`:
+ * the console and `window.onerror`, where error monitoring sees it), exactly as an uncaught throw
+ * would, without stopping the loop. Where there is no such handler (a server, a test), it is
+ * printed.
+ */
+export declare function report_thrown(error: unknown): void;

package/dist/report-thrown.js

@@ -0,0 +1,15 @@
+// src/report-thrown.ts
+/**
+* AN APP'S CALLBACK THAT THREW where the loop it ran in must go on (a ref watcher, a scope disposer,
+* a page store subscriber, a navigation hook, a receipt seam, a devtools sink): the others still
+* run, and its error is not dropped. On a page it goes to the page's error handler (`reportError`:
+* the console and `window.onerror`, where error monitoring sees it), exactly as an uncaught throw
+* would, without stopping the loop. Where there is no such handler (a server, a test), it is
+* printed.
+*/
+function report_thrown(error) {
+	const report = globalThis.reportError;
+	if (typeof report === "function") report(error);
+	else console.error(error);
+}
+export { report_thrown };

package/dist/rules.d.ts

@@ -0,0 +1,17 @@
+/** What a rule found broken (null: it holds). */
+export type RuleCheck = () => string | null;
+/** A rule found broken: its code, and what it found. */
+export interface BrokenRule {
+  readonly code: string;
+  readonly detail: string;
+}
+/** One area's rules: each a check under its code. */
+export declare class Rules<C extends string> {
+  #private;
+  /** Adds a rule. */
+  add(code: C, check: RuleCheck): void;
+  /** Every rule broken now. A check that throws is broken, with its error. */
+  broken(): BrokenRule[];
+  /** Checks every rule, and says each newly broken one (`say` prints its code). */
+  say(say: (code: C, detail: string) => void): void;
+}

package/dist/rules.js

@@ -0,0 +1,57 @@
+// src/rules.ts
+/**
+* RULES AS CODE (#313). Each "always true" rule of an area is written once, as a plain function over
+* that area's state that names what it found broken (or null: kept), under the message code it
+* breaks with. The same function is checked wherever it is cheap to look:
+*
+* - in dev, after machine moves and navigations (the runtime) and after each response (the server),
+*   printing its code once per thing it found;
+* - in e2e, at the end of every test (`globalThis.__ogygia_rules()` in the page, read by the e2e
+*   harness's `rules(page)`).
+*
+* The areas keep their rules beside their code (./runtime/rules.ts, ./server/rules.ts) and register
+* them here. Rules exist in dev and in a build made with `OGYGIA_RULES=1` (the e2e suites'); in any
+* other build every call site folds out, and no rule ships (`__OGYGIA_RULES__`).
+*/
+const SAID_MAX = 200;
+/** One area's rules: each a check under its code. */
+var Rules = class {
+	#checks = [];
+	/** What was said already (`code detail`): a rule that stays broken is said once. */
+	#said = /* @__PURE__ */ new Set();
+	/** Adds a rule. */
+	add(code, check) {
+		this.#checks.push({
+			code,
+			check
+		});
+	}
+	/** Every rule broken now. A check that throws is broken, with its error. */
+	broken() {
+		const out = [];
+		for (const { code, check } of this.#checks) {
+			let detail;
+			try {
+				detail = check();
+			} catch (error) {
+				detail = "the check threw: " + String(error);
+			}
+			if (detail !== null) out.push({
+				code,
+				detail
+			});
+		}
+		return out;
+	}
+	/** Checks every rule, and says each newly broken one (`say` prints its code). */
+	say(say) {
+		for (const b of this.broken()) {
+			const key = b.code + " " + b.detail;
+			if (this.#said.has(key)) continue;
+			if (this.#said.size >= SAID_MAX) return;
+			this.#said.add(key);
+			say(b.code, b.detail);
+		}
+	}
+};
+export { Rules };

package/dist/runtime/beacon.d.ts

@@ -143,10 +143,6 @@ export interface EntryFallback {
   recovered: boolean;
 }
 export declare function beacon_entry_fallback(f: EntryFallback): void;
-/** The runtime asks for a hole's HTML (each ask, retries and re-asks included): what lets a
- *  preload followed by a download read as used-then-asked-again, not as a preload the browser could
- *  not use. */
-export declare function beacon_hole_fetched(endpoint: string): void;
 /** A hole's first answer landed: the profiler weighs how long its fallback held the first screen.
  *  The element is read (id, place) only while measuring. */
 export declare function beacon_hole_answered(el: Element, start: number, batch?: {

package/dist/runtime/beacon.js

@@ -4,6 +4,7 @@ import { paint_blocker } from "./render-blocking.js";
 import { critical_outcome } from "./load-scheduler.js";
 import { devtools_switched_on } from "../insights/switch.js";
 import { charge, metered } from "./own-cost.js";
+import { machine } from "@ogygia/machine";
 // src/runtime/beacon.ts
 /**
 * THE BEACON — the browser's half of the profiler. When the document carries
@@ -45,7 +46,6 @@ function owner() {
 		beacon_hole_answered,
 		beacon_hole_batch_missed,
 		beacon_entry_fallback,
-		beacon_hole_fetched,
 		beacon_nav
 	};
 	const g = globalThis;
@@ -72,7 +72,6 @@ function beacon_mark(name, ms, attrs, t0) {
 	schedule();
 }
 let vitals = null;
-let vitals_sent = false;
 const ISLAND_SEL = "ogygia-region[data-og-fp]";
 const r2 = (n) => Math.round(n * 100) / 100;
 let visit_islands = [];
@@ -296,20 +295,6 @@ function beacon_entry_fallback(f) {
 	});
 	if (early_visit_done) resend_soon();
 }
-/** each hole URL (absolute) → how many times the runtime asked the network for it */
-let hole_fetches = /* @__PURE__ */ new Map();
-/** The runtime asks for a hole's HTML (each ask, retries and re-asks included): what lets a
-*  preload followed by a download read as used-then-asked-again, not as a preload the browser could
-*  not use. */
-function beacon_hole_fetched(endpoint) {
-	const o = owner();
-	if (o) return o.beacon_hole_fetched?.(endpoint);
-	if (!collecting() || hole_fetches.size >= 200) return;
-	try {
-		const url = new URL(endpoint, location.href).href;
-		hole_fetches.set(url, (hole_fetches.get(url) ?? 0) + 1);
-	} catch {}
-}
 let holes_answered_els = /* @__PURE__ */ new WeakSet();
 /** A hole's first answer landed: the profiler weighs how long its fallback held the first screen.
 *  The element is read (id, place) only while measuring. */
@@ -352,7 +337,22 @@ let lcp_el = null;
 let lcp_region = null;
 /** an island's markup as the server sent it and after it hydrated — the browser store only */
 let snapshots = [];
-let visit_sent = false;
+/**
+* THE VISIT'S STATE. A hide sends the vitals and the visit (`sent`), but the visit is not over:
+* coming back to the tab, or a back/forward cache restore, opens it again (`reopened`), and what
+* happens after (a navigation, a worse interaction, a shift) goes out again, with the next hide.
+* A second hide with no return in between sends nothing more.
+*/
+const visit_machine = machine()({
+	name: "beacon-visit",
+	initial: "open",
+	steps: {
+		open: ["sent"],
+		sent: ["reopened"],
+		reopened: ["sent"]
+	}
+});
+let visit_state = visit_machine.create();
 const SNAPSHOT_CAP = 24e3;
 const MAX_SNAPSHOTS = 40;
 /** The snapshot of a changed island: whole when both fit, else the window around the change
@@ -690,8 +690,7 @@ function send(body, slim) {
 	post(body, true);
 }
 function flush_vitals() {
-	if (vitals_sent || !vitals || !Object.keys(vitals).length) return;
-	vitals_sent = true;
+	if (!vitals || !Object.keys(vitals).length) return;
 	send(JSON.stringify({
 		page: visit_page(),
 		at: Math.round(performance.timeOrigin),
@@ -1093,17 +1092,14 @@ function build_visit_now() {
 		for (const [url, list] of by_url) {
 			if (list.length < 2 || preload_misses.length >= 20) continue;
 			const pre = list.find((r) => r.initiatorType === "link");
-			const downloads = list.filter((r) => r !== pre && r.initiatorType !== "link" && r.encodedBodySize > 0 && r.transferSize >= r.encodedBodySize);
-			const again = downloads[0];
+			const again = list.filter((r) => r !== pre && r.initiatorType !== "link" && r.encodedBodySize > 0 && r.transferSize >= r.encodedBodySize)[0];
 			if ((pre?.responseStatus ?? 0) >= 400) continue;
-			if (downloads.length < (hole_fetches.get(url) ?? 0)) continue;
 			if (pre && again) preload_misses.push({
 				url: url.slice(0, 500),
 				type: type_of(pre),
 				bytes: again.transferSize,
 				as: link_as.get(url) ?? "",
-				crossorigin: link_co.get(url) ?? null,
-				...hole_fetches.has(url) ? { hole: true } : {}
+				crossorigin: link_co.get(url) ?? null
 			});
 		}
 		const reload = nav.type === "reload";
@@ -1276,18 +1272,17 @@ function visit_page() {
 	if (landing_page === null && typeof location !== "undefined") landing_page = location.pathname;
 	return landing_page ?? "/";
 }
+/** The visit so far; `final`: the hide's (the page may come back: `visit_state`). Nothing while
+*  the page is hidden after its hide sent it. */
 function flush_visit(final) {
-	if (visit_sent) return;
+	if (visit_state.now.kind === "sent") return;
 	const visit = build_visit();
 	if (!visit) return;
-	if (final) {
-		visit_sent = true;
-		for (const s of snapshots) {
-			const el = document.querySelector(`ogygia-region[data-og-fp="${s.fp}"]`);
-			if (el) {
-				const html = s.from === void 0 ? el.innerHTML : without_runtime_marks(without_comments(el.innerHTML)).slice(s.from, s.from + SNAPSHOT_CAP);
-				if (html !== s.hydrated) s.final = html.slice(0, SNAPSHOT_CAP);
-			}
+	if (final) for (const s of snapshots) {
+		const el = document.querySelector(`ogygia-region[data-og-fp="${s.fp}"]`);
+		if (el) {
+			const html = s.from === void 0 ? el.innerHTML : without_runtime_marks(without_comments(el.innerHTML)).slice(s.from, s.from + SNAPSHOT_CAP);
+			if (html !== s.hydrated) s.final = html.slice(0, SNAPSHOT_CAP);
 		}
 	}
 	if (!endpoint()) return;
@@ -1856,13 +1851,15 @@ function endpoint() {
 	return target = href ? href : null;
 }
 let early_visit_done = false;
+/** The re-send waiting to go: its cancel. The open visit's timer: the hide (`sent`) or a reset ends
+*  it with the visit. */
 let resend_timer = null;
 let resends = 0;
 const RESEND_MAX = 8;
 function resend_soon() {
-	if (!endpoint() || visit_sent || resends >= RESEND_MAX) return;
-	if (resend_timer) clearTimeout(resend_timer);
-	resend_timer = setTimeout(() => {
+	if (!endpoint() || visit_state.now.kind === "sent" || resends >= RESEND_MAX) return;
+	resend_timer?.();
+	resend_timer = visit_state.scope.timeout(() => {
 		resend_timer = null;
 		resends++;
 		flush_visit(false);
@@ -1901,14 +1898,24 @@ function on_hide() {
 	leaving = true;
 	try {
 		flush();
-		flush_vitals();
-		flush_visit(true);
+		if (visit_state.now.kind !== "sent") {
+			resend_timer?.();
+			resend_timer = null;
+			flush_vitals();
+			flush_visit(true);
+			visit_state.go("sent");
+		}
 	} finally {
 		leaving = false;
 	}
 	flush_cpu(true);
 	stop_interaction_cpu(true);
 }
+/** the page is shown again (back to its tab, or restored from the back/forward cache): the visit
+*  goes on, and the next hide sends it again */
+function on_show() {
+	visit_state.move("sent", "reopened");
+}
 function schedule() {
 	if (scheduled) return;
 	scheduled = true;
@@ -1916,8 +1923,9 @@ function schedule() {
 		listening = true;
 		observe_vitals();
 		start_cpu();
-		document.addEventListener("visibilitychange", () => document.visibilityState === "hidden" && on_hide());
+		document.addEventListener("visibilitychange", () => document.visibilityState === "hidden" ? on_hide() : on_show());
 		addEventListener("pagehide", on_hide);
+		addEventListener("pageshow", (e) => e.persisted && on_show());
 	}
 	const idle = globalThis.requestIdleCallback;
 	if (idle) idle(flush, { timeout: 2e3 });
@@ -2113,7 +2121,6 @@ function _reset_beacon() {
 	marks = [];
 	scheduled = false;
 	vitals = null;
-	vitals_sent = false;
 	cpu = null;
 	cpu_sent = false;
 	cpu_kept = [];
@@ -2156,12 +2163,13 @@ function _reset_beacon() {
 	visit_hole_batches = [];
 	visit_entry_fallbacks = [];
 	holes_answered_els = /* @__PURE__ */ new WeakSet();
-	hole_fetches = /* @__PURE__ */ new Map();
 	visit_marks = [];
 	visit_paints = {};
 	lcp_el = lcp_region = null;
 	snapshots = [];
-	visit_sent = false;
+	visit_state.stop();
+	visit_state = visit_machine.create();
+	resend_timer = null;
 	early_visit_done = false;
 	resends = 0;
 }
@@ -2187,4 +2195,11 @@ function _beacon_send_leaving(body, slim) {
 	}
 }
 if (typeof document !== "undefined" && owner() === null && (devtools_measures() || !!document.querySelector("meta[name=\"ogygia-profiler-beacon\"]")) && !supports("longtask")) watch_frame_gaps();
-export { _beacon_send, _beacon_send_leaving, _beacon_state, _reset_beacon, attr_changes, beacon_entry_fallback, beacon_failed, beacon_hole_answered, beacon_hole_batch_missed, beacon_hole_failed, beacon_hole_fetched, beacon_hydrated, beacon_mark, beacon_nav, beacon_page, beacon_record_cpu, beacon_warning, beacon_watch, hole_request_times, is_headless, resource_type, without_comments, without_runtime_marks };
+const WAITING_KEY = Symbol.for("ogygia.beacon.waiting");
+if (typeof document !== "undefined" && owner() === null) {
+	const g = globalThis;
+	const waiting = g[WAITING_KEY];
+	delete g[WAITING_KEY];
+	if (waiting) for (const args of waiting) beacon_mark(...args);
+}
+export { _beacon_send, _beacon_send_leaving, _beacon_state, _reset_beacon, attr_changes, beacon_entry_fallback, beacon_failed, beacon_hole_answered, beacon_hole_batch_missed, beacon_hole_failed, beacon_hydrated, beacon_mark, beacon_nav, beacon_page, beacon_record_cpu, beacon_warning, beacon_watch, hole_request_times, is_headless, resource_type, without_comments, without_runtime_marks };

package/dist/runtime/boot-link.js

@@ -1,4 +1,5 @@
 import { slots } from "./slots.js";
+import { create_soft_refresh } from "./soft-refresh.js";
 import { KitBoot, kit_hydrates_page } from "./kit-boot.js";
 import { ABSOLUTE_URL_SCHEME, is_warmed_module, warm_island_module } from "./region-endpoint-url.js";
 import { note_entry_location } from "./entry-locations.js";
@@ -7,10 +8,14 @@ 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 { release_sheets } from "./region-sheets.js";
 import { yield_task } from "./schedule.js";
 import { beacon_nav } from "./beacon.js";
 import { is_self_owned, record_server_body, server_body_attributes, server_body_child, walk_enters } from "./ownership.js";
-import { load_slot } from "./load-scheduler.js";
+import { LoadSlot } from "./load-scheduler.js";
+import { devalue, load_devalue, needs_devalue, with_devalue } from "./devalue-lane.js";
+import { OgygiaError, warn } from "../messages/core.js";
+import { STALE, flights, stage, world } from "@ogygia/machine";
 // src/runtime/boot-link.ts
 /**
 * Fill `slots.boot` — the boot helpers and session state the runtime's lazy chunks (the hydrate
@@ -34,6 +39,7 @@ function link_boot() {
 		parse_region_html,
 		runtime_session,
 		regions_in_shadow,
+		release_sheets,
 		yield_task,
 		beacon_nav: BEACON ? beacon_nav : no_beacon_nav,
 		walk_enters,
@@ -41,7 +47,18 @@ function link_boot() {
 		record_server_body,
 		server_body_attributes,
 		server_body_child,
-		load_slot
+		LoadSlot,
+		load_devalue,
+		devalue,
+		with_devalue,
+		needs_devalue,
+		OgygiaError,
+		warn,
+		STALE,
+		flights,
+		stage,
+		world,
+		soft: create_soft_refresh()
 	};
 }
 export { link_boot };