@ogygia/core 0.0.0 → 0.11.1

package/dist/runtime/drift-watch.d.ts

@@ -0,0 +1,9 @@
+/** A region kept its server copy: watch until it wakes (pair with {@link unwatch_region}). */
+export declare function watch_region(): void;
+/** A region woke (or left): stop watching once none sleeps. */
+export declare function unwatch_region(): void;
+/** The region's copy is stale (it left the document while it slept): compare it at the wake. */
+export declare function mark_region_changed(region: Element): void;
+/** Was anything in this region's markup touched since it kept its copy? Read at the wake, BEFORE the
+ *  runtime itself edits the island (lakes lifted): the pending records are taken first. */
+export declare function region_changed(region: Element): boolean;

package/dist/runtime/drift-watch.js

@@ -0,0 +1,60 @@
+import { walk_enters } from "./ownership.js";
+// src/runtime/drift-watch.ts
+/**
+* WHICH SLEEPING ISLANDS WERE TOUCHED. An island keeps its server markup from its first connect and,
+* at its wake, used to parse that copy and walk it against the live DOM (hydrate-core
+* `repair_if_drifted`) — every island, though almost always nothing had touched it: two thirds of
+* Svelte's own hydrate time on a page of heavy islands, measured. One `MutationObserver` over the
+* document now marks an island CHANGED when a node or a text in it changes (the comparison ignores
+* attributes, and so does this); the wake runs the comparison, and the repair, only for a changed
+* one. Nothing is decided by timing: the wake takes the observer's pending records first.
+*
+* The observer runs only while some island sleeps with a copy (a page whose islands are all awake
+* pays nothing for later DOM work). An island that leaves the document while it sleeps is marked
+* changed: nothing watched it meanwhile. A browser without MutationObserver: every island compares,
+* as before.
+*/
+const REGION = "ogygia-region";
+const changed = /* @__PURE__ */ new WeakSet();
+let observer = null;
+let sleeping = 0;
+const supported = typeof MutationObserver !== "undefined";
+function mark(records) {
+	for (const r of records) {
+		let hidden = false;
+		for (let n = r.target; n; n = n.parentNode) {
+			if (n.nodeType !== 1) continue;
+			const el = n;
+			if (el.localName === REGION && !hidden) changed.add(el);
+			if (!hidden && !walk_enters(el)) hidden = true;
+		}
+	}
+}
+/** A region kept its server copy: watch until it wakes (pair with {@link unwatch_region}). */
+function watch_region() {
+	if (!supported || ++sleeping > 1) return;
+	observer ??= new MutationObserver(mark);
+	observer.observe(document.documentElement, {
+		childList: true,
+		characterData: true,
+		subtree: true
+	});
+}
+/** A region woke (or left): stop watching once none sleeps. */
+function unwatch_region() {
+	if (!supported || sleeping === 0 || --sleeping > 0) return;
+	if (observer) mark(observer.takeRecords());
+	observer?.disconnect();
+}
+/** The region's copy is stale (it left the document while it slept): compare it at the wake. */
+function mark_region_changed(region) {
+	changed.add(region);
+}
+/** Was anything in this region's markup touched since it kept its copy? Read at the wake, BEFORE the
+*  runtime itself edits the island (lakes lifted): the pending records are taken first. */
+function region_changed(region) {
+	if (!supported) return true;
+	if (observer && sleeping > 0) mark(observer.takeRecords());
+	return changed.has(region);
+}
+export { mark_region_changed, region_changed, unwatch_region, watch_region };

package/dist/runtime/entry-locations.d.ts

@@ -0,0 +1,33 @@
+/** A load that fell back to its identity: who hears about it (the runtime registers the devtools
+ *  and beacon reporter at boot). This module imports nothing: app code (a portable snippet) uses it
+ *  too, and must not pull the runtime's reporting into the app's chunks. */
+export type EntryFallbackReport = {
+  entry: string;
+  src: string;
+  recovered: boolean;
+};
+export declare function on_entry_fallback(reporter: (report: EntryFallbackReport) => void): void;
+/** Remember where an entry is served from. `base`: the document the pair was read from. */
+export declare function note_entry_location(entry: string | null | undefined, src: string | null | undefined, base?: string): void;
+/** The known location of an entry, or undefined. */
+export declare function entry_location(entry: string, base?: string): string | undefined;
+/**
+ * PIN A REGION'S URLS TO THE PAGE THAT WROTE THEM. With Kit's default `paths.relative`, the server
+ * writes `entry` / `src` / `endpoint` relative to the page it rendered (`../../_app/immutable/…`,
+ * `../../__ogygia__?…`), and every reader resolves them against `location.href`. A region that stays
+ * on the page through a client navigation (Kit's, or the router's) then resolved them against the
+ * NEW address: its island imported `/a/b/_app/…` (a redirect to an HTML page), and a hole's key
+ * changed with the depth of the page, so a swap kept the old region beside the new one. Resolved
+ * once, where the address is still the right one — the element's connect, and a fetched document
+ * against its own URL — they read the same on every page. Same origin only (a federated entry stays
+ * as written); an absolute or root-absolute value is already pinned.
+ */
+export declare function pin_region_urls(el: Element, base?: string): void;
+/** An island element's identity, its location noted on the way (the one read every loader uses). */
+export declare function island_entry_of(el: Element): string | null;
+/**
+ * Import an entry: its location when known, else `url` (what the caller resolved for the identity);
+ * the location failing, once, the identity fetched fresh — so an island on a page that outlived its
+ * build still wakes, on the current code. No location known → the error stands.
+ */
+export declare function import_entry<T>(entry: string, url?: string): Promise<T>;

package/dist/runtime/entry-locations.js

@@ -0,0 +1,119 @@
+// src/runtime/entry-locations.ts
+/**
+* ENTRY IDENTITY → LOCATION, the browser's half (server/entry-location.ts is the server's).
+*
+* An island's `entry` is its IDENTITY: the stable URL every key uses (the island graph, the
+* fingerprint, the devtools' names). The file to import is its LOCATION — content-hashed, so an
+* `immutable` cache never serves a stale one. The server writes it beside the identity: the region
+* element's `src`, and the island graph's `s` map for an entry no element carries (a portable
+* snippet's). Every loader resolves through `island_module_url` (region-endpoint-url.ts), which asks
+* here first: the location once one is known, else the identity (the dev server, or a page from
+* before hashing — whose stable name is a shim that reaches the current build).
+*/
+/** absolute identity → absolute location */
+const locations = /* @__PURE__ */ new Map();
+let fallback_reporter = null;
+function on_entry_fallback(reporter) {
+	fallback_reporter = reporter;
+}
+/** Resolved URLs by base + url: every wake, warm and graph read asks again for the same few
+*  entries, and each ask was a `new URL()` parse (bounded: cleared past a few thousand). */
+const resolved_urls = /* @__PURE__ */ new Map();
+function absolute(url, base) {
+	const b = base ?? location.href;
+	const key = b + "\n" + url;
+	const hit = resolved_urls.get(key);
+	if (hit !== void 0) return hit;
+	let out;
+	try {
+		out = new URL(url, b).href;
+	} catch {
+		out = url;
+	}
+	if (resolved_urls.size > 4e3) resolved_urls.clear();
+	resolved_urls.set(key, out);
+	return out;
+}
+/** Remember where an entry is served from. `base`: the document the pair was read from. */
+function note_entry_location(entry, src, base) {
+	if (!entry || !src || src === entry) return;
+	locations.set(absolute(entry, base), absolute(src, base));
+}
+/** The known location of an entry, or undefined. */
+function entry_location(entry, base) {
+	return locations.size ? locations.get(absolute(entry, base)) : void 0;
+}
+/** The region attributes that hold a URL: its identity, its location, its hole's endpoint. */
+const REGION_URL_ATTRS = [
+	"entry",
+	"src",
+	"endpoint"
+];
+/**
+* PIN A REGION'S URLS TO THE PAGE THAT WROTE THEM. With Kit's default `paths.relative`, the server
+* writes `entry` / `src` / `endpoint` relative to the page it rendered (`../../_app/immutable/…`,
+* `../../__ogygia__?…`), and every reader resolves them against `location.href`. A region that stays
+* on the page through a client navigation (Kit's, or the router's) then resolved them against the
+* NEW address: its island imported `/a/b/_app/…` (a redirect to an HTML page), and a hole's key
+* changed with the depth of the page, so a swap kept the old region beside the new one. Resolved
+* once, where the address is still the right one — the element's connect, and a fetched document
+* against its own URL — they read the same on every page. Same origin only (a federated entry stays
+* as written); an absolute or root-absolute value is already pinned.
+*/
+function pin_region_urls(el, base) {
+	for (const name of REGION_URL_ATTRS) {
+		const value = el.getAttribute(name);
+		if (!value || !(value.startsWith("./") || value.startsWith("../"))) continue;
+		let url;
+		try {
+			url = new URL(absolute(value, base));
+		} catch {
+			continue;
+		}
+		if (url.origin === location.origin) el.setAttribute(name, url.pathname + url.search + url.hash);
+	}
+}
+/** An island element's identity, its location noted on the way (the one read every loader uses). */
+function island_entry_of(el) {
+	const entry = el.getAttribute("entry");
+	if (entry) note_entry_location(entry, el.getAttribute("src"));
+	return entry;
+}
+/**
+* The identity itself, past every cache: what a load falls back to when its location failed (a page
+* a cache kept outlived the build that made it, and that build's files are gone). The stable name
+* is a shim of the CURRENT build's file; the query makes the browser fetch it fresh rather than the
+* copy an `immutable` cache may hold. Null when no location was known (nothing to fall back to).
+*/
+function fresh_identity_url(entry, base) {
+	if (!entry_location(entry, base)) return null;
+	const identity = absolute(entry, base);
+	return identity + (identity.includes("?") ? "&" : "?") + "og-fresh=" + Date.now().toString(36);
+}
+/**
+* Import an entry: its location when known, else `url` (what the caller resolved for the identity);
+* the location failing, once, the identity fetched fresh — so an island on a page that outlived its
+* build still wakes, on the current code. No location known → the error stands.
+*/
+function import_entry(entry, url = entry_location(entry) ?? entry) {
+	const loaded = import(
+		/* @vite-ignore */
+		url
+);
+	const fresh = fresh_identity_url(entry);
+	if (!fresh) return loaded;
+	return loaded.catch(() => {
+		const retry = import(
+			/* @vite-ignore */
+			fresh
+);
+		const report = (recovered) => fallback_reporter?.({
+			entry,
+			src: url,
+			recovered
+		});
+		retry.then(() => report(true), () => report(false));
+		return retry;
+	});
+}
+export { entry_location, import_entry, island_entry_of, note_entry_location, on_entry_fallback, pin_region_urls };

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

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,14 @@
+// src/runtime/foreign-props.ts
+/**
+* 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.
+*/
+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.");
+	} };
+}
+export { foreign_region_prop_revivers };

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

@@ -0,0 +1,10 @@
+/** Feature entry: enable form-field survival across SPA nav (unless the build disabled it). */
+export declare function install(): void;
+/** Snapshot changed island fields in `root` under `pathKey`. Call BEFORE the body is swapped out. */
+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).
+ */
+export declare function arm_form_restore(pathKey: string): void;

package/dist/runtime/form-continuity.js

@@ -0,0 +1,107 @@
+import { element_address, resolve_address } from "./interaction.js";
+import { slots } from "./slots.js";
+// src/runtime/form-continuity.ts
+/**
+* CONTINUITY — ambient island form-field survival across SPA navigation.
+*
+* Leaving a page, every island input whose value differs from its SSR default is snapshotted into a
+* tab-session store, keyed by the page's path + a positional address (nth region + child-index path,
+* the same addressing `interaction` uses, because hydration can replace nodes). Returning to that
+* page, each field is restored when its island (re)hydrates, with `input`/`change` fired so `bind:`
+* syncs. Session-scoped: survives navigation and back/forward, dies with the tab, never persisted.
+*
+* Only DIFFS are stored (default → nothing), bounded page count, so this stays cheap.
+*/
+/** Feature entry: enable form-field survival across SPA nav (unless the build disabled it). */
+function install() {
+	if (!(typeof __OGYGIA_CONTINUITY_FORMS__ !== "undefined" ? __OGYGIA_CONTINUITY_FORMS__ : true)) return;
+	slots.forms = {
+		enabled: true,
+		snapshot: snapshot_forms,
+		restore: arm_form_restore
+	};
+}
+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();
+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) {
+	const regions = Array.from(root.querySelectorAll("ogygia-region"));
+	const recs = [];
+	regions.forEach((region, ri) => {
+		for (const el of region.querySelectorAll(VALUE_SELECTOR)) {
+			const f = el;
+			if (f.closest("[data-ogygia-no-keep]")) continue;
+			if (!(is_checkable(f) ? f.checked !== f.defaultChecked : f.value !== f.defaultValue)) continue;
+			const addr = element_address(region, el);
+			if (!addr) continue;
+			recs.push({
+				region: ri,
+				addr,
+				tag: el.tagName,
+				value: f.value,
+				checked: is_checkable(f) ? f.checked : void 0
+			});
+		}
+	});
+	if (recs.length) {
+		store.delete(pathKey);
+		store.set(pathKey, recs);
+		while (store.size > MAX_PAGES) store.delete(store.keys().next().value);
+	} else store.delete(pathKey);
+}
+function apply_region(region, ri, recs) {
+	for (const r of recs) {
+		if (r.region !== ri) continue;
+		const el = resolve_address(region, r.addr);
+		if (!el || el.tagName !== r.tag) continue;
+		const f = el;
+		let changed = false;
+		if (r.checked !== void 0) {
+			if (f.checked !== r.checked) {
+				f.checked = r.checked;
+				changed = true;
+			}
+		} else if (f.value !== r.value) {
+			f.value = r.value;
+			changed = true;
+		}
+		if (changed) {
+			f.dispatchEvent(new Event("input", { bubbles: true }));
+			f.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+	}
+}
+/**
+* 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).
+*/
+function arm_form_restore(pathKey) {
+	const recs = store.get(pathKey);
+	if (!recs) return;
+	let regions = Array.from(document.querySelectorAll("ogygia-region"));
+	regions.forEach((region, ri) => {
+		if (region.hasAttribute("data-hydrated")) apply_region(region, ri, recs);
+	});
+	const on_hydrated = (e) => {
+		const region = e.target;
+		if (!(region instanceof Element) || region.localName !== "ogygia-region") return;
+		let ri = regions.indexOf(region);
+		if (ri < 0) {
+			regions = Array.from(document.querySelectorAll("ogygia-region"));
+			ri = regions.indexOf(region);
+		}
+		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);
+}
+export { arm_form_restore, install, snapshot_forms };

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

@@ -0,0 +1,36 @@
+/** How the batch that carried `endpoint` timed it, or undefined (it rode no batch). */
+export declare function batch_times(endpoint: string): {
+  left: number;
+  at: number;
+  size: number;
+} | undefined;
+type Parcel = {
+  slot: string;
+  html: string;
+  end: number;
+};
+/**
+ * The next whole parcel in `buf` from `from` (server/stream-regions.ts), or `null` when it has not
+ * fully arrived yet. A plain parcel ends at the first `</template>` (the server length-frames any
+ * answer carrying one of its own); a length-framed one is exactly `data-og-len` characters.
+ */
+export declare function read_parcel(buf: string, from: number): Parcel | null;
+/**
+ * Stream a batch of region calls into the frame store. Endpoints must share an endpoint path (they
+ * 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.
+ */
+export declare function streamFrames(endpoints: string[], kind?: "page" | "nav"): 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
+ * and, at the end of that task, go out as ONE batch — reserved in the store first, so each hole's
+ * own fetch then JOINS its address instead of starting a request. One request instead of N: one pass
+ * through the app's handle chain (its session lookup, its auth) instead of N, and no per-hole slot in
+ * the browser's own few-at-a-time gate. A lone hole goes out on its own (a GET, as before); so does
+ * any hole the batch does not deliver (release → its fetch runs). Resolves when the batch is on its
+ * way, never with its content.
+ */
+export declare function join_batch(endpoint: string): Promise<void>;
+export {};

package/dist/runtime/frame-nav.js

@@ -0,0 +1,225 @@
+import { frameAddress } from "../frame.js";
+import { is_idle, release, reserve, ticket, write } from "./frame-store.js";
+import { emit } from "../events/bus.js";
+import { beacon_hole_batch_missed } from "./beacon.js";
+// src/runtime/frame-nav.ts
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+const BEACON = typeof __OGYGIA_BEACON__ !== "undefined" ? __OGYGIA_BEACON__ : true;
+/** this page's batches, numbered (the devtools join a batch's parts and its end to it) */
+let batch_seq = 0;
+/** A batched hole's timing, for the hole's own report of its answer (beacon `holes_answered`): the
+*  batch left at `left`, this hole's part landed at `at` (page time), `size` holes rode it. Bounded:
+*  the newest 64 endpoints (the measuring browser only). */
+const batched = /* @__PURE__ */ new Map();
+/** How the batch that carried `endpoint` timed it, or undefined (it rode no batch). */
+function batch_times(endpoint) {
+	return batched.get(endpoint);
+}
+const STREAM_DONE_SLOT = "__ogygia_done__";
+const OPEN = "<template data-ogygia-slot=\"";
+const LEN = "\" data-og-len=\"";
+const CLOSE = "</template>";
+/**
+* The next whole parcel in `buf` from `from` (server/stream-regions.ts), or `null` when it has not
+* fully arrived yet. A plain parcel ends at the first `</template>` (the server length-frames any
+* answer carrying one of its own); a length-framed one is exactly `data-og-len` characters.
+*/
+function read_parcel(buf, from) {
+	const open = buf.indexOf(OPEN, from);
+	if (open === -1) return null;
+	const slot_at = open + 28;
+	const quote = buf.indexOf("\"", slot_at);
+	if (quote === -1) return null;
+	const slot = buf.slice(slot_at, quote);
+	if (buf.startsWith("\">", quote)) {
+		const close = buf.indexOf(CLOSE, quote + 2);
+		if (close === -1) return null;
+		return {
+			slot,
+			html: buf.slice(quote + 2, close),
+			end: close + 11
+		};
+	}
+	if (!buf.startsWith(LEN, quote)) return buf.length - quote < 15 ? null : read_parcel(buf, slot_at);
+	let i = quote + 15;
+	let len = 0;
+	for (let c = buf.charCodeAt(i); c >= 48 && c <= 57; c = buf.charCodeAt(++i)) len = len * 10 + (c - 48);
+	if (i + 2 > buf.length) return null;
+	if (!buf.startsWith("\">", i)) return read_parcel(buf, slot_at);
+	const start = i + 2;
+	const end = start + len + 11;
+	if (end > buf.length) return null;
+	return {
+		slot,
+		html: buf.slice(start, start + len),
+		end
+	};
+}
+function sigOf(endpoint) {
+	const q = endpoint.indexOf("?");
+	return q === -1 ? null : new URLSearchParams(endpoint.slice(q + 1)).get("sig");
+}
+/**
+* Stream a batch of region calls into the frame store. Endpoints must share an endpoint path (they
+* 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.
+*/
+async function streamFrames(endpoints, kind = "nav") {
+	if (!endpoints.length) return;
+	const first = endpoints[0];
+	const q = first.indexOf("?");
+	const path = q === -1 ? first : first.slice(0, q);
+	const bySig = /* @__PURE__ */ new Map();
+	const endpoint_of = DEVTOOLS || BEACON ? /* @__PURE__ */ new Map() : null;
+	const reserved = [];
+	for (const e of endpoints) {
+		const s = sigOf(e);
+		if (s) {
+			const a = frameAddress(e);
+			bySig.set(s, a);
+			endpoint_of?.set(s, e);
+			reserved.push(a);
+			reserve(a);
+		}
+	}
+	const batch = DEVTOOLS ? ++batch_seq : 0;
+	if (DEVTOOLS) emit({
+		domain: "runtime",
+		name: "region.batch.sent",
+		batch,
+		kind,
+		endpoints: endpoints.slice()
+	});
+	const left = BEACON ? performance.now() : 0;
+	let delivered = 0;
+	let status = 0;
+	let refused;
+	let final_url;
+	try {
+		let res;
+		try {
+			res = await fetch(path, {
+				method: "POST",
+				credentials: "same-origin",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(endpoints)
+			});
+		} catch {
+			return;
+		}
+		status = res.status;
+		if ((DEVTOOLS || BEACON) && res.redirected) {
+			refused = "redirected";
+			final_url = res.url;
+		}
+		if (!res.ok || !res.body) return;
+		const reader = res.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let parcels = false;
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let consumed = 0;
+			for (let p = read_parcel(buffer, 0); p; p = read_parcel(buffer, consumed)) {
+				consumed = p.end;
+				parcels = true;
+				if (p.slot === STREAM_DONE_SLOT) return;
+				const a = bySig.get(p.slot);
+				if (a) {
+					if (BEACON) {
+						const ep = endpoint_of.get(p.slot);
+						batched.delete(ep);
+						batched.set(ep, {
+							left,
+							at: performance.now(),
+							size: reserved.length
+						});
+						if (batched.size > 64) batched.delete(batched.keys().next().value);
+					}
+					write({
+						a,
+						v: ticket(a),
+						html: p.html
+					});
+					delivered++;
+					if (DEVTOOLS) emit({
+						domain: "runtime",
+						name: "region.batch.part",
+						batch,
+						endpoint: endpoint_of.get(p.slot)
+					});
+				}
+			}
+			if (consumed) buffer = buffer.slice(consumed);
+		}
+		if ((DEVTOOLS || BEACON) && !parcels && !refused) {
+			refused = "document";
+			final_url = res.url;
+		}
+	} finally {
+		for (const a of reserved) release(a);
+		if (BEACON && delivered < reserved.length) beacon_hole_batch_missed({
+			sent: reserved.length,
+			delivered,
+			status,
+			...refused ? {
+				refused,
+				...final_url ? { final_url } : {}
+			} : {},
+			endpoints
+		});
+		if (DEVTOOLS) emit({
+			domain: "runtime",
+			name: "region.batch.done",
+			batch,
+			sent: reserved.length,
+			delivered,
+			status,
+			...refused ? {
+				refused,
+				...final_url ? { final_url } : {}
+			} : {}
+		});
+	}
+}
+/** The server renders at most this many calls per batch (hooks.ts `render_batch`). */
+const MAX_BATCH = 32;
+let queued = null;
+let flushed = Promise.resolve();
+/**
+* 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
+* and, at the end of that task, go out as ONE batch — reserved in the store first, so each hole's
+* own fetch then JOINS its address instead of starting a request. One request instead of N: one pass
+* through the app's handle chain (its session lookup, its auth) instead of N, and no per-hole slot in
+* the browser's own few-at-a-time gate. A lone hole goes out on its own (a GET, as before); so does
+* any hole the batch does not deliver (release → its fetch runs). Resolves when the batch is on its
+* way, never with its content.
+*/
+function join_batch(endpoint) {
+	if (!queued) {
+		queued = [];
+		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);
+			}
+			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;
+}
+export { batch_times, join_batch, read_parcel, streamFrames };