@ogygia/core 0.12.2 → 0.13.0

package/dist/plugin/css.js

@@ -1,6 +1,8 @@
 import { router_css_active, router_css_of } from "../router-css.js";
 import { claim_region_css } from "../context.js";
+import { warn } from "../messages/server.js";
 import { DEV } from "esm-env";
+import { flights } from "@ogygia/machine";
 // src/plugin/css.ts
 /**
 * `ogygia/plugin/css` — the CSS of components a programmatic router renders (see the server-router-css
@@ -14,24 +16,23 @@ import { DEV } from "esm-env";
 * plugin's server realm) — and it is imported on the first call, never at module load.
 */
 const STYLE_CLOSE_G = /<\/style/gi;
-let rcss_ready;
+const registry = flights({
+	name: "router-css registry",
+	run: () => import("virtual:ogygia/router-css")
+});
 let warned_inactive = false;
-function registry_ready() {
-	if (rcss_ready === void 0) try {
-		rcss_ready = import("virtual:ogygia/router-css").catch(() => null);
-	} catch {
-		rcss_ready = null;
-	}
-	return rcss_ready;
-}
 /** Head tags for the components ONE render places (a layout chain + its page or error component):
 *  each component's whole-tree CSS, linked once per request. */
 async function componentCssHead(components) {
-	const ready = registry_ready();
-	const registry = ready ? await ready : null;
-	if (DEV && registry && !warned_inactive && components.length && !router_css_active()) {
+	let read = true;
+	try {
+		await registry.get();
+	} catch {
+		read = false;
+	}
+	if (DEV && read && !warned_inactive && components.length && !router_css_active()) {
 		warned_inactive = true;
-		console.warn("[ogygia] a page rendered outside Kit's routes, but no plugin declared page modules, so its components' CSS is not linked. Using `@ogygia/router`? List `router()` from `@ogygia/router/vite` beside `ogygia()` in vite.config `plugins`.");
+		warn("router_css_inactive");
 	}
 	const entries = components.flatMap((c) => router_css_of(c));
 	if (!entries.length) return "";

package/dist/plugin/facts.d.ts

@@ -36,6 +36,8 @@ export interface RequestFacts {
 export declare function facts_of(request: Request): RequestFacts;
 /** Core only (hooks.ts): how the running code's Request is found. */
 export declare function set_current_request(fn: (() => Request | undefined) | null): void;
+/** The Request the running code belongs to, or undefined outside one (the client, a test). */
+export declare function current_request(): Request | undefined;
 /** The facts of the request the running code belongs to, or null outside one (the client, a test). */
 export declare function current_facts(): RequestFacts | null;
 /** Name the first reason a render is per-visitor (later reasons do not replace it). */

package/dist/plugin/facts.js

@@ -21,17 +21,21 @@ function facts_of(request) {
 function set_current_request(fn) {
 	slot.current = fn;
 }
-/** The facts of the request the running code belongs to, or null outside one (the client, a test). */
-function current_facts() {
+/** The Request the running code belongs to, or undefined outside one (the client, a test). */
+function current_request() {
 	try {
-		const request = slot.current?.();
-		return request ? facts_of(request) : null;
+		return slot.current?.();
 	} catch {
-		return null;
+		return;
 	}
 }
+/** The facts of the request the running code belongs to, or null outside one (the client, a test). */
+function current_facts() {
+	const request = current_request();
+	return request ? facts_of(request) : null;
+}
 /** Name the first reason a render is per-visitor (later reasons do not replace it). */
 function mark_per_visitor(facts, reason) {
 	if (facts.perVisitor === null) facts.perVisitor = reason;
 }
-export { current_facts, facts_of, mark_per_visitor, set_current_request };
+export { current_facts, current_request, facts_of, mark_per_visitor, set_current_request };

package/dist/plugin/hooks.d.ts

@@ -1,18 +1,3 @@
-/**
- * SHARED HOOKS — how plugins (and core) talk to each other: the same way core talks to them. A
- * plugin implements a hook as a method of its server half; anyone calls it through `app`:
- *
- *   app.notify.invalidate(tags)        every implementation runs (resolves when all are done)
- *   app.ask.lastBuild(version)         the first answer that is not `undefined`, in plugin order
- *
- * Nobody implementing a hook is normal: `notify` does nothing, `ask` answers `undefined`. Core owns
- * the common names below; a plugin's own hooks carry its name (`federationThaw`), added by
- * declaration merging:
- *
- *   declare module 'ogygia/plugin' { interface ServerHooks { myThing(x: number): void } }
- *
- * One global slot: every module instance dispatches over the same implementations.
- */
 /** The shared hooks. Each is optional on a plugin; the signature is the contract. */
 export interface ServerHooks {
   /** Drop every stored page carrying any of `tags` (a peer said they are stale). Never re-announced. */
@@ -27,7 +12,12 @@ export interface ServerHooks {
 export declare function register_hooks(impl: object): () => void;
 export type Notify = { [K in keyof ServerHooks]: (...args: Parameters<ServerHooks[K]>) => Promise<void>; };
 export type Ask = { [K in keyof ServerHooks]: (...args: Parameters<ServerHooks[K]>) => Promise<Awaited<ReturnType<ServerHooks[K]>> | undefined>; };
-/** Every implementation of the named hook runs; a failing one is logged, never thrown. */
+/** Every implementation of the named hook runs; a failing one is logged and does not stop the
+ *  others. Once all ran, the notify rejects with what failed (the one error, or an
+ *  AggregateError): "done" and "done, but one could not" are different answers, like the ask's
+ *  (a peer said done for a thaw its store failed to apply, #287). */
 export declare const notify: Notify;
-/** The first implementation that answers something other than `undefined`. */
+/** The first implementation that answers something other than `undefined`. When none answered and
+ *  one threw, the ask throws that error: "nobody knows" and "the one who knows could not say" are
+ *  different answers (a store down once read as "no store", and the deploy thaw was lost, #198). */
 export declare const ask: Ask;

package/dist/plugin/hooks.js

@@ -1,4 +1,21 @@
+import { warn } from "../messages/server.js";
 // src/plugin/hooks.ts
+/**
+* SHARED HOOKS — how plugins (and core) talk to each other: the same way core talks to them. A
+* plugin implements a hook as a method of its server half; anyone calls it through `app`:
+*
+*   app.notify.invalidate(tags)        every implementation runs (resolves when all are done;
+*                                      rejects then if one failed)
+*   app.ask.lastBuild(version)         the first answer that is not `undefined`, in plugin order
+*
+* Nobody implementing a hook is normal: `notify` does nothing, `ask` answers `undefined`. Core owns
+* the common names below; a plugin's own hooks carry its name (`federationThaw`), added by
+* declaration merging:
+*
+*   declare module 'ogygia/plugin' { interface ServerHooks { myThing(x: number): void } }
+*
+* One global slot: every module instance dispatches over the same implementations.
+*/
 const implementations = globalThis[Symbol.for("ogygia.server-hooks.v1")] ??= [];
 /** Core only: a set of hook implementations joins (a plugin's server half, or core's own). Keyed by
 *  identity; returns the leave. */
@@ -10,20 +27,29 @@ function register_hooks(impl) {
 		if (at !== -1) implementations.splice(at, 1);
 	};
 }
-/** Every implementation of the named hook runs; a failing one is logged, never thrown. */
+/** Every implementation of the named hook runs; a failing one is logged and does not stop the
+*  others. Once all ran, the notify rejects with what failed (the one error, or an
+*  AggregateError): "done" and "done, but one could not" are different answers, like the ask's
+*  (a peer said done for a thaw its store failed to apply, #287). */
 const notify = new Proxy({}, { get: (_, name) => async (...args) => {
+	let failed = null;
 	for (const impl of implementations.slice()) {
 		const fn = impl[name];
 		if (typeof fn !== "function") continue;
 		try {
 			await fn.apply(impl, args);
 		} catch (e) {
-			console.warn(`[ogygia] a \`${name}\` hook failed —`, e);
+			warn("plugin_hook_failed", { name }, e);
+			(failed ??= []).push(e);
 		}
 	}
+	if (failed) throw failed.length === 1 ? failed[0] : new AggregateError(failed, `${failed.length} implementations of ${name} failed`);
 } });
-/** The first implementation that answers something other than `undefined`. */
+/** The first implementation that answers something other than `undefined`. When none answered and
+*  one threw, the ask throws that error: "nobody knows" and "the one who knows could not say" are
+*  different answers (a store down once read as "no store", and the deploy thaw was lost, #198). */
 const ask = new Proxy({}, { get: (_, name) => async (...args) => {
+	let failed = null;
 	for (const impl of implementations.slice()) {
 		const fn = impl[name];
 		if (typeof fn !== "function") continue;
@@ -31,8 +57,10 @@ const ask = new Proxy({}, { get: (_, name) => async (...args) => {
 			const answer = await fn.apply(impl, args);
 			if (answer !== void 0) return answer;
 		} catch (e) {
-			console.warn(`[ogygia] a \`${name}\` hook failed —`, e);
+			warn("plugin_hook_failed", { name }, e);
+			failed ??= { error: e };
 		}
 	}
+	if (failed) throw failed.error;
 } });
 export { ask, notify, register_hooks };

package/dist/plugin/index.d.ts

@@ -30,6 +30,10 @@ export interface ServerApp<Options = undefined> {
   /** Record a server-realm event into the current request's devtools stream (a no-op unless
    *  devtools is on for that browser). */
   devtools(event: DevtoolsEventInput): void;
+  /** Keeps `work` alive past the response of the request the running code belongs to: it is handed
+   *  to the platform's `waitUntil` when there is one. Outside a request, or on a platform without
+   *  one, it runs on in the process. Never throws. An outbox's `waitUntil`. */
+  keepAlive(work: Promise<unknown>): void;
   /** Warn once per message, prefixed with the plugin's name. */
   warn(message: string): void;
 }
@@ -112,8 +116,11 @@ export type ServerPlugin<Options = undefined, State = undefined> = Partial<Serve
   /** SEQUENTIAL — the page's response, before it streams out. A Response replaces it. */
   response?(ctx: RequestContext<Options, State>, response: Response): MaybePromise<void | Response>;
   /** PARALLEL — the request's end, always (an answered, failed or streamed request included). Must
-   *  not throw; must not await anything slow. */
-  done?(ctx: RequestContext<Options, State>): void;
+   *  not throw. Work it leaves running that must finish (a send) it returns: the platform's
+   *  `waitUntil` keeps it alive past the response when there is one, and otherwise it runs on by
+   *  itself (a long-running server keeps it alive). The response never waits for it. A failure in
+   *  it never fails the request: say what went wrong yourself. */
+  done?(ctx: RequestContext<Options, State>): void | Promise<void>;
 };
 /** Typed identity: a plugin's server half. */
 export declare function defineServer<Options = undefined, State = undefined>(plugin: ServerPlugin<Options, State>): ServerPlugin<Options, State>;

package/dist/plugin/request-scope.d.ts

@@ -0,0 +1,20 @@
+import { Scope } from "@ogygia/machine";
+/** The owner of `request` (made on first touch). */
+export declare function request_scope(request: Request): Scope;
+/** The owner of the request the running code belongs to, or null outside one. */
+export declare function current_request_scope(): Scope | null;
+/** A value per request: `make` runs the first time a request asks, and what it made is disposed
+ *  when that request ends. Asked after the end, it is made and disposed at once. */
+export declare function request_local<T extends Disposable>(make: (owner: Scope) => T): (request: Request) => T;
+/** Says that a cleanup of a request's work failed (`request_cleanup_failed`, the error after it):
+ *  for an ending nobody waits on, such as a stream source ended as the visitor leaves. */
+export declare function cleanup_failed(error: unknown): void;
+/** Ends a request's owner. A cleanup that throws is said, never thrown: the response is not its. */
+export declare function end_request_scope(owner: Scope): void;
+/**
+ * Core only (the handle): `response` to `request`, whose end ends `owner`. No body, or one the
+ * platform will not read (`body_unread`): it ends now. A body: the response carries it through as
+ * it is, chunk by chunk, and its last chunk read or its cancel ends the owner; the owner ending
+ * first (the visitor left) cancels the body and ends the response.
+ */
+export declare function own_response(owner: Scope, response: Response, request: Request): Response;

package/dist/plugin/request-scope.js

@@ -0,0 +1,149 @@
+import { current_request } from "./facts.js";
+import { warn } from "../messages/server.js";
+import { note_response_end } from "../server/rules.js";
+import { scope } from "@ogygia/machine";
+// src/plugin/request-scope.ts
+/**
+* THE REQUEST'S OWNER — one scope per server request: the timers, streams, readers and fetches the
+* request starts are its, and go when it ends.
+*
+*   const owner = request_scope(event.request);
+*   owner.timeout(give_up, 5000);                     // cleared when the request ends
+*   owner.defer(() => void reader.cancel());          // the reader stops with it
+*   fetch(url, { signal: owner.signal });             // aborted when the visitor leaves
+*
+* It ends at the first of:
+* - the response ends: its body is read to the end, or cancelled (a streamed page included: its
+*   body is the response's, so it ends when the stream does), or it has a body the platform will
+*   not read (a HEAD answer, or a page SvelteKit turns into a 304), which ends at once;
+* - the visitor leaves: `request.signal` aborts.
+*
+* The handle makes it when the request comes in and closes it at the end of the response
+* (`own_response`). Code with no handle around it (a test, a render off-request) still gets one,
+* made on first touch and closed when `request.signal` aborts.
+*
+* A value that lives as long as one request is a `request_local`: made the first time the request
+* asks for it, and let go (disposed) when the request ends. Keyed by the request, like its facts.
+*
+* One global slot, not module scope: a plugin package and core can end up as two module instances
+* of this file (src beside dist, a dual install), and both must find the same owner.
+*/
+const RULES = import.meta.env?.DEV || (typeof __OGYGIA_RULES__ !== "undefined" ? __OGYGIA_RULES__ : false);
+const slot = globalThis[Symbol.for("ogygia.request-scope.v1")] ??= { by_request: /* @__PURE__ */ new WeakMap() };
+function entry_of(request) {
+	let entry = slot.by_request.get(request);
+	if (entry === void 0) {
+		const owner = scope();
+		const signal = request.signal;
+		if (signal.aborted) owner.close();
+		else owner.on(signal, "abort", () => end_request_scope(owner));
+		entry = {
+			owner,
+			locals: null
+		};
+		slot.by_request.set(request, entry);
+	}
+	return entry;
+}
+/** The owner of `request` (made on first touch). */
+function request_scope(request) {
+	return entry_of(request).owner;
+}
+/** The owner of the request the running code belongs to, or null outside one. */
+function current_request_scope() {
+	const request = current_request();
+	return request ? entry_of(request).owner : null;
+}
+/** A value per request: `make` runs the first time a request asks, and what it made is disposed
+*  when that request ends. Asked after the end, it is made and disposed at once. */
+function request_local(make) {
+	const key = {};
+	return (request) => {
+		const entry = entry_of(request);
+		let value = entry.locals?.get(key);
+		if (value === void 0) {
+			value = entry.owner.adopt(make(entry.owner));
+			(entry.locals ??= /* @__PURE__ */ new Map()).set(key, value);
+		}
+		return value;
+	};
+}
+/** Says that a cleanup of a request's work failed (`request_cleanup_failed`, the error after it):
+*  for an ending nobody waits on, such as a stream source ended as the visitor leaves. */
+function cleanup_failed(error) {
+	warn("request_cleanup_failed", error);
+}
+/** Ends a request's owner. A cleanup that throws is said, never thrown: the response is not its. */
+function end_request_scope(owner) {
+	try {
+		owner.close();
+	} catch (error) {
+		cleanup_failed(error);
+	}
+}
+const noop = () => {};
+/**
+* Will the platform answer `request` with `response` without reading its body? A HEAD answer sends
+* none, and SvelteKit turns a 200 whose etag the visitor already has into a 304 after the handle
+* returns, dropping the body (the same match as its respond: a `W/` prefix on the asked etag
+* ignored). Nobody reads or cancels such a body, so its end would never come.
+*/
+function body_unread(request, response) {
+	if (request.method === "HEAD") return true;
+	if (response.status !== 200) return false;
+	const etag = response.headers.get("etag");
+	if (etag === null) return false;
+	let asked = request.headers.get("if-none-match");
+	if (asked?.startsWith("W/\"")) asked = asked.slice(2);
+	return asked === etag;
+}
+/**
+* Core only (the handle): `response` to `request`, whose end ends `owner`. No body, or one the
+* platform will not read (`body_unread`): it ends now. A body: the response carries it through as
+* it is, chunk by chunk, and its last chunk read or its cancel ends the owner; the owner ending
+* first (the visitor left) cancels the body and ends the response.
+*/
+function own_response(owner, response, request) {
+	const body = response.body;
+	if (body === null || owner.closed) {
+		end_request_scope(owner);
+		if (RULES) note_response_end(owner);
+		return response;
+	}
+	if (body_unread(request, response)) {
+		body.cancel().catch(noop);
+		end_request_scope(owner);
+		if (RULES) note_response_end(owner);
+		return response;
+	}
+	const reader = body.getReader();
+	owner.defer(() => void reader.cancel().catch(noop));
+	const carried = new ReadableStream({
+		async pull(controller) {
+			let step;
+			try {
+				step = await reader.read();
+			} catch (error) {
+				end_request_scope(owner);
+				if (RULES) note_response_end(owner);
+				controller.error(error);
+				return;
+			}
+			if (step.done) {
+				controller.close();
+				end_request_scope(owner);
+				if (RULES) note_response_end(owner);
+			} else controller.enqueue(step.value);
+		},
+		cancel() {
+			end_request_scope(owner);
+			if (RULES) note_response_end(owner);
+		}
+	}, { highWaterMark: 0 });
+	return new Response(carried, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+export { cleanup_failed, current_request_scope, end_request_scope, own_response, request_local, request_scope };

package/dist/plugin/server.d.ts

@@ -17,12 +17,30 @@ export interface LivePlugin {
 /** The app's signer, handed in by the handle (it holds the region key, and answers a refused
  *  capability the way it answers a refused region request). */
 export type AppSigner = CapabilitySigner;
-/** Make each plugin live, in order: app, shared hooks, `setup`. */
-export declare function start_plugins(entries: readonly ServerPluginEntry[], signer: AppSigner): LivePlugin[];
+/** Make each plugin live, in order: app, shared hooks, `setup`. `leave` takes their shared hooks out
+ *  again. */
+export declare function start_plugins(entries: readonly ServerPluginEntry[], signer: AppSigner): {
+  plugins: LivePlugin[];
+  leave: () => void;
+};
+/** The app's plugins, live: the handle module's start, each time it runs. The plugins of the run
+ *  before leave first, so only this run's answer `ask` and hear `notify`. */
+export declare function start_app_plugins(entries: readonly ServerPluginEntry[], signer: AppSigner): LivePlugin[];
 /** Two `resolve()` option sets as one: the inner transform (ogygia's document injection) runs first,
  *  the outer (a plugin's `handle`) sees the finished chunk; the other options merge, outer last. */
 export declare function compose_resolve_options(inner?: ResolveOptions, outer?: ResolveOptions): ResolveOptions | undefined;
 /** The plugins' `handle` hooks nested around `core`, first plugin outermost. No hook: `core` itself. */
 export declare function around(plugins: readonly LivePlugin[], core: Handle): Handle;
+/**
+ * The request's end: each plugin's `done`, in order (one that throws does not stop the others), and
+ * the work they leave running (a sink's send, #243):
+ * - the platform keeps a request alive past its response (`platform.context.waitUntil` or
+ *   `platform.ctx.waitUntil`): the work is handed to it;
+ * - otherwise it runs on by itself: a long-running server keeps it alive in the process.
+ *
+ * The visitor's response is never held for it. A failed piece of work never fails the request (the
+ * plugin says what went wrong), and is never an unhandled rejection.
+ */
+export declare function end_request(plugins: readonly LivePlugin[], ctxs: readonly RequestContext<unknown, unknown>[], platform: unknown): void;
 /** The per-plugin contexts of one request. */
 export declare function request_contexts(plugins: readonly LivePlugin[], event: RequestEvent, path: string, facts: RequestFacts, render_hole: (endpoint: string) => Promise<string | null>): RequestContext<unknown, unknown>[];

package/dist/plugin/server.js

@@ -3,35 +3,57 @@ import { ask, notify, register_hooks } from "./hooks.js";
 import { route_config } from "./routes.js";
 import { plugin_capabilities } from "./capability.js";
 import { record_server_event } from "../events/server-registry.js";
+import { warn } from "../messages/server.js";
+import { try_get_request_store } from "@sveltejs/kit/internal/server";
 // src/plugin/server.ts
-/** Make each plugin live, in order: app, shared hooks, `setup`. */
+/** Make each plugin live, in order: app, shared hooks, `setup`. `leave` takes their shared hooks out
+*  again. */
 function start_plugins(entries, signer) {
-	return entries.map(({ name, options, server }) => {
-		const warned = /* @__PURE__ */ new Set();
-		const app = {
-			name,
-			options,
-			notify,
-			ask,
-			facts: facts_of,
-			current: current_facts,
-			sign: signer.sign,
-			verify: signer.verify,
-			capability: plugin_capabilities(name, signer),
-			devtools: record_server_event,
-			warn(message) {
-				if (warned.has(message)) return;
-				warned.add(message);
-				console.warn(`[${name}] ${message}`);
-			}
-		};
-		register_hooks(server);
-		server.setup?.(app);
-		return {
-			def: server,
-			app
-		};
-	});
+	const leaves = [];
+	return {
+		plugins: entries.map(({ name, options, server }) => {
+			const warned = /* @__PURE__ */ new Set();
+			const app = {
+				name,
+				options,
+				notify,
+				ask,
+				facts: facts_of,
+				current: current_facts,
+				sign: signer.sign,
+				verify: signer.verify,
+				capability: plugin_capabilities(name, signer),
+				devtools: record_server_event,
+				keepAlive: keep_alive,
+				warn(message) {
+					if (warned.has(message)) return;
+					warned.add(message);
+					console.warn(`[${name}] ${message}`);
+				}
+			};
+			leaves.push(register_hooks(server));
+			server.setup?.(app);
+			return {
+				def: server,
+				app
+			};
+		}),
+		leave() {
+			for (const leave of leaves) leave();
+		}
+	};
+}
+/** The leave of the app's plugins as the handle module last started them. One global slot, like the
+*  shared hooks themselves: the handle module runs again in dev (an edit runs a plugin's server half
+*  again, and the handle module that imports it), and its new run must not find the old one there. */
+const app_plugins = globalThis[Symbol.for("ogygia.app-plugins.v1")] ??= { leave: null };
+/** The app's plugins, live: the handle module's start, each time it runs. The plugins of the run
+*  before leave first, so only this run's answer `ask` and hear `notify`. */
+function start_app_plugins(entries, signer) {
+	app_plugins.leave?.();
+	const { plugins, leave } = start_plugins(entries, signer);
+	app_plugins.leave = leave;
+	return plugins;
 }
 /** Two `resolve()` option sets as one: the inner transform (ogygia's document injection) runs first,
 *  the outer (a plugin's `handle`) sees the finished chunk; the other options merge, outer last. */
@@ -72,6 +94,54 @@ function around(plugins, core) {
 	}
 	return inner;
 }
+/**
+* The request's end: each plugin's `done`, in order (one that throws does not stop the others), and
+* the work they leave running (a sink's send, #243):
+* - the platform keeps a request alive past its response (`platform.context.waitUntil` or
+*   `platform.ctx.waitUntil`): the work is handed to it;
+* - otherwise it runs on by itself: a long-running server keeps it alive in the process.
+*
+* The visitor's response is never held for it. A failed piece of work never fails the request (the
+* plugin says what went wrong), and is never an unhandled rejection.
+*/
+function end_request(plugins, ctxs, platform) {
+	let left = null;
+	for (let i = 0; i < plugins.length; i++) try {
+		const work = plugins[i].def.done?.(ctxs[i]);
+		if (work) (left ??= []).push(Promise.resolve(work).then(void 0, done_failed));
+	} catch (error) {
+		done_failed(error);
+	}
+	if (left === null) return;
+	const wait_until = wait_until_of(platform);
+	if (wait_until === null) return;
+	try {
+		wait_until(left.length === 1 ? left[0] : Promise.all(left).then(ignore));
+	} catch {}
+}
+function done_failed(error) {
+	warn("plugin_hook_failed", { name: "done" }, error);
+}
+function ignore() {}
+/** `app.keepAlive`: `work` handed to the `waitUntil` of the request the running code belongs to
+*  (Kit's request store knows it, through every await of the request), or left to run on. */
+function keep_alive(work) {
+	const event = try_get_request_store()?.event;
+	const wait_until = wait_until_of(event?.platform);
+	if (wait_until === null) return;
+	try {
+		wait_until(work);
+	} catch {}
+}
+/** The platform's way to keep a request alive past its response, or null. */
+function wait_until_of(platform) {
+	if (typeof platform !== "object" || platform === null) return null;
+	for (const at of ["context", "ctx"]) {
+		const host = platform[at];
+		if (typeof host?.waitUntil === "function") return (work) => host.waitUntil(work);
+	}
+	return null;
+}
 /** The per-plugin contexts of one request. */
 function request_contexts(plugins, event, path, facts, render_hole) {
 	const route_id = event.route?.id;
@@ -89,4 +159,4 @@ function request_contexts(plugins, event, path, facts, render_hole) {
 		perVisitor: per_visitor
 	}));
 }
-export { around, compose_resolve_options, request_contexts, start_plugins };
+export { around, compose_resolve_options, end_request, request_contexts, start_app_plugins, start_plugins };

package/dist/plugin/testing.d.ts

@@ -1,6 +1,12 @@
 import { RequestContext, ServerApp, ServerPlugin } from "./index.js";
 import { clear_route_config, route_config, set_page_route_config } from "./routes.js";
 import { RequestEvent } from "@sveltejs/kit";
+/**
+ * Runs `fn` inside a request, as Kit runs a hook or an endpoint: Kit's request store carries
+ * `event` through every await of it, so `app.keepAlive` finds its platform (a `waitUntil` at
+ * `platform.context` or `platform.ctx`).
+ */
+export declare function inRequest<T>(event: Partial<RequestEvent>, fn: () => T): T;
 export interface StartedPlugin<Options, State> {
   app: ServerApp<Options>;
   /** A request context for `request` (a bare event: url, request, cookies that read nothing). */

package/dist/plugin/testing.js

@@ -3,6 +3,7 @@ import { request_contexts, start_plugins } from "./server.js";
 import { capability_lifetime } from "../server/capability-lifetime.js";
 import { RENEW_WINDOW_SEC } from "../server/shared-cache.js";
 import { clear_route_config, route_config, set_page_route_config } from "./routes.js";
+import { with_request_store } from "@sveltejs/kit/internal/server";
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 // src/plugin/testing.ts
 /** A real HMAC under a key made for this test process. */
@@ -25,8 +26,19 @@ const TEST_SIGNER = {
 		headers: { "x-ogygia-deny": why }
 	})
 };
+/**
+* Runs `fn` inside a request, as Kit runs a hook or an endpoint: Kit's request store carries
+* `event` through every await of it, so `app.keepAlive` finds its platform (a `waitUntil` at
+* `platform.context` or `platform.ctx`).
+*/
+function inRequest(event, fn) {
+	return with_request_store({
+		event,
+		state: {}
+	}, fn);
+}
 function startPlugin(server, { name = "test-plugin", options } = {}) {
-	const [live] = start_plugins([{
+	const { plugins: [live] } = start_plugins([{
 		name,
 		options,
 		server
@@ -51,4 +63,4 @@ function startPlugin(server, { name = "test-plugin", options } = {}) {
 		}
 	};
 }
-export { clear_route_config as clearRouteConfig, route_config as routeConfig, set_page_route_config as setPageRouteConfig, startPlugin };
+export { clear_route_config as clearRouteConfig, inRequest, route_config as routeConfig, set_page_route_config as setPageRouteConfig, startPlugin };

package/dist/policies.d.ts

@@ -0,0 +1,21 @@
+import { Policy } from "@ogygia/machine";
+/** 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. */
+export declare const download: Policy;
+/** 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). */
+export declare const devalue_download: Policy;
+/** 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. */
+export declare const region_fetch: Policy;
+/** 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. */
+export declare const render: Policy;
+/** 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. */
+export declare const stream: Policy;
+/** 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). */
+export declare const rollover: Policy;