@ogygia/core 0.12.2 → 0.13.0

package/dist/runtime/devalue-lane.d.ts

@@ -0,0 +1,13 @@
+import { Stale } from "@ogygia/machine";
+type Devalue = typeof import("devalue");
+/** Start (once) and await devalue's import. (Never STALE: nothing drops it.) */
+export declare const load_devalue: () => Promise<Devalue | Stale>;
+/** devalue, already loaded: a devalue-lane read only runs after its load ({@link load_devalue}). */
+export declare function devalue(): Devalue;
+/** Run `fn` with devalue now when it is loaded, else once it is. Nothing else asks again for its
+ *  caller (a streamed value's resolver runs once), so a failed download is asked for again later,
+ *  as `devalue_download` says (`tried`: the loads that failed so far). */
+export declare function with_devalue(fn: (d: Devalue) => void, tried?: number): void;
+/** Does this document (or fragment) hold a script only devalue can read? */
+export declare function needs_devalue(root: ParentNode): boolean;
+export {};

package/dist/runtime/devalue-lane.js

@@ -0,0 +1,49 @@
+import { import_again } from "./import-again.js";
+import { devalue_download, download } from "../policies.js";
+import { STALE, backoffAfter, flights } from "@ogygia/machine";
+// src/runtime/devalue-lane.ts
+/**
+* DEVALUE, LOADED WHEN A PAGE NEEDS IT. A side-channel script crosses in one of two lanes
+* (server/props-wire.ts): plain JSON under `data-og-format="json"` (the common props and seed: a
+* payload with nothing devalue exists for), devalue otherwise. A page whose scripts are all JSON never
+* reads devalue, so it never downloads it: the first read that needs it starts its import beside the
+* load that leads there (an island's wake starts it with the hydrate core; a navigation, before its
+* preflight), never after it. The parse itself stays synchronous: by then the module is in.
+*
+* A leaf: island-side code (the page-defer resolver) imports it, so it imports nothing of the boot.
+*
+* A download that fails is tried again at once, and a failure is never kept: the next read loads it
+* afresh (one dropped request must not leave every later wake, and every streamed value, unreadable).
+*/
+let lib = null;
+const import_devalue = import_again(() => import("devalue"));
+const devalue_load = flights({
+	name: "devalue",
+	run: () => import_devalue().then((m) => lib = m),
+	retry: download
+});
+/** Start (once) and await devalue's import. (Never STALE: nothing drops it.) */
+const load_devalue = () => devalue_load.get();
+/** devalue, already loaded: a devalue-lane read only runs after its load ({@link load_devalue}). */
+function devalue() {
+	if (!lib) throw new Error("[ogygia] https://ogygiajs.dev/e/devalue_not_loaded");
+	return lib;
+}
+/** Run `fn` with devalue now when it is loaded, else once it is. Nothing else asks again for its
+*  caller (a streamed value's resolver runs once), so a failed download is asked for again later,
+*  as `devalue_download` says (`tried`: the loads that failed so far). */
+function with_devalue(fn, tried = 0) {
+	if (lib) fn(lib);
+	else load_devalue().then((d) => d !== STALE && fn(d), () => {
+		const failed = tried + 1;
+		if (failed >= devalue_download.attempts) return;
+		setTimeout(() => with_devalue(fn, failed), backoffAfter(devalue_download, failed));
+	});
+}
+/** Every side-channel a read may parse with devalue: props sidecars, the page seed, page facts. */
+const DEVALUE_LANE_SELECTOR = "script[data-ogygia-props]:not([data-og-format=\"json\"]),script[type=\"application/ogygia-page\"]:not([data-og-format=\"json\"]),script[type=\"application/ogygia-page-facts\"]";
+/** Does this document (or fragment) hold a script only devalue can read? */
+function needs_devalue(root) {
+	return root.querySelector(DEVALUE_LANE_SELECTOR) !== null;
+}
+export { devalue, load_devalue, needs_devalue, with_devalue };

package/dist/runtime/disclose-version.d.ts

@@ -0,0 +1 @@
+export declare function disclose_version(): void;

package/dist/runtime/disclose-version.js

@@ -0,0 +1,14 @@
+// src/runtime/disclose-version.ts
+/**
+* WHICH OGYGIA IS THIS PAGE ON: the runtime adds its version to `window.__ogygia.v`, a Set, as
+* Svelte does with `window.__svelte.v`. A Set because a page can run more than one ogygia (a
+* federated fragment brings its own app's runtime). The full version, not just the major: telling
+* one release line from another is the point. The plugin defines it from the installed package.
+*/
+const VERSION = typeof __OGYGIA_VERSION__ !== "undefined" ? __OGYGIA_VERSION__ : null;
+function disclose_version() {
+	if (typeof window === "undefined" || !VERSION) return;
+	const own = window;
+	((own.__ogygia ??= {}).v ??= /* @__PURE__ */ new Set()).add(VERSION);
+}
+export { disclose_version };

package/dist/runtime/early-holes.d.ts

@@ -0,0 +1,4 @@
+import { Scope } from "@ogygia/machine";
+/** Take the parked requests over, once (the global is emptied): each the flight at its address,
+ *  with `visit` its first caller. */
+export declare function adopt_early_holes(visit: Scope): void;

package/dist/runtime/early-holes.js

@@ -0,0 +1,40 @@
+import { EARLY_HOLES_KEY } from "../early-holes.js";
+import { frameAddress } from "../frame.js";
+import { ensure, hold_refusal, renew } from "./frame-store.js";
+import { read_hole } from "./hole-fetch.js";
+import { scope } from "@ogygia/machine";
+// src/runtime/early-holes.ts
+/**
+* THE PAGE'S EARLY HOLE REQUESTS, TAKEN OVER (../early-holes.ts). The head started each `load`
+* hole's request during the parse and parked it on one global; at boot each becomes the flight at
+* its frame-store address, its response read the one way every hole answer is (./hole-fetch.ts
+* `read_hole`). The hole's own wake joins that flight, a batch finds the address in flight and
+* leaves it out, and the response is read once. The flight's first caller is the page visit, and
+* the flight's signal cancels the parked request: one nobody joined is cancelled with the visit.
+* Part of the frames feature (./frames.ts): no hole, no code.
+*/
+const PARKED = Symbol.for(EARLY_HOLES_KEY);
+/** Take the parked requests over, once (the global is emptied): each the flight at its address,
+*  with `visit` its first caller. */
+function adopt_early_holes(visit) {
+	const host = globalThis;
+	const parked = host[PARKED];
+	if (!parked) return;
+	delete host[PARKED];
+	for (const { url, response, controller } of parked) {
+		const address = frameAddress(url);
+		ensure(address, async (signal) => {
+			const tie = scope();
+			tie.on(signal, "abort", () => controller.abort(signal.reason));
+			try {
+				return await read_hole(url, response, {
+					signal,
+					renewed: (fresh) => renew(address, fresh)
+				});
+			} finally {
+				tie.close();
+			}
+		}, { signal: visit.signal }).catch((err) => hold_refusal(address, err));
+	}
+}
+export { adopt_early_holes };

package/dist/runtime/entry-locations.js

@@ -1,3 +1,6 @@
+import { import_file } from "./import-again.js";
+import { rollover } from "../policies.js";
+import { STALE, backoffAfter, flights, scope } from "@ogygia/machine";
 // src/runtime/entry-locations.ts
 /**
 * ENTRY IDENTITY → LOCATION, the browser's half (server/entry-location.ts is the server's).
@@ -54,7 +57,19 @@ function entry_location(entry, base) {
 * is not kept: the next identity-only load asks again (a blip must not cost the page every later one).
 */
 const BUILD_MAP_ATTR = "data-og-locations";
-let build_map = null;
+/** The map's read: whether it filled the locations. One read at a time, kept once it did. */
+const build_map = flights({
+	name: "build location map",
+	run: (url) => fetch(url).then((res) => res.ok ? res.json() : null).catch(() => null).then((map) => {
+		if (!map) return false;
+		for (const stable in map) {
+			const identity = absolute(stable, url);
+			if (!locations.has(identity)) locations.set(identity, absolute(map[stable], url));
+		}
+		return true;
+	}),
+	keep: (filled) => filled ? Infinity : 0
+});
 /**
 * Pin the build map's address to the page that wrote it, as `pin_region_urls` pins a region's: with
 * Kit's default `paths.relative` it is written relative to that page, and it is read lazily — after a
@@ -68,22 +83,10 @@ function pin_build_map() {
 	if (script && href) script.setAttribute(BUILD_MAP_ATTR, absolute(href));
 }
 function read_build_map() {
-	if (build_map) return build_map;
 	if (typeof document === "undefined") return null;
 	const href = document.querySelector(`script[${BUILD_MAP_ATTR}]`)?.getAttribute(BUILD_MAP_ATTR);
 	if (!href) return null;
-	const url = absolute(href);
-	const read = fetch(url).then((res) => res.ok ? res.json() : null).catch(() => null).then((map) => {
-		if (!map) {
-			if (build_map === read) build_map = null;
-			return;
-		}
-		for (const stable in map) {
-			const identity = absolute(stable, url);
-			if (!locations.has(identity)) locations.set(identity, absolute(map[stable], url));
-		}
-	});
-	return build_map = read;
+	return build_map.get(absolute(href));
 }
 /** The region attributes that hold a URL: its identity, its location, its hole's endpoint. */
 const REGION_URL_ATTRS = [
@@ -129,7 +132,11 @@ function island_entry_of(el) {
 * that kept it anyway), read once per document per app. Only an ogygia identity has one: the dev
 * server's module URLs never ask.
 */
-const current_maps = /* @__PURE__ */ new Map();
+const current_maps = flights({
+	name: "current build map",
+	run: (file) => fetch(file, { cache: "no-cache" }).then((res) => res.ok ? res.json() : null).catch(() => null),
+	keep: (map) => map ? Infinity : 0
+});
 /** A build's island identity (`…/<appDir>/ogygia/og-region.<id>.js`): a name, no file. */
 function is_build_identity(entry) {
 	return absolute(entry).includes("/ogygia/og-region.");
@@ -145,22 +152,11 @@ async function current_location(entry) {
 	const identity = absolute(entry);
 	const file = current_map_file(identity);
 	if (!file) return null;
-	let map = current_maps.get(file);
-	if (!map) {
-		map = fetch(file, { cache: "no-cache" }).then((res) => res.ok ? res.json() : null).catch(() => null);
-		current_maps.set(file, map);
-	}
-	const pairs = await map;
-	if (!pairs) {
-		forget_current_map(file, map);
-		return;
-	}
+	const pairs = await current_maps.get(file);
+	if (!pairs || pairs === STALE) return void 0;
 	for (const name in pairs) if (absolute(name, file) === identity) return absolute(pairs[name], file);
 	return null;
 }
-function forget_current_map(file, map = current_maps.get(file)) {
-	if (current_maps.get(file) === map) current_maps.delete(file);
-}
 /** The host says this file is not there (it does not say so of a file that failed another way). */
 function is_gone(url) {
 	return fetch(url, {
@@ -168,13 +164,6 @@ function is_gone(url) {
 		cache: "no-store"
 	}).then((res) => res.status === 404 || res.status === 410, () => false);
 }
-/** How long a recovery waits before each ask of the current map: a rollover settles in seconds. */
-const RECOVERY_WAITS = [
-	0,
-	1e3,
-	3e3,
-	9e3
-];
 /**
 * The current build's file for a build's identity whose file just failed to load. A deploy's rollover
 * is exactly when this is asked, so an answer that cannot be the current one is asked again while it
@@ -184,12 +173,20 @@ const RECOVERY_WAITS = [
 */
 async function recover_location(entry, failed) {
 	let current;
-	for (const wait of RECOVERY_WAITS) {
-		if (wait) await new Promise((resolve) => setTimeout(resolve, wait));
-		current = await current_location(entry);
-		if (current === void 0) continue;
-		if (current !== failed || !await is_gone(failed)) break;
-		forget_current_map(current_map_file(absolute(entry)));
+	const waits = scope();
+	try {
+		for (let n = 1; n <= rollover.attempts; n++) {
+			if (n > 1) {
+				const wait = backoffAfter(rollover, n - 1);
+				await waits.task(() => new Promise((resolve) => waits.timeout(resolve, wait)));
+			}
+			current = await current_location(entry);
+			if (current === void 0) continue;
+			if (current !== failed || !await is_gone(failed)) break;
+			current_maps.drop(current_map_file(absolute(entry)));
+		}
+	} finally {
+		waits.close();
 	}
 	return current ?? null;
 }
@@ -207,17 +204,11 @@ function import_entry(entry, url = entry_location(entry) ?? entry) {
 	});
 }
 function load_entry(entry, url) {
-	return import(
-		/* @vite-ignore */
-		url
-).catch(async (error) => {
+	return import_file(url).catch(async (error) => {
 		const failed = absolute(url);
 		const current = is_build_identity(entry) ? await recover_location(entry, failed) : absolute(entry);
 		if (!current || current === failed) throw error;
-		const retry = import(
-			/* @vite-ignore */
-			current
-);
+		const retry = import_file(current);
 		const report = (recovered) => fallback_reporter?.({
 			entry,
 			src: url,

package/dist/runtime/foreign-props.d.ts

@@ -1,8 +1 @@
-/**
- * THE MEMBRANE for foreign islands (fragment federation) — a pure module (no DOM, no virtual
- * imports) so it is unit-testable and safe in any bundle. A FOREIGN-origin island's props parse
- * with wire revivers OFF: reviving a wired ref would construct a class instance from THIS
- * build's codec and hand it to ANOTHER build's svelte — the exact live-value crossing the
- * boundary laws forbid. A ref in a foreign sidecar fails HERE, loudly, at the boundary.
- */
 export declare function foreign_region_prop_revivers(): Record<string, (d: never) => unknown>;

package/dist/runtime/foreign-props.js

@@ -1,3 +1,4 @@
+import { OgygiaError } from "../messages/lazy.js";
 // src/runtime/foreign-props.ts
 /**
 * THE MEMBRANE for foreign islands (fragment federation) — a pure module (no DOM, no virtual
@@ -8,7 +9,7 @@
 */
 function foreign_region_prop_revivers() {
 	return { OgygiaRef: () => {
-		throw new Error("[ogygia] a wired class crossed a build boundary: foreign (stitched-fragment) island props must be plain data — wired live objects cannot reunite across two svelte runtimes. Pass the underlying data instead.");
+		throw new OgygiaError("wired_class_foreign");
 	} };
 }
 export { foreign_region_prop_revivers };

package/dist/runtime/form-continuity.d.ts

@@ -4,7 +4,7 @@ export declare function install(): void;
 export declare function snapshot_forms(root: ParentNode, pathKey: string): void;
 /**
  * Arm restoration for `pathKey` on the freshly-connected page. Restores already-hydrated islands
- * immediately and hooks `ogygia:hydrated` for those still waking. Auto-detaches after a short
- * window (the page's islands have all hydrated by then, or never will).
+ * immediately and hooks `ogygia:hydrated` for those still waking, for this page's restore window
+ * (see `restore_window`).
  */
 export declare function arm_form_restore(pathKey: string): void;

package/dist/runtime/form-continuity.js

@@ -1,5 +1,6 @@
 import { element_address, resolve_address } from "./interaction.js";
 import { slots } from "./slots.js";
+import { machine } from "@ogygia/machine";
 // src/runtime/form-continuity.ts
 /**
 * CONTINUITY — ambient island form-field survival across SPA navigation.
@@ -25,9 +26,32 @@ const VALUE_SELECTOR = "input, textarea, select";
 const MAX_PAGES = 20;
 /** pathKey → the fields a visitor changed on that page (in this tab session). */
 const store = /* @__PURE__ */ new Map();
+/**
+* THE RESTORE WINDOW, one per page visit: `open` while a page's saved fields wait for its islands
+* to hydrate. It closes on its own after RESTORE_WINDOW_MS, when the page is left (the next
+* navigation's snapshot), or when another page's restore opens; leaving `open` removes its
+* listeners, so a page's values never reach the next page's islands.
+*/
+const restore_window = machine()({
+	name: "form-restore",
+	initial: "idle",
+	steps: {
+		idle: ["open"],
+		open: ["idle"]
+	},
+	after: { open: {
+		ms: 5e3,
+		to: "idle"
+	} }
+}).create();
+/** The page being left (or another page's restore opening) ends the open window. */
+function close_restore() {
+	if (restore_window.now.kind === "open") restore_window.go("idle");
+}
 const is_checkable = (f) => f.type === "checkbox" || f.type === "radio";
 /** Snapshot changed island fields in `root` under `pathKey`. Call BEFORE the body is swapped out. */
 function snapshot_forms(root, pathKey) {
+	close_restore();
 	const regions = Array.from(root.querySelectorAll("ogygia-region"));
 	const recs = [];
 	regions.forEach((region, ri) => {
@@ -76,10 +100,11 @@ function apply_region(region, ri, recs) {
 }
 /**
 * Arm restoration for `pathKey` on the freshly-connected page. Restores already-hydrated islands
-* immediately and hooks `ogygia:hydrated` for those still waking. Auto-detaches after a short
-* window (the page's islands have all hydrated by then, or never will).
+* immediately and hooks `ogygia:hydrated` for those still waking, for this page's restore window
+* (see `restore_window`).
 */
 function arm_form_restore(pathKey) {
+	close_restore();
 	const recs = store.get(pathKey);
 	if (!recs) return;
 	let regions = Array.from(document.querySelectorAll("ogygia-region"));
@@ -97,11 +122,8 @@ function arm_form_restore(pathKey) {
 		if (ri >= 0) apply_region(region, ri, recs);
 	};
 	const on_answer = () => regions = Array.from(document.querySelectorAll("ogygia-region"));
-	document.addEventListener("ogygia:hydrated", on_hydrated, true);
-	document.addEventListener("ogygia:server", on_answer, true);
-	setTimeout(() => {
-		document.removeEventListener("ogygia:hydrated", on_hydrated, true);
-		document.removeEventListener("ogygia:server", on_answer, true);
-	}, 5e3);
+	restore_window.go("open");
+	restore_window.scope.on(document, "ogygia:hydrated", on_hydrated, true);
+	restore_window.scope.on(document, "ogygia:server", on_answer, true);
 }
 export { arm_form_restore, install, snapshot_forms };

package/dist/runtime/frame-nav.d.ts

@@ -1,3 +1,4 @@
+import { Scope } from "@ogygia/machine";
 /** How the batch that carried `endpoint` timed it, or undefined (it rode no batch). */
 export declare function batch_times(endpoint: string): {
   left: number;
@@ -20,8 +21,13 @@ export declare function read_parcel(buf: string, from: number): Parcel | null;
  * do — all are minted against the app's one islands endpoint, `handle({ endpoint })`, read here off
  * the first URL). Frames apply as they land; the promise resolves when
  * the response ends.
+ *
+ * `visit`: the scope of the page whose holes these are (the page on screen by default; a navigation
+ * hands the next page's, runtime/session.ts `PageVisit`). The batch is its: the visit ending stops
+ * the request and lets go of its body. Every other end lets go of the body too (the end mark, a
+ * stall, a refusal), and the holes it did not carry fetch on their own.
  */
-export declare function streamFrames(endpoints: string[], kind?: "page" | "nav"): Promise<void>;
+export declare function streamFrames(endpoints: string[], kind?: "page" | "nav", visit?: Scope): Promise<void>;
 /**
  * THE PAGE'S HOLES, ONE REQUEST. Holes that start fetching together (the above-the-fold `visible`
  * ones fire in one observer callback; `idle` and media ones in one task) join here

package/dist/runtime/frame-nav.js

@@ -1,7 +1,10 @@
 import { frameAddress } from "../frame.js";
+import { stream } from "../policies.js";
 import { is_idle, release, reserve, ticket, write } from "./frame-store.js";
+import { runtime_session } from "./session.js";
 import { emit } from "../events/bus.js";
 import { beacon_hole_batch_missed } from "./beacon.js";
+import { STALE, machine } from "@ogygia/machine";
 // src/runtime/frame-nav.ts
 const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
 const BEACON = typeof __OGYGIA_BEACON__ !== "undefined" ? __OGYGIA_BEACON__ : true;
@@ -55,6 +58,43 @@ function read_parcel(buf, from) {
 		end
 	};
 }
+/** A batch stream quiet this long is given up, and the holes still waiting on it fetch on their own:
+*  the `stream` policy's deadline (../policies.ts, where its reason lives). */
+const STALL_MS = stream.deadline;
+/**
+* A BATCH STREAM'S LIFE, one machine: `sending` (the POST, until its answer starts), `reading` (each
+* read that brings bytes is a new visit, so the quiet time starts again), `ended`. Quiet for
+* STALL_MS in either, it steps to `stalled` on its own: the request is aborted and every reservation
+* it did not fill is released, as at any other end.
+*/
+const batch_stream = machine()({
+	name: "batch-stream",
+	initial: "sending",
+	steps: {
+		sending: [
+			"reading",
+			"stalled",
+			"ended"
+		],
+		reading: [
+			"reading",
+			"stalled",
+			"ended"
+		],
+		stalled: [],
+		ended: []
+	},
+	after: {
+		sending: {
+			ms: STALL_MS,
+			to: "stalled"
+		},
+		reading: {
+			ms: STALL_MS,
+			to: "stalled"
+		}
+	}
+});
 function sigOf(endpoint) {
 	const q = endpoint.indexOf("?");
 	return q === -1 ? null : new URLSearchParams(endpoint.slice(q + 1)).get("sig");
@@ -64,8 +104,13 @@ function sigOf(endpoint) {
 * do — all are minted against the app's one islands endpoint, `handle({ endpoint })`, read here off
 * the first URL). Frames apply as they land; the promise resolves when
 * the response ends.
+*
+* `visit`: the scope of the page whose holes these are (the page on screen by default; a navigation
+* hands the next page's, runtime/session.ts `PageVisit`). The batch is its: the visit ending stops
+* the request and lets go of its body. Every other end lets go of the body too (the end mark, a
+* stall, a refusal), and the holes it did not carry fetch on their own.
 */
-async function streamFrames(endpoints, kind = "nav") {
+async function streamFrames(endpoints, kind = "nav", visit = runtime_session.visit.scope) {
 	if (!endpoints.length) return;
 	const first = endpoints[0];
 	const q = first.indexOf("?");
@@ -96,31 +141,45 @@ async function streamFrames(endpoints, kind = "nav") {
 	let status = 0;
 	let refused;
 	let final_url;
+	const stream = batch_stream.create();
+	const batch_scope = visit.child();
+	stream.wait("stalled").then((s) => s !== STALE && batch_scope.close());
 	try {
 		let res;
 		try {
-			res = await fetch(path, {
+			res = await stream.scope.task(() => fetch(path, {
 				method: "POST",
 				credentials: "same-origin",
 				headers: { "content-type": "application/json" },
-				body: JSON.stringify(endpoints)
-			});
+				body: JSON.stringify(endpoints),
+				signal: batch_scope.signal
+			}));
 		} catch {
 			return;
 		}
+		if (res === STALE) return;
+		stream.go("reading");
 		status = res.status;
 		if ((DEVTOOLS || BEACON) && res.redirected) {
 			refused = "redirected";
 			final_url = res.url;
 		}
-		if (!res.ok || !res.body) return;
+		if (!res.ok || !res.body) {
+			res.body?.cancel().catch(() => {});
+			return;
+		}
 		const reader = res.body.getReader();
+		batch_scope.defer(() => void reader.cancel().catch(() => {}));
 		const decoder = new TextDecoder();
 		let buffer = "";
 		let parcels = false;
 		for (;;) {
-			const { done, value } = await reader.read();
+			const read = await stream.scope.task(() => reader.read());
+			if (read === STALE) return;
+			const { done, value } = read;
+			if (batch_scope.closed) return;
 			if (done) break;
+			stream.go("reading");
 			buffer += decoder.decode(value, { stream: true });
 			let consumed = 0;
 			for (let p = read_parcel(buffer, 0); p; p = read_parcel(buffer, consumed)) {
@@ -160,8 +219,10 @@ async function streamFrames(endpoints, kind = "nav") {
 			final_url = res.url;
 		}
 	} finally {
+		stream.stop();
+		batch_scope.close();
 		for (const a of reserved) release(a);
-		if (BEACON && delivered < reserved.length) beacon_hole_batch_missed({
+		if (BEACON && delivered < reserved.length && !visit.closed) beacon_hole_batch_missed({
 			sent: reserved.length,
 			delivered,
 			status,
@@ -205,21 +266,26 @@ function join_batch(endpoint) {
 		flushed = new Promise((resolve) => queueMicrotask(() => {
 			const list = queued;
 			queued = null;
-			const fresh = [];
-			const seen = /* @__PURE__ */ new Set();
-			const hinted = /* @__PURE__ */ new Set();
-			for (const l of document.querySelectorAll("link[rel=\"preload\"][as=\"fetch\"]")) if (l.href) hinted.add(l.href);
-			for (const e of list) {
-				const a = frameAddress(e);
-				if (seen.has(a) || hinted.size && hinted.has(new URL(e, document.baseURI).href) || !is_idle(a)) continue;
-				seen.add(a);
-				fresh.push(e);
+			try {
+				gather(list);
+			} finally {
+				resolve();
 			}
-			if (fresh.length >= 2) for (let i = 0; i < fresh.length; i += MAX_BATCH) streamFrames(fresh.slice(i, i + MAX_BATCH), "page");
-			resolve();
 		}));
 	}
 	queued.push(endpoint);
 	return flushed;
 }
+/** The holes that joined in one task: the ones a batch can carry go out in batches of MAX_BATCH. */
+function gather(list) {
+	const fresh = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const e of list) {
+		const a = frameAddress(e);
+		if (seen.has(a) || !is_idle(a)) continue;
+		seen.add(a);
+		fresh.push(e);
+	}
+	if (fresh.length >= 2) for (let i = 0; i < fresh.length; i += MAX_BATCH) streamFrames(fresh.slice(i, i + MAX_BATCH), "page");
+}
 export { batch_times, join_batch, read_parcel, streamFrames };

package/dist/runtime/frame-store.d.ts

@@ -1,10 +1,18 @@
 import { Frame } from "../frame.js";
+import { Stale } from "@ogygia/machine";
 export type FrameFetcher = (signal: AbortSignal) => Promise<string>;
+/** A refused answer nobody asked for yet (the page's early start: ./early-holes.ts), held at its
+ *  address for the first caller that asks there (see `Entry.refused`). Any other failure is not. */
+export declare function hold_refusal(a: string, err: unknown): void;
 /** Applied content for an address, if any. */
 export declare function peek(a: string): {
   v: number;
   html: string;
 } | null;
+/** A renewal at this address answered `fresh`, the capability its elements fetch with from now on. */
+export declare function renew(a: string, fresh: string): void;
+/** The fresh capability a renewal at this address answered, if any. */
+export declare function renewal(a: string): string | null;
 /** Nothing applied and nothing in flight at this address (a batch may take it on). */
 export declare function is_idle(a: string): boolean;
 /** Next request ticket for an address. External channels (streaming, mutations) use this too. */
@@ -16,16 +24,17 @@ export declare function ticket(a: string): number;
 export declare function write(f: Frame): boolean;
 /**
  * Reserve an address whose content is arriving via an EXTERNAL batch stream (single-flight navigation). A region
- * binder that mounts before its frame lands calls `ensure()`, sees this reservation, and JOINS it
+ * binder that mounts before its frame lands calls `ensure()`, finds the batch's flight there, and JOINS it
  * instead of starting its own fetch — so a navigation that pulls N regions makes ONE batch request,
- * not N. `write()` fulfils the reservation when the frame arrives; `release()` fails it if the batch
- * ends without one (the binder then falls back to its own fetch). No-op if content or a fetch is
- * already present.
+ * not N. `write()` fulfils it when the frame arrives; `release()` fails it if the batch ends without
+ * one (the binder then falls back to its own fetch). The flight is the batch's: a binder leaving never
+ * ends it. No-op if content or a fetch is already present.
  */
 export declare function reserve(a: string): void;
 /**
- * Fail an unfulfilled reservation (the batch ended and no frame carried this address). Joined binders
- * reject out of `ensure()` and retry with their own fetch. No-op once content has arrived.
+ * Fail an unfulfilled batch part (the batch ended and no frame was written at this address, by it or
+ * by anyone). Joined binders reject out of `ensure()` and retry with their own fetch. No-op once a
+ * frame has landed (it settled the part).
  */
 export declare function release(a: string): void;
 /** The error a joined reservation rejects with when its batch ended without its frame: the binder's
@@ -42,21 +51,21 @@ export declare function subscribe(a: string, cb: (f: Frame) => void): () => void
  * Ensure an address has content, deduping concurrent callers onto one fetch.
  *
  * - Content already applied (and not `force`): resolves immediately with it.
- * - A fetch is in flight (and not `force`): joins it — N regions, ONE request.
+ * - A fetch (or a batch's part) is in flight (and not `force`): joins it — N regions, ONE request.
  * - Otherwise starts `fetcher` with a fresh ticket; on success the response is WRITTEN (subject to
  *   the staleness check) and the resolved value is whatever the store now holds.
- * - `force` (SWR revalidate) always starts a new fetch; the ticket ordering still guarantees an
- *   older in-flight response can't overwrite it.
+ * - `force` (SWR revalidate) always starts a new fetch, and ends the one out before it: whoever
+ *   waited on that one joins the new one. The ticket ordering still guarantees an older response
+ *   can't overwrite a newer one.
  *
- * Rejections propagate to every joined caller; retry policy stays with the caller (the element).
+ * `signal` is the caller's: when it aborts, this caller alone gets `STALE` at once, and the shared
+ * fetch is aborted only once its LAST caller left — one unmounting element must not kill a fetch
+ * its twin still awaits. Rejections propagate to every joined caller; retry policy stays with the
+ * caller (the element).
  */
 export declare function ensure(a: string, fetcher: FrameFetcher, opts?: {
   force?: boolean;
-}): Promise<string>;
-/**
- * A waiter is leaving (its element disconnected). Aborts the shared fetch only when the LAST
- * waiter leaves — one unmounting element must not kill a fetch its twin still awaits.
- */
-export declare function abandon(a: string): void;
+  signal?: AbortSignal;
+}): Promise<string | Stale>;
 /** Test/HMR hook — drop everything. */
 export declare function _reset(): void;