@ogygia/core 0.0.0 → 0.11.0

package/dist/server/kit-context.js

@@ -0,0 +1,110 @@
+// src/server/kit-context.ts
+/**
+* Kit's request context for ogygia's OWN server render roots.
+*
+* Kit's server `$app/state` answers `page.*` from `getContext('__request__').page` — a Svelte
+* context Kit's page render sets on ITS root. Every `svelte/server` `render()` ogygia starts is a
+* fresh root with no such context: the routeless document (`document()`), the inline island render
+* (`region.ts`), the deferred-region endpoint, snippet bodies. A component reading `page.data`
+* during SSR under any of them crashed with "reading 'page' of undefined". Every such root now
+* passes `kit_render_context()`, which rebuilds Kit's shape from the per-request page snapshot
+* (Region.svelte records it; the handle keeps it in the request bag) or, absent that, from the
+* live request via the reader hooks.ts installs.
+*
+* Isomorphic and dependency-free by design: `region.ts` is in the client graph, so nothing here may
+* import Kit's server internals. The reader rides ONE `globalThis` + `Symbol.for` slot — the
+* PAGE-STATE-SINGLETON law (dist entries can double-evaluate a module).
+*/
+const KIT_REQUEST_CONTEXT = "__request__";
+/** Kit's `$app/stores` server side reads `getContext('__svelte__')` — `{ page, navigating, updated }`
+*  stores Kit's page render sets on ITS root (`render.js`). Same gap as `__request__`: a component
+*  using the (deprecated, still everywhere) `$page` store crashed under every ogygia render root. */
+const KIT_STORES_CONTEXT = "__svelte__";
+const SLOT = Symbol.for("ogygia.kit-context");
+const slots = globalThis[SLOT] ??= {
+	reader: null,
+	event_reader: null
+};
+/** hooks.ts installs the request-scoped reader (page snapshot + live event). */
+function set_kit_page_reader(fn) {
+	slots.reader = fn;
+}
+/** hooks.ts installs the live `RequestEvent` reader — what `requestEvent()` (public, isomorphic)
+*  hands a server island: `locals`, `cookies`, `url`, `request` of the request rendering it. */
+function set_kit_event_reader(fn) {
+	slots.event_reader = fn;
+}
+/** hooks.ts installs the render-page port: in a request rendering for a page it is not (a hole, a
+*  remote call), that page is looked up once (server/page-facts.ts) so the reader answers from it,
+*  and an answer carries the facts its islands read. */
+function set_render_page_port(port) {
+	slots.render_page = port;
+}
+/**
+* Await before an async render root starts: the page this render belongs to, ready for the reader.
+* Inside a page request, on the client, or for a render that reads no `page.data`: nothing to wait for
+* (`undefined`, no microtask).
+*/
+function kit_page_ready(reads_data = null) {
+	return slots.render_page?.ready(reads_data);
+}
+/** Append to a render root's HTML: the page facts its islands read, when it rendered for a page. */
+function kit_page_facts_tail() {
+	return slots.render_page?.tail() ?? "";
+}
+/** Append to a minted hole endpoint: its page version (server/render-page.ts), or `''`. */
+function kit_page_version(hole_id) {
+	return slots.render_page?.version(hole_id) ?? "";
+}
+/** The live event the installed reader answers (null off-request / on the client). */
+function kit_request_event() {
+	return slots.event_reader?.() ?? null;
+}
+/** A page no component can crash on: what a render outside any request sees (tests, tools). */
+function empty_kit_page() {
+	return {
+		url: void 0,
+		params: {},
+		route: { id: null },
+		status: 200,
+		data: {},
+		form: null,
+		error: null,
+		state: {}
+	};
+}
+/** A frozen server-side store: the value is known for the whole render, nothing ever changes it
+*  (Kit's own page render uses `writable`s it never writes after start). Hand-rolled so this
+*  module stays dependency-free for the client graph. */
+function frozen_store(value) {
+	return { subscribe(fn) {
+		fn(value);
+		return () => {};
+	} };
+}
+/** Kit's `__svelte__` context shape: what `getStores()` in `$app/stores` destructures. */
+function kit_stores_context(page) {
+	return {
+		page: frozen_store(page),
+		navigating: frozen_store(null),
+		updated: {
+			...frozen_store(false),
+			check: async () => false
+		}
+	};
+}
+/** The `context` option for a `svelte/server` `render()` ogygia starts. An explicit `page` (the
+*  document root, built from the router's seed) wins; else the request reader; else empty. Both
+*  of Kit's contexts ride along: `__request__` for `$app/state`, `__svelte__` for `$app/stores`.
+*  The `__request__` entry also carries the live `event` (Kit's own render sets `{ page }` only)
+*  — the channel `requestEvent()` reads, so a server island can see its request without importing
+*  `$app/server` (which Kit's client guard rejects the moment a csr=true page shares the layout). */
+function kit_render_context(page, event) {
+	const resolved = page ?? slots.reader?.() ?? empty_kit_page();
+	const live = event ?? slots.event_reader?.() ?? null;
+	return /* @__PURE__ */ new Map([[KIT_REQUEST_CONTEXT, {
+		page: resolved,
+		event: live
+	}], [KIT_STORES_CONTEXT, kit_stores_context(resolved)]]);
+}
+export { KIT_REQUEST_CONTEXT, KIT_STORES_CONTEXT, empty_kit_page, kit_page_facts_tail, kit_page_ready, kit_page_version, kit_render_context, kit_request_event, set_kit_event_reader, set_kit_page_reader, set_render_page_port };

package/dist/server/late-wire.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The LATE WIRE — how a region that resolves after the document flushed reaches the page down the SAME
+ * response. A slot (`<og-late-slot>`, also what `<Region of={promise}>` renders around its placeholder)
+ * sits in the flushed document; each later state rides down as an inert `<template data-og-late>` chunk
+ * that ONE small classic inline script in the head swaps in as it parses. Module scripts don't run until
+ * parsing ENDS, which for a streamed document is the very thing we're not waiting for. After an SPA
+ * navigation the runtime applies remaining templates itself (runtime/router-nav.ts).
+ *
+ * A renderer that delivers late chunks (the server router's streamed document) speaks this format; core
+ * owns it because core's components emit the slots and core's runtime consumes the chunks.
+ */
+/** Wrap html as the swappable slot `id` (display:contents — layout-invisible). */
+export declare function late_slot(id: string, html: string): string;
+/** A late chunk: inert template + nothing else — the boot script (or the runtime, post-SPA-swap)
+ *  performs the swap. Multiple chunks for one slot apply in order (progressive states). */
+export declare function late_chunk(id: string, html: string): string;
+/**
+ * The classic inline boot: observes streamed-in `<template data-og-late>` nodes DURING parse and
+ * swaps each into its slot immediately (stylesheet links hoist to head first so the swap never
+ * paints unstyled). Kept dependency-free and tiny — it must run before any module script can.
+ */
+export declare const LATE_BOOT_SCRIPT: string;

package/dist/server/late-wire.js

@@ -0,0 +1,28 @@
+// src/server/late-wire.ts
+/**
+* The LATE WIRE — how a region that resolves after the document flushed reaches the page down the SAME
+* response. A slot (`<og-late-slot>`, also what `<Region of={promise}>` renders around its placeholder)
+* sits in the flushed document; each later state rides down as an inert `<template data-og-late>` chunk
+* that ONE small classic inline script in the head swaps in as it parses. Module scripts don't run until
+* parsing ENDS, which for a streamed document is the very thing we're not waiting for. After an SPA
+* navigation the runtime applies remaining templates itself (runtime/router-nav.ts).
+*
+* A renderer that delivers late chunks (the server router's streamed document) speaks this format; core
+* owns it because core's components emit the slots and core's runtime consumes the chunks.
+*/
+/** Wrap html as the swappable slot `id` (display:contents — layout-invisible). */
+function late_slot(id, html) {
+	return `<og-late-slot data-og-slot="${id}" style="display:contents">${html}</og-late-slot>`;
+}
+/** A late chunk: inert template + nothing else — the boot script (or the runtime, post-SPA-swap)
+*  performs the swap. Multiple chunks for one slot apply in order (progressive states). */
+function late_chunk(id, html) {
+	return `<template data-og-late="${id}">${html}</template>`;
+}
+/**
+* The classic inline boot: observes streamed-in `<template data-og-late>` nodes DURING parse and
+* swaps each into its slot immediately (stylesheet links hoist to head first so the swap never
+* paints unstyled). Kept dependency-free and tiny — it must run before any module script can.
+*/
+const LATE_BOOT_SCRIPT = "<script data-og-late-boot>(function(){function ap(t){var id=t.getAttribute(\"data-og-late\");var s=document.querySelector('og-late-slot[data-og-slot=\"'+id+'\"]');if(!s){t.remove();return}var c=t.content;var ls=c.querySelectorAll('link[rel=\"stylesheet\"],style');for(var i=0;i<ls.length;i++){var l=ls[i];var h=l.getAttribute&&l.getAttribute(\"href\");if(h&&document.head.querySelector('link[href=\"'+h+'\"]'))l.remove();else document.head.appendChild(l)}while(s.firstChild)s.removeChild(s.firstChild);s.appendChild(c);t.remove()}var mo=new MutationObserver(function(ms){for(var i=0;i<ms.length;i++){var ad=ms[i].addedNodes;for(var j=0;j<ad.length;j++){var n=ad[j];if(n.nodeType===1&&n.tagName===\"TEMPLATE\"&&n.hasAttribute(\"data-og-late\"))ap(n)}}});mo.observe(document.documentElement,{childList:true,subtree:true});addEventListener(\"DOMContentLoaded\",function(){var ts=document.querySelectorAll(\"template[data-og-late]\");for(var i=0;i<ts.length;i++)ap(ts[i]);mo.disconnect()},{once:true});})()<\/script>";
+export { LATE_BOOT_SCRIPT, late_chunk, late_slot };

package/dist/server/page-facts.d.ts

@@ -0,0 +1,25 @@
+/** Marks ogygia's own lookup: the handle answers it without setting up a page render. */
+export declare const PAGE_FACTS_HEADER = "x-ogygia-page-facts";
+/** The route id and params Kit matched for the looked-up page (the data alone carries neither). */
+export declare const PAGE_FACTS_ROUTE_HEADER = "x-ogygia-page-route";
+export type PageFacts = {
+  url: URL;
+  params: Record<string, string | undefined>;
+  route: {
+    id: string | null;
+  };
+  data: Record<string, unknown>;
+};
+type Decoders = Record<string, (value: unknown) => unknown>;
+type Fetch = (input: string, init?: RequestInit) => Promise<Response>;
+/** Kit's data URL for a page, as its client builds it: the data suffix on the path, the page's
+ *  search kept, the trailing-slash marker when the path ends in `/`. */
+export declare function data_url_of(page: URL): string;
+/**
+ * The page's facts, or a reason they are not available (a redirect, an error, a load that threw,
+ * not a Kit data answer). `decoders`: the app's `transport` decoders, as Kit's client uses them.
+ */
+export declare function look_up_page(page: URL, fetch: Fetch, decoders: Decoders): Promise<PageFacts | {
+  miss: string;
+}>;
+export {};

package/dist/server/page-facts.js

@@ -0,0 +1,138 @@
+import * as devalue from "devalue";
+// src/server/page-facts.ts
+/**
+* PAGE FACTS — the page a render outside its page belongs to (internal/notes/region-page-context.md).
+*
+* A hole renders in the islands endpoint's request, a region refreshed by a remote `query` /
+* `command` in the remote call's: no page render around them, so no `page.data`. Their page is the
+* same-origin `Referer`, and its data is looked up through Kit itself — the data request Kit's own
+* client makes on a navigation (`<page>/__data.json`). The app's handle chain and the page's server
+* loads run with the visitor's cookies: the facts are the server's, for this visitor, now; nothing
+* the browser could forge or that a cache could have kept from someone else.
+*
+* Cheap by construction: the caller looks up only when a render reads `page.data`, once per request;
+* only the answer's FIRST line is waited for (a streamed promise in the data resolves later, in the
+* background, without holding the render); no regex.
+*/
+/** Marks ogygia's own lookup: the handle answers it without setting up a page render. */
+const PAGE_FACTS_HEADER = "x-ogygia-page-facts";
+/** The route id and params Kit matched for the looked-up page (the data alone carries neither). */
+const PAGE_FACTS_ROUTE_HEADER = "x-ogygia-page-route";
+/** Kit's data URL for a page, as its client builds it: the data suffix on the path, the page's
+*  search kept, the trailing-slash marker when the path ends in `/`. */
+function data_url_of(page) {
+	const u = new URL(page.href);
+	u.hash = "";
+	const p = page.pathname;
+	u.pathname = p.endsWith(".html") ? p.slice(0, -5) + ".html__data.json" : (p.endsWith("/") ? p.slice(0, -1) : p) + "/__data.json";
+	if (p.endsWith("/")) u.searchParams.append("x-sveltekit-trailing-slash", "1");
+	return u.href;
+}
+/**
+* The page's facts, or a reason they are not available (a redirect, an error, a load that threw,
+* not a Kit data answer). `decoders`: the app's `transport` decoders, as Kit's client uses them.
+*/
+async function look_up_page(page, fetch, decoders) {
+	let res;
+	try {
+		res = await fetch(data_url_of(page), { headers: { [PAGE_FACTS_HEADER]: "1" } });
+	} catch (e) {
+		return { miss: `the data request failed (${String(e?.message ?? e)})` };
+	}
+	if (!res.ok || !res.body) {
+		res.body?.cancel().catch(() => {});
+		return { miss: `the data request answered ${res.status}` };
+	}
+	const reader = res.body.getReader();
+	const text = new TextDecoder();
+	let buf = "";
+	let nl = -1;
+	while ((nl = buf.indexOf("\n")) === -1) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buf += text.decode(value, { stream: true });
+	}
+	const first = nl === -1 ? buf : buf.slice(0, nl);
+	const rest = nl === -1 ? "" : buf.slice(nl + 1);
+	const stop = (miss) => {
+		reader.cancel().catch(() => {});
+		return { miss };
+	};
+	let head;
+	try {
+		head = JSON.parse(first);
+	} catch {
+		return stop("the answer is not Kit data");
+	}
+	if (head?.type === "redirect") return stop(`a load redirected to ${head.location}`);
+	if (head?.type !== "data" || !Array.isArray(head.nodes)) return stop("the answer is not Kit data");
+	const deferreds = /* @__PURE__ */ new Map();
+	const revive = (flat) => devalue.unflatten(flat, {
+		...decoders,
+		Promise: (id) => {
+			const p = new Promise((fulfil, reject) => deferreds.set(id, {
+				fulfil,
+				reject
+			}));
+			p.catch(() => {});
+			return p;
+		}
+	});
+	const data = {};
+	try {
+		for (const node of head.nodes) {
+			if (node?.type === "error") return stop("a load threw");
+			if (node?.type === "data") Object.assign(data, revive(node.data));
+		}
+	} catch (e) {
+		return stop(`its data did not decode (${String(e?.message ?? e)})`);
+	}
+	if (deferreds.size) settle_streamed(reader, text, rest, deferreds, revive);
+	else reader.cancel().catch(() => {});
+	let route = { id: null };
+	let params = {};
+	const named = res.headers.get(PAGE_FACTS_ROUTE_HEADER);
+	if (named) try {
+		const r = JSON.parse(decodeURIComponent(named));
+		route = { id: r.id ?? null };
+		params = r.params ?? {};
+	} catch {}
+	return {
+		url: page,
+		params,
+		route,
+		data
+	};
+}
+/** The streamed promises in the page's data, fulfilled as their lines arrive (Kit's `chunk` lines). */
+async function settle_streamed(reader, text, buf, deferreds, revive) {
+	const line = (raw) => {
+		if (!raw) return;
+		try {
+			const chunk = JSON.parse(raw);
+			if (chunk.type !== "chunk" || chunk.id === void 0) return;
+			const d = deferreds.get(chunk.id);
+			if (!d) return;
+			deferreds.delete(chunk.id);
+			if (chunk.error !== void 0) d.reject(revive(chunk.error));
+			else d.fulfil(revive(chunk.data));
+		} catch {}
+	};
+	try {
+		for (;;) {
+			let nl;
+			while ((nl = buf.indexOf("\n")) !== -1) {
+				line(buf.slice(0, nl));
+				buf = buf.slice(nl + 1);
+			}
+			if (!deferreds.size) break;
+			const { done, value } = await reader.read();
+			if (done) break;
+			buf += text.decode(value, { stream: true });
+		}
+		line(buf);
+	} catch {} finally {
+		reader.cancel().catch(() => {});
+	}
+}
+export { PAGE_FACTS_HEADER, PAGE_FACTS_ROUTE_HEADER, data_url_of, look_up_page };

package/dist/server/page-seed.d.ts

@@ -0,0 +1,33 @@
+import { stringify } from "devalue";
+type PageLike = {
+  url?: {
+    href?: string;
+  };
+  params?: Record<string, string>;
+  route?: {
+    id: string | null;
+  };
+  status?: number;
+  data?: unknown;
+  form?: unknown;
+  error?: unknown;
+};
+/** The seed's text and the lane it is in (`json` → the runtime reads it with `JSON.parse`). */
+export interface SeedText {
+  text: string;
+  json: boolean;
+}
+export declare class PageSeed {
+  /**
+   * Public page slice for islands. url/params/route/status are always plain and MUST survive;
+   * data/form/error may carry a non-serializable leaf (function/store/class) — that ONE field is
+   * dropped, never the whole seed. Promises should already be resolved by the handle
+   * (`resolve_promises`) before this. See INVARIANTS.md · PAGE-SEED.
+   *
+   * `json`: the caller proved the whole slice JSON-exact (seed-refs.ts `analyze`) — then the seed
+   * goes out as native `JSON.stringify` output (an order of magnitude cheaper than devalue on a
+   * CMS tree), escaped once for the `<script>`. devalue output needs no escape (it writes `<`).
+   */
+  static serialize(page_ref: PageLike, stringify_fn?: typeof stringify, json?: boolean): SeedText | null;
+}
+export {};

package/dist/server/page-seed.js

@@ -0,0 +1,60 @@
+import { escape_script_text } from "../escape.js";
+import { stringify } from "devalue";
+// src/server/page-seed.ts
+/** Serialize a Kit `page` snapshot for a single document-level ogygia side-channel. */
+var PageSeed = class {
+	/**
+	* Public page slice for islands. url/params/route/status are always plain and MUST survive;
+	* data/form/error may carry a non-serializable leaf (function/store/class) — that ONE field is
+	* dropped, never the whole seed. Promises should already be resolved by the handle
+	* (`resolve_promises`) before this. See INVARIANTS.md · PAGE-SEED.
+	*
+	* `json`: the caller proved the whole slice JSON-exact (seed-refs.ts `analyze`) — then the seed
+	* goes out as native `JSON.stringify` output (an order of magnitude cheaper than devalue on a
+	* CMS tree), escaped once for the `<script>`. devalue output needs no escape (it writes `<`).
+	*/
+	static serialize(page_ref, stringify_fn = stringify, json = false) {
+		try {
+			const base = {
+				url: page_ref.url?.href,
+				params: page_ref.params,
+				route: page_ref.route,
+				status: page_ref.status
+			};
+			const full = {
+				...base,
+				data: page_ref.data,
+				form: page_ref.form ?? null,
+				error: page_ref.error ?? null
+			};
+			if (json) try {
+				return {
+					text: escape_script_text(JSON.stringify(full)),
+					json: true
+				};
+			} catch {}
+			let raw;
+			try {
+				raw = stringify_fn(full);
+			} catch {
+				const safe = { ...base };
+				for (const key of [
+					"data",
+					"form",
+					"error"
+				]) try {
+					stringify_fn(full[key]);
+					safe[key] = full[key];
+				} catch {}
+				raw = stringify_fn(safe);
+			}
+			return {
+				text: raw,
+				json: false
+			};
+		} catch {
+			return null;
+		}
+	}
+};
+export { PageSeed };

package/dist/server/page-stream.d.ts

@@ -0,0 +1,55 @@
+/** A THENABLE, not just a native Promise — Kit wraps streamed load promises, so `instanceof Promise`
+ *  would miss them. Anything with a callable `.then` we can await. */
+export declare const is_thenable: (v: unknown) => v is PromiseLike<unknown>;
+/** Serializable stand-in for a pending promise leaf (streaming path). Encodes to its id. */
+export declare class DeferRef {
+  readonly id: number;
+  constructor(id: number);
+}
+/** Serializable stand-in for an already-settled promise leaf (non-navigate path). Encodes to
+ *  `[ok, value]`; the client revives it as a resolved/rejected Promise. */
+export declare class SettledRef {
+  readonly ok: boolean;
+  readonly value: unknown;
+  constructor(ok: boolean, value: unknown);
+}
+export declare const defer_reducer: Record<string, (v: unknown) => unknown>;
+export declare const page_seed_reducers: Record<string, (v: unknown) => unknown>;
+export type Deferred = {
+  id: number;
+  promise: PromiseLike<unknown>;
+};
+/**
+ * Replace every promise in `value` with a {@link DeferRef}, returning the promise-free clone plus the
+ * deferred promises (id + promise to await). Plain objects/arrays are cloned; class instances and
+ * primitives pass through untouched. Ids continue from `start_id` so `data` and `form` share one id
+ * space across the whole seed. Bounded depth guards a pathological structure.
+ */
+export declare function stage_deferred(value: unknown, start_id?: number): {
+  staged: unknown;
+  deferred: Deferred[];
+  next_id: number;
+};
+/**
+ * Non-navigate (SPA/router) fallback: deep-await every promise in `value`, wrapping each ORIGINAL
+ * promise position in a {@link SettledRef} (resolved OR rejected — a rejection is caught, never
+ * thrown, so the render can't crash). Nested promises inside a resolved value are settled too. The
+ * client revives each SettledRef as a resolved/rejected Promise, so `page.data.x` stays a Promise on
+ * this path exactly as on the streaming path, and `{#await …:catch}` works.
+ */
+export declare function settle_deferred(value: unknown, depth?: number): Promise<unknown>;
+/**
+ * The streamed resolve `<script>` body for one settled promise. The value is encoded WITH
+ * {@link defer_reducer} so a re-staged value carrying nested DeferRef markers (a promise that resolved
+ * to a value containing further promises) serializes — the client revives those as fresh pending
+ * promises that later resolve scripts settle, exactly like Kit's recursive deferral. `ok=false` carries
+ * a normalized `{ message }` (matches the page seed's error shape) so a rejected non-serializable value
+ * can't blow up the stream. `<` is escaped so the payload can't break out of the `<script>`.
+ */
+export declare function resolve_script(global_name: string, id: number, settled: {
+  ok: boolean;
+  value: unknown;
+}, reducers?: Record<string, (v: unknown) => unknown>): string;
+export declare function normalize_error(err: unknown): {
+  message: string;
+};

package/dist/server/page-stream.js

@@ -0,0 +1,121 @@
+import { PAGE_DEFER_KEY, PAGE_SETTLED_KEY } from "../page-defer.js";
+import { escape_script_text } from "../escape.js";
+import { stringify } from "devalue";
+// src/server/page-stream.ts
+/**
+* Server side of streaming `$page.data` promises into islands (see `../page-defer.ts` for the why).
+*
+* `stage_deferred` walks the captured page `data`/`form`, swaps every promise for a serializable
+* DEFER MARKER, and hands back the promise-free clone plus the promises to await. The clone goes into
+* the page seed (each marker becomes a real pending Promise on the client); as each promise settles we
+* stream a `<script>__ogygia_page_resolve(id, ok, encoded)<\/script>` chunk that resolves it live.
+*/
+const MAX_DEPTH = 64;
+/** A THENABLE, not just a native Promise — Kit wraps streamed load promises, so `instanceof Promise`
+*  would miss them. Anything with a callable `.then` we can await. */
+const is_thenable = (v) => !!v && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+/** Serializable stand-in for a pending promise leaf (streaming path). Encodes to its id. */
+var DeferRef = class {
+	id;
+	constructor(id) {
+		this.id = id;
+	}
+};
+/** Serializable stand-in for an already-settled promise leaf (non-navigate path). Encodes to
+*  `[ok, value]`; the client revives it as a resolved/rejected Promise. */
+var SettledRef = class {
+	ok;
+	value;
+	constructor(ok, value) {
+		this.ok = ok;
+		this.value = value;
+	}
+};
+const defer_reducer = { [PAGE_DEFER_KEY]: (v) => v instanceof DeferRef ? [v.id] : void 0 };
+const page_seed_reducers = {
+	[PAGE_DEFER_KEY]: (v) => v instanceof DeferRef ? [v.id] : void 0,
+	[PAGE_SETTLED_KEY]: (v) => v instanceof SettledRef ? [v.ok, v.value] : void 0
+};
+/**
+* Replace every promise in `value` with a {@link DeferRef}, returning the promise-free clone plus the
+* deferred promises (id + promise to await). Plain objects/arrays are cloned; class instances and
+* primitives pass through untouched. Ids continue from `start_id` so `data` and `form` share one id
+* space across the whole seed. Bounded depth guards a pathological structure.
+*/
+function stage_deferred(value, start_id = 0) {
+	const deferred = [];
+	let id = start_id;
+	const walk = (v, depth) => {
+		if (is_thenable(v)) {
+			const ref = new DeferRef(id++);
+			deferred.push({
+				id: ref.id,
+				promise: v
+			});
+			return ref;
+		}
+		if (depth > MAX_DEPTH) return v;
+		if (Array.isArray(v)) return v.map((x) => walk(x, depth + 1));
+		if (v && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype) {
+			const out = {};
+			for (const k in v) out[k] = walk(v[k], depth + 1);
+			return out;
+		}
+		return v;
+	};
+	return {
+		staged: walk(value, 0),
+		deferred,
+		next_id: id
+	};
+}
+/**
+* Non-navigate (SPA/router) fallback: deep-await every promise in `value`, wrapping each ORIGINAL
+* promise position in a {@link SettledRef} (resolved OR rejected — a rejection is caught, never
+* thrown, so the render can't crash). Nested promises inside a resolved value are settled too. The
+* client revives each SettledRef as a resolved/rejected Promise, so `page.data.x` stays a Promise on
+* this path exactly as on the streaming path, and `{#await …:catch}` works.
+*/
+async function settle_deferred(value, depth = 0) {
+	if (is_thenable(value)) try {
+		return new SettledRef(true, await settle_deferred(await value, depth + 1));
+	} catch (err) {
+		return new SettledRef(false, normalize_error(err));
+	}
+	if (depth > MAX_DEPTH) return value;
+	if (Array.isArray(value)) return Promise.all(value.map((x) => settle_deferred(x, depth + 1)));
+	if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+		const out = {};
+		await Promise.all(Object.keys(value).map(async (k) => {
+			out[k] = await settle_deferred(value[k], depth + 1);
+		}));
+		return out;
+	}
+	return value;
+}
+/**
+* The streamed resolve `<script>` body for one settled promise. The value is encoded WITH
+* {@link defer_reducer} so a re-staged value carrying nested DeferRef markers (a promise that resolved
+* to a value containing further promises) serializes — the client revives those as fresh pending
+* promises that later resolve scripts settle, exactly like Kit's recursive deferral. `ok=false` carries
+* a normalized `{ message }` (matches the page seed's error shape) so a rejected non-serializable value
+* can't blow up the stream. `<` is escaped so the payload can't break out of the `<script>`.
+*/
+function resolve_script(global_name, id, settled, reducers = defer_reducer) {
+	let ok = settled.ok;
+	let encoded;
+	try {
+		encoded = stringify(ok ? settled.value : normalize_error(settled.value), reducers);
+	} catch {
+		encoded = stringify({ message: "ogygia: streamed value is not serializable" });
+		ok = false;
+	}
+	const json = escape_script_text(JSON.stringify(encoded));
+	return `<script>${global_name}(${id},${ok},${json})<\/script>`;
+}
+function normalize_error(err) {
+	if (err instanceof Error) return { message: err.message };
+	if (err && typeof err === "object" && "message" in err) return { message: String(err.message) };
+	return { message: String(err) };
+}
+export { DeferRef, SettledRef, defer_reducer, is_thenable, normalize_error, page_seed_reducers, resolve_script, settle_deferred, stage_deferred };

package/dist/server/payload.d.ts

@@ -0,0 +1,6 @@
+export declare class B64Url {
+  /** @param str utf-8 string */
+  static encode(str: string): string;
+  /** @param b64 base64url string (decoded only after its MAC verified) */
+  static decode(b64: string): string;
+}

package/dist/server/payload.js

@@ -0,0 +1,22 @@
+// src/server/payload.ts
+const NodeBuffer = globalThis.Buffer;
+var B64Url = class {
+	/** @param str utf-8 string */
+	static encode(str) {
+		if (NodeBuffer) return NodeBuffer.from(str, "utf8").toString("base64url");
+		const bytes = new TextEncoder().encode(str);
+		let bin = "";
+		for (const b of bytes) bin += String.fromCharCode(b);
+		return btoa(bin).replaceAll("=", "").replaceAll("+", "-").replaceAll("/", "_");
+	}
+	/** @param b64 base64url string (decoded only after its MAC verified) */
+	static decode(b64) {
+		if (NodeBuffer) return NodeBuffer.from(b64, "base64url").toString("utf8");
+		const norm = b64.replaceAll("-", "+").replaceAll("_", "/");
+		const bin = atob(norm);
+		const bytes = new Uint8Array(bin.length);
+		for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+		return new TextDecoder().decode(bytes);
+	}
+};
+export { B64Url };

package/dist/server/personal-response.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A page made for ONE browser — its devtools events (hooks.ts), the profiler's beacon (profiler/), the
+ * switch's Set-Cookie — must never reach a shared cache, whatever `cache-control` the app set: a CDN that
+ * keeps HTML would hand that browser's page to every visitor.
+ */
+export declare function mark_personal(response: Response): void;

package/dist/server/personal-response.js

@@ -0,0 +1,13 @@
+// src/server/personal-response.ts
+/**
+* A page made for ONE browser — its devtools events (hooks.ts), the profiler's beacon (profiler/), the
+* switch's Set-Cookie — must never reach a shared cache, whatever `cache-control` the app set: a CDN that
+* keeps HTML would hand that browser's page to every visitor.
+*/
+function mark_personal(response) {
+	try {
+		response.headers.set("cache-control", "private, no-store");
+		response.headers.append("vary", "Cookie");
+	} catch {}
+}
+export { mark_personal };