@jigs.design/server 0.2.0 → 0.3.0

package/dist/{server.js → core.js}

@@ -1,19 +1,20 @@
-import { INTERNAL_MESSAGE, JigsCompileError, JigsError, errorData, fatalDiagnostics, isJigsError, statusOf } from "./errors.js";
-import { checkMarkdownElements, createChecker } from "./compile.js";
+import { INTERNAL_MESSAGE, JigsCompileError, JigsError, errorData, fatalDiagnostics, isJigsError } from "./errors.js";
 import { belowPrefix, splitPragma, versionDiagnostics } from "./pragma.js";
-import { MAX_CONTENT, messagesSchema, runSession } from "./session.js";
-import { createReplyParser, repairBlock, streamChat } from "./chat.js";
+import { checkMarkdownElements, createChecker } from "./compile.js";
+import { VERSION_HEADER, createHandler, createHttp, issuesText, originOf } from "./handler.js";
+import { MAX_CONTENT, asksModel, parseSessionInput, restoreTurn } from "./session.js";
 import { confirmMessage, createConfirmer, memoryConfirmations } from "./confirm.js";
+import { processCompileCache, sha256 } from "./compile-cache.js";
+import { eventStream } from "./events.js";
 import { invalidationsOf } from "./invalidation.js";
+import { createModelServer } from "./model-server.js";
 import { systemPromptParts } from "@jigs.design/prompt";
 import { isCallPolicy } from "@jigs.design/host";
 import { PROGRAM_FORMAT } from "@jigs.design/protocol";
 import { z } from "zod";
 import { frameDocument, frameSecurityPolicy } from "@jigs.design/runtime/frame";
-//#region src/server.ts
-const VERSION_HEADER = "jigs-version";
+//#region src/core.ts
 const DEFAULT_MAX_BODY_BYTES = 1e6;
-const HEARTBEAT_MS = 15e3;
 /** A small document whose compiled code changes when the compiler's output does. */
 const COMPILER_PROBE = `{@body const [count, setCount] = useState(0)}
 # Probe
@@ -23,62 +24,18 @@ const COMPILER_PROBE = `{@body const [count, setCount] = useState(0)}
 <if test={count > 0}>
 **done**
 </if>`;
-/**
-* The body as text, or null once it passes `max` bytes. Reading stops there,
-* so an oversized body is never held in memory.
-*/
-async function readLimited(request, max) {
-	if (request.body === null) return "";
-	const reader = request.body.getReader();
-	const chunks = [];
-	let size = 0;
-	for (;;) {
-		const chunk = await reader.read();
-		if (chunk.done) break;
-		size += chunk.value.byteLength;
-		if (size > max) {
-			await reader.cancel();
-			return null;
-		}
-		chunks.push(chunk.value);
-	}
-	const bytes = new Uint8Array(size);
-	let offset = 0;
-	for (const chunk of chunks) {
-		bytes.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return new TextDecoder().decode(bytes);
+/** What `resolvePage` must return, checked, since a plain-JavaScript one may not. */
+const savedPageSchema = z.object({ source: z.string() });
+/** The strict rule: an error or warning diagnostic throws. */
+function strictly(subject, compiled) {
+	const fatal = fatalDiagnostics(compiled.diagnostics);
+	if (fatal.length > 0) throw new JigsCompileError(subject, fatal);
+	return compiled;
 }
-/**
-* An origin such as `https://app.example.com`. Throws on anything else,
-* including an entry with no `http:` or `https:` scheme: `localhost:3000`
-* parses as a URL whose origin is `"null"`, the `Origin` that sandboxed
-* frames and `file:` pages send.
-*/
-function originOf(entry) {
-	let url = null;
-	try {
-		url = new URL(entry);
-	} catch {}
-	if (url === null || url.protocol !== "http:" && url.protocol !== "https:" || url.origin === "null") throw new Error(`"${entry}" is not an origin: write its scheme and host, such as https://app.example.com`);
-	return url.origin;
+/** A document page, shipped or saved, takes no props. */
+function noProps(name, props) {
+	if (Object.keys(props).length > 0) throw new JigsError("BAD_INPUT", `"${name}" is a document page, which takes no props`);
 }
-const bodySchema = z.discriminatedUnion("type", [z.object({
-	confirmation: z.string().max(1e3).optional(),
-	input: z.json().optional(),
-	kind: z.enum([
-		"action",
-		"mutation",
-		"query"
-	], { error: "Send the procedure's kind as \"kind\": \"query\", \"mutation\" or \"action\"" }),
-	name: z.string().max(200),
-	type: z.literal("call")
-}), z.object({
-	messages: z.json(),
-	options: z.json().optional(),
-	type: z.literal("session")
-})]);
 /** A call a policy refused. The procedure stays in the prompt. */
 const denial = (name) => ({ error: {
 	code: "FORBIDDEN",
@@ -136,47 +93,16 @@ function hostFingerprint(host) {
 			output: procedure.output === void 0 ? null : z.toJSONSchema(procedure.output),
 			projection: procedure.kind === "action" || procedure.projection === void 0 ? null : z.toJSONSchema(procedure.projection.schema)
 		})),
-		recipes: host.recipes.map((entry) => [entry.name, entry.source])
+		jigs: host.jigs.map((entry) => [
+			entry.name,
+			splitPragma(entry.source).body,
+			entry.kind,
+			entry.page,
+			entry.tag
+		])
 	});
 }
 /**
-* What `jigs.chat` reads from the route besides the request. `blocks` and
-* `prompt` come from the browser, so they are checked like a session's
-* messages.
-*/
-const chatInputSchema = z.object({
-	blocks: z.array(z.object({
-		id: z.string().max(200),
-		source: z.string().max(MAX_CONTENT)
-	})).max(200).optional(),
-	prompt: z.string().max(MAX_CONTENT).optional()
-});
-/**
-* Runs a `safeParse`, with a value nested too deeply to walk reported as a
-* failure instead of a thrown `RangeError`.
-*/
-function parseBounded(parse) {
-	let parsed;
-	try {
-		parsed = parse();
-	} catch {
-		return {
-			message: "The request body is nested too deeply.",
-			success: false
-		};
-	}
-	return parsed.success ? {
-		data: parsed.data,
-		success: true
-	} : {
-		message: issuesText(parsed.error),
-		success: false
-	};
-}
-function issuesText(error) {
-	return error.issues.slice(0, 3).map((issue) => issue.path.length === 0 ? issue.message : `${issue.path.join(".")}: ${issue.message}`).join("; ");
-}
-/**
 * Types a `context` and `run` pair outside `createJigsServer`, so two
 * servers (one per platform) can share them. `TContext` comes from `context`
 * alone, as in `createJigsServer`.
@@ -198,23 +124,20 @@ function createJigsServer(options) {
 	const chatParts = systemPromptParts(host, promptOptions("chat"));
 	const system = `${documentParts.stable}\n\n${documentParts.variable}`;
 	const chatSystem = `${chatParts.stable}\n\n${chatParts.variable}`;
-	/** Tags that mark unfenced Jigs in a chat reply. */
-	const chatTags = /* @__PURE__ */ new Set([...host.components.components.map((component) => component.name), ...host.recipes.map((entry) => entry.name)]);
-	const maxRepairs = options.maxRepairs ?? 1;
-	const programIntervalMs = options.programIntervalMs ?? 250;
-	const designRepair = new Set(options.designRepair ?? []);
 	const allowedOrigins = new Set((options.allowedOrigins ?? []).map((entry) => originOf(entry)));
 	const ownOrigin = options.origin === void 0 ? null : originOf(options.origin);
 	const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
 	const frameHtml = frameDocument();
 	const compilerProbe = checker.compile(COMPILER_PROBE).program.code;
-	const version = fingerprint(JSON.stringify([
+	const fingerprintInput = JSON.stringify([
 		PROGRAM_FORMAT,
 		0,
 		frameHtml,
 		compilerProbe,
 		hostFingerprint(host)
-	]));
+	]);
+	const version = fingerprint(fingerprintInput);
+	const namespace = sha256(fingerprintInput);
 	const onError = (cause, info) => {
 		try {
 			options.onError?.(cause, info);
@@ -392,7 +315,7 @@ function createJigsServer(options) {
 		const failed = (cause) => {
 			onError(cause, {
 				name: report.name,
-				type: "call"
+				type: report.kind === "page" ? "page" : "call"
 			});
 		};
 		try {
@@ -423,26 +346,6 @@ function createJigsServer(options) {
 		reportCall(report);
 		return outcome;
 	};
-	const parseSession = (body) => {
-		const messages = messagesSchema.safeParse(body.messages);
-		if (!messages.success) return { error: {
-			code: "BAD_INPUT",
-			message: `messages: ${issuesText(messages.error)}`
-		} };
-		if (options.options === void 0) return {
-			messages: messages.data,
-			options: void 0
-		};
-		const parsed = options.options.safeParse(body.options ?? {});
-		if (!parsed.success) return { error: {
-			code: "BAD_INPUT",
-			message: `options: ${issuesText(parsed.error)}`
-		} };
-		return {
-			messages: messages.data,
-			options: parsed.data
-		};
-	};
 	/** A stored source: its pragma's versions are checked, then its body compiled. */
 	const compileStored = (source, placement = "document") => {
 		const stored = splitPragma(source);
@@ -454,157 +357,230 @@ function createJigsServer(options) {
 			program: compiled.program
 		};
 	};
-	/** The strict rule: an error or warning diagnostic throws. */
-	const compileStrict = (subject, source, placement) => {
-		const compiled = compileStored(source, placement);
-		const fatal = fatalDiagnostics(compiled.diagnostics);
-		if (fatal.length > 0) throw new JigsCompileError(subject, fatal);
-		return compiled;
-	};
-	const specs = /* @__PURE__ */ new Map();
-	for (const [name, source] of Object.entries(options.specs ?? {})) specs.set(name, compileStrict(`Spec "${name}"`, source).program);
-	const spec = (name) => {
-		const program = specs.get(name);
-		if (program === void 0) throw new Error(`createJigsServer has no spec named "${name}"`);
-		return program;
-	};
-	const compile = async (source, compileOptions) => compileOptions?.strict === false ? compileStored(source, compileOptions.placement) : compileStrict("The source", source, compileOptions?.placement);
-	const sessionDeps = {
-		checker,
-		designRepair,
-		host,
-		kind: "session",
-		maxRepairs,
-		model: options.model,
-		onError,
-		onTurn: options.onTurn,
-		programIntervalMs,
-		system,
-		systemPrefix: documentParts.stable
-	};
-	const serverOrigin = (request) => ownOrigin ?? new URL(request.url).origin;
 	/**
-	* Why a POST is refused before anything runs: an `Origin` that may not
-	* call this server, or a body that is not JSON, which a cross-site form
-	* can send without a preflight. Null when it may go on.
+	* `compile` through the process's cache, keyed by what this server
+	* compiles against, the placement (or "page", for a define page's body,
+	* which compiles against every define jig) and the body's hash. Only
+	* final artifacts come here: a reply's partial sources stay on `checker`.
 	*/
-	const refusal = (request) => {
-		const origin = request.headers.get("origin");
-		if (origin !== null && origin !== serverOrigin(request) && !allowedOrigins.has(origin)) return {
-			code: "FORBIDDEN",
-			message: "This origin may not call this server."
+	const cached = async (placement, body, compile) => {
+		const key = `${await namespace}.${placement}.${await sha256(body)}`;
+		const hit = processCompileCache.get(key);
+		if (hit !== void 0) return hit;
+		const compiled = compile();
+		processCompileCache.set(key, compiled);
+		return compiled;
+	};
+	const compileCached = (source, placement = "document") => cached(placement, source, () => compileStored(source, placement));
+	const jigsByName = new Map(host.jigs.map((entry) => [entry.name, entry]));
+	/** A define page's one-tag body compiled; it throws as `pageBody` does. */
+	const compileDefine = (name, props) => {
+		const compiled = checker.page(name, props);
+		return {
+			advice: compiled.advise("document"),
+			diagnostics: compiled.diagnostics,
+			program: compiled.program
 		};
-		if (!(request.headers.get("content-type") ?? "").toLowerCase().startsWith("application/json")) return {
-			code: "BAD_INPUT",
-			message: "Send the request body as application/json."
+	};
+	const startupPages = /* @__PURE__ */ new Map();
+	for (const entry of host.jigs) {
+		if (!entry.page) continue;
+		const subject = `Jig "${entry.name}"`;
+		if (entry.kind === "document") startupPages.set(entry.name, {
+			...strictly(subject, compileStored(entry.source)),
+			origin: "shipped",
+			source: entry.source
+		});
+		else if (!checker.needsProps(entry.name)) startupPages.set(entry.name, {
+			...strictly(subject, compileDefine(entry.name, {})),
+			origin: "shipped",
+			source: checker.pageBody(entry.name, {})
+		});
+	}
+	/** A page the host lists, compiled strictly. */
+	const shippedPage = async (entry, props) => {
+		const ready = startupPages.get(entry.name);
+		if (entry.kind === "document") noProps(entry.name, props);
+		if (ready !== void 0 && Object.keys(props).length === 0) return ready;
+		const body = checker.pageBody(entry.name, props);
+		const compiled = await cached("page", body, () => compileDefine(entry.name, props));
+		return {
+			...strictly(`Page "${entry.name}"`, compiled),
+			origin: "shipped",
+			source: body
 		};
-		return null;
 	};
-	const chat = async (request, chatOptions) => {
-		const refused = refusal(request);
-		if (refused !== null) throw new JigsError(refused.code, refused.message);
-		let ctx;
+	const internal = (cause, name) => {
+		onError(cause, {
+			name,
+			type: "page"
+		});
+		return new JigsError("INTERNAL", INTERNAL_MESSAGE);
+	};
+	/** The source `resolvePage` finds for `call.ctx`, checked; null when it finds none. */
+	const savedSource = async (name, props, lookup) => {
+		if (options.resolvePage === void 0) return null;
+		let found;
 		try {
-			ctx = await options.context(request);
+			found = await options.resolvePage(name, lookup.signal === void 0 ? { ctx: lookup.ctx } : {
+				ctx: lookup.ctx,
+				signal: lookup.signal
+			});
 		} catch (error) {
 			if (isJigsError(error)) throw error;
-			onError(error, { type: "chat" });
-			throw new JigsError("INTERNAL", INTERNAL_MESSAGE);
-		}
-		const input = parseBounded(() => chatInputSchema.safeParse({
-			blocks: chatOptions?.blocks,
-			prompt: chatOptions?.prompt
-		}));
-		if (!input.success) throw new JigsError("BAD_INPUT", input.message);
-		let turnOptions;
-		if (options.options === void 0) turnOptions = void 0;
-		else {
-			const schema = options.options;
-			const parsed = parseBounded(() => schema.safeParse(chatOptions?.options ?? {}));
-			if (!parsed.success) throw new JigsError("BAD_INPUT", `options: ${parsed.message}`);
-			turnOptions = parsed.data;
+			throw internal(error, name);
 		}
-		const turnCall = {
-			ctx,
-			signal: chatOptions?.signal ?? new AbortController().signal
-		};
-		const repairRounds = Math.max(0, maxRepairs - 1);
-		const parser = createReplyParser({
-			catalogVersion: host.components.version,
-			compile: (body) => checker.compile(body),
-			designRepair,
-			now: () => performance.now(),
-			programIntervalMs,
-			repairs: options.model !== void 0 && maxRepairs > 0,
-			tags: chatTags
-		}, input.data.blocks ?? []);
-		const turnDeps = {
-			call: turnCall,
-			options: turnOptions,
-			parser,
-			prompt: input.data.prompt,
-			session: {
-				...sessionDeps,
-				kind: "chat-repair",
-				maxRepairs: repairRounds
-			}
-		};
-		const repair = (block) => repairBlock(turnDeps, block);
+		if (found === null) return null;
+		const checked = savedPageSchema.safeParse(found);
+		if (!checked.success) throw internal(/* @__PURE__ */ new Error(`resolvePage returned ${String(found)} for "${name}"; return { source } or null`), name);
+		const source = checked.data.source;
+		if (source.length > 2e5) throw internal(/* @__PURE__ */ new Error(`The source resolvePage returned for "${name}" is longer than ${MAX_CONTENT} characters`), name);
+		noProps(name, props);
+		return source;
+	};
+	/** A page `resolvePage` finds for `call.ctx`, compiled leniently unless `strict`. */
+	const savedPage = async (name, props, lookup) => {
+		const source = await savedSource(name, props, lookup);
+		if (source === null) return null;
+		const compiled = await compileCached(source);
 		return {
-			end: parser.end,
-			push: parser.push,
-			repair,
-			results: parser.results,
-			stream: (reply) => streamChat({
-				end: parser.end,
-				push: parser.push,
-				repair
-			}, reply, chatOptions?.signal),
-			system: chatSystem,
-			systemPrefix: chatParts.stable
+			...lookup.strict === true ? strictly(`Page "${name}"`, compiled) : compiled,
+			origin: "saved",
+			source
 		};
 	};
-	async function* session(body, context) {
-		const parsed = parseSession(body);
-		if ("error" in parsed) {
-			yield {
-				error: parsed.error,
-				type: "error"
+	const resolve = async (name, props = {}, lookup) => {
+		const entry = jigsByName.get(name);
+		if (entry?.page === true) return shippedPage(entry, props);
+		if (lookup === void 0 || !("ctx" in lookup)) throw new Error(`createJigsServer has no page named "${name}"`);
+		return entry === void 0 ? savedPage(name, props, lookup) : null;
+	};
+	const page = resolve;
+	const compile = async (source, compileOptions) => {
+		const compiled = await compileCached(source, compileOptions?.placement);
+		return compileOptions?.strict === false ? compiled : strictly("The source", compiled);
+	};
+	/** Whether `pagePolicy` lets this `ctx` read a shipped page; it fails closed. */
+	const pageAllowed = (ctx, name, props) => {
+		if (options.pagePolicy === void 0) return true;
+		try {
+			const decided = options.pagePolicy({
+				ctx,
+				name,
+				props
+			});
+			if (decided !== "allow" && decided !== "deny") throw new Error(`pagePolicy returned ${String(decided)} for "${name}"; return "allow" or "deny", synchronously`);
+			return decided === "allow";
+		} catch (error) {
+			onError(error, {
+				name,
+				type: "page"
+			});
+			return false;
+		}
+	};
+	/**
+	* A page request from the wire, after `context`: `pagePolicy` for a
+	* shipped page, then `page` with `ctx`. A denied page and one no list
+	* has answer alike, so a denial does not say the page exists.
+	*/
+	const pageRequest = async (request, context) => {
+		const started = performance.now();
+		const { name, props } = request;
+		const notFound = {
+			code: "NOT_FOUND",
+			message: `There is no page named "${name}".`
+		};
+		let outcome;
+		let denied = false;
+		const shippedName = name;
+		if (jigsByName.get(name)?.page === true && !pageAllowed(context.ctx, shippedName, props)) {
+			denied = true;
+			outcome = { error: notFound };
+		} else try {
+			const resolved = await page(name, props, context);
+			outcome = resolved === null ? { error: notFound } : {
+				diagnostics: resolved.diagnostics,
+				program: resolved.program,
+				version
 			};
-			return;
+		} catch (error) {
+			if (!isJigsError(error)) onError(error, {
+				name,
+				type: "page"
+			});
+			outcome = { error: errorData(isJigsError(error) ? error : null) };
 		}
-		yield* runSession(sessionDeps, parsed.messages, parsed.options, context);
-	}
-	const tooLarge = (request) => failure(request, {
-		code: "BAD_INPUT",
-		message: `The request body is larger than ${maxBodyBytes} bytes.`
-	});
-	const corsHeaders = (request) => {
-		const headers = new Headers({ [VERSION_HEADER]: version });
-		const origin = request.headers.get("origin");
-		if (origin !== null && allowedOrigins.has(origin)) {
-			headers.set("access-control-allow-origin", origin);
-			headers.set("access-control-allow-credentials", "true");
-			headers.set("access-control-expose-headers", VERSION_HEADER);
-			headers.append("vary", "Origin");
+		const report = {
+			ctx: context.ctx,
+			durationMs: performance.now() - started,
+			input: props,
+			kind: "page",
+			name,
+			outcome: "success"
+		};
+		if ("error" in outcome) {
+			report.error = outcome.error;
+			report.outcome = denied ? "denied" : "error";
 		}
-		return headers;
+		reportCall(report);
+		return outcome;
 	};
-	const json = (request, status, value) => {
-		const headers = corsHeaders(request);
-		headers.set("content-type", "application/json");
-		headers.set("cache-control", "no-store");
-		return new Response(JSON.stringify(value), {
-			headers,
-			status
-		});
+	/**
+	* The source a session opens for a page by name, or null when this
+	* `ctx` has no such page: a shipped page `pagePolicy` allows, as a
+	* self-contained document for a define page, or a saved one. A tag that
+	* is not a page is not one a session may open.
+	*/
+	const pageSource = async (name, props, context) => {
+		const entry = jigsByName.get(name);
+		if (entry === void 0) return savedSource(name, props, context);
+		const shippedName = name;
+		if (!entry.page || !pageAllowed(context.ctx, shippedName, props)) return null;
+		if (entry.kind === "document") {
+			noProps(name, props);
+			return entry.source;
+		}
+		return checker.pageDocument(name, props);
 	};
-	const failure = (request, error) => json(request, statusOf(error.code), { error });
+	const prepareSession = async (body, context) => {
+		const input = parseSessionInput(body);
+		if ("error" in input) return input;
+		const document = input.document;
+		if (document === null || "source" in document) return {
+			document: document?.source ?? null,
+			messages: input.messages
+		};
+		let source;
+		try {
+			source = await pageSource(document.name, document.props ?? {}, context);
+		} catch (error) {
+			if (!isJigsError(error)) onError(error, {
+				name: document.name,
+				type: "page"
+			});
+			return { error: errorData(isJigsError(error) ? error : null) };
+		}
+		if (source === null) return { error: {
+			code: "NOT_FOUND",
+			message: `There is no page named "${document.name}".`
+		} };
+		return {
+			document: source,
+			messages: input.messages
+		};
+	};
+	const http = createHttp({
+		allowedOrigins,
+		ownOrigin,
+		version
+	});
 	const frame = (request) => {
 		const ancestors = ["'self'", ...allowedOrigins].join(" ");
-		const headers = request === void 0 ? new Headers() : corsHeaders(request);
+		const headers = request === void 0 ? new Headers() : http.corsHeaders(request);
 		if (headers.has("access-control-allow-origin")) headers.set("access-control-expose-headers", `${VERSION_HEADER}, content-security-policy`);
 		headers.set("cache-control", "no-cache");
+		headers.append("vary", "Accept");
 		headers.set("content-security-policy", `${frameSecurityPolicy}; frame-ancestors ${ancestors}`);
 		headers.set("content-type", "text/html; charset=utf-8");
 		headers.set("etag", `"${version}"`);
@@ -631,156 +607,94 @@ function createJigsServer(options) {
 			} };
 		}
 	};
-	const stream = (request, events, abort, cleanup) => {
-		const encoder = new TextEncoder();
-		const iterator = events[Symbol.asyncIterator]();
-		let heartbeat;
-		let open = true;
-		const finish = () => {
-			open = false;
-			clearInterval(heartbeat);
-			cleanup();
-		};
-		const body = new ReadableStream({
-			async cancel() {
-				finish();
-				abort.abort();
-				await iterator.return?.();
-			},
-			async pull(controller) {
-				let next;
-				try {
-					next = await iterator.next();
-				} catch (error) {
-					onError(error, { type: "session" });
-					finish();
-					const event = {
-						error: {
-							code: "INTERNAL",
-							message: INTERNAL_MESSAGE
-						},
-						type: "error"
-					};
-					controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-					controller.close();
-					return;
-				}
-				if (next.done === true) {
-					finish();
-					controller.close();
-					return;
-				}
-				controller.enqueue(encoder.encode(`data: ${JSON.stringify(next.value)}\n\n`));
-			},
-			start(controller) {
-				heartbeat = setInterval(() => {
-					if (!open) return;
-					try {
-						controller.enqueue(encoder.encode(": keep-alive\n\n"));
-					} catch {
-						finish();
-					}
-				}, HEARTBEAT_MS);
-			}
-		});
-		const headers = corsHeaders(request);
-		headers.set("content-type", "text/event-stream; charset=utf-8");
-		headers.set("cache-control", "no-store");
-		headers.set("x-accel-buffering", "no");
-		return new Response(body, {
+	/**
+	* A session turn with no model: a document that asks nothing is
+	* compiled again; a turn that would ask the model is not found here.
+	*/
+	const restoreOnly = async (body, context) => {
+		const prepared = await prepareSession(body, context);
+		if ("error" in prepared) return prepared;
+		const document = prepared.document;
+		if (document === null || asksModel(prepared.messages)) return { error: {
+			code: "NOT_FOUND",
+			message: "This server has no model, so it cannot answer a turn that asks one."
+		} };
+		return { async *turn() {
+			yield* restoreTurn(checker, host.components.version, document, true);
+		} };
+	};
+	const hostEvents = options.events;
+	/**
+	* The push stream's answer before `ctx` is needed: a foreign `Origin` is
+	* refused, and a server without `events` says so with `204`. Null when
+	* the stream may open.
+	*/
+	const eventsRefusal = (request) => {
+		const foreign = http.foreignOrigin(request);
+		if (foreign !== null) return http.failure(request, foreign);
+		if (hostEvents !== void 0) return null;
+		const headers = http.corsHeaders(request);
+		headers.append("vary", "Accept");
+		return new Response(null, {
 			headers,
-			status: 200
+			status: 204
 		});
 	};
-	const handler = async (request) => {
-		const origin = request.headers.get("origin");
-		if (request.method === "OPTIONS") {
-			const headers = corsHeaders(request);
-			if (origin !== null && allowedOrigins.has(origin)) {
-				headers.set("access-control-allow-methods", "GET, POST");
-				headers.set("access-control-allow-headers", request.headers.get("access-control-request-headers") ?? "content-type");
-				headers.set("access-control-max-age", "600");
-			}
-			return new Response(null, {
-				headers,
-				status: 204
-			});
-		}
-		if (request.method === "GET") return frame(request);
-		if (request.method !== "POST") {
-			const headers = corsHeaders(request);
-			headers.set("allow", "GET, POST, OPTIONS");
-			return new Response(null, {
-				headers,
-				status: 405
-			});
-		}
-		const refused = refusal(request);
-		if (refused !== null) return failure(request, refused);
-		if (Number(request.headers.get("content-length") ?? "0") > maxBodyBytes) return tooLarge(request);
-		let text;
-		try {
-			text = await readLimited(request, maxBodyBytes);
-		} catch {
-			return failure(request, {
-				code: "BAD_INPUT",
-				message: "The request body could not be read."
-			});
-		}
-		if (text === null) return tooLarge(request);
-		let raw;
-		try {
-			raw = JSON.parse(text);
-		} catch {
-			return failure(request, {
-				code: "BAD_INPUT",
-				message: "The request body is not JSON."
-			});
-		}
-		const body = parseBounded(() => bodySchema.safeParse(raw));
-		if (!body.success) return failure(request, {
-			code: "BAD_INPUT",
-			message: body.message
-		});
-		const context = await contextFor(request, body.data.type === "call" ? "call" : "session");
-		if ("error" in context) return failure(request, context.error);
-		if (body.data.type === "call") {
-			const callRequest = {
-				input: body.data.input,
-				kind: body.data.kind,
-				name: body.data.name
-			};
-			if (body.data.confirmation !== void 0) callRequest.confirmation = body.data.confirmation;
-			const outcome = await call(callRequest, {
-				ctx: context.ctx,
-				signal: request.signal
-			});
-			return json(request, "error" in outcome ? statusOf(outcome.error.code) : 200, outcome);
-		}
-		const parsed = parseSession(body.data);
-		if ("error" in parsed) return failure(request, parsed.error);
-		const abort = new AbortController();
-		const forward = () => abort.abort();
-		if (request.signal.aborted) abort.abort();
-		else request.signal.addEventListener("abort", forward, { once: true });
-		return stream(request, runSession(sessionDeps, parsed.messages, parsed.options, {
+	const events = async (request, context) => {
+		const refused = eventsRefusal(request);
+		if (refused !== null || hostEvents === void 0) return refused ?? new Response(null, { status: 204 });
+		return eventStream({
+			events: hostEvents,
+			http,
+			onError
+		}, request, context);
+	};
+	/** The handler's route for a `GET` that accepts `text/event-stream`. */
+	const eventsRoute = async (request) => {
+		const refused = eventsRefusal(request);
+		if (refused !== null) return refused;
+		const context = await contextFor(request, "events");
+		if ("error" in context) return http.failure(request, context.error);
+		return events(request, {
 			ctx: context.ctx,
-			signal: abort.signal
-		}), abort, () => request.signal.removeEventListener("abort", forward));
+			signal: request.signal
+		});
+	};
+	const handlerDeps = {
+		allowedOrigins,
+		call,
+		contextFor,
+		events: eventsRoute,
+		frame,
+		http,
+		maxBodyBytes,
+		onError,
+		page: pageRequest
 	};
-	return {
+	const core = {
 		call,
-		chat,
 		compile,
+		events,
 		frame,
-		handler,
+		handler: createHandler({
+			...handlerDeps,
+			session: restoreOnly
+		}),
 		maxBodyBytes,
+		page,
 		prompt: (mode) => mode === "chat" ? chatSystem : system,
 		promptPrefix: (mode) => mode === "chat" ? chatParts.stable : documentParts.stable,
-		session,
-		spec,
-		version
+		version,
+		withModel: (modelOptions) => createModelServer({
+			checker,
+			context: options.context,
+			handlerDeps,
+			host,
+			onError,
+			prepareSession
+		}, core, modelOptions)
 	};
+	return core;
 }
 //#endregion
 export { createJigsServer, defineRun };