@jigs.design/server 0.2.0 → 0.3.1

package/dist/core.js

@@ -0,0 +1,722 @@
+import { INTERNAL_MESSAGE, JigsCompileError, JigsError, errorData, fatalDiagnostics, isJigsError } from "./errors.js";
+import { belowPrefix, splitPragma, versionDiagnostics } from "./pragma.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/core.ts
+const DEFAULT_MAX_BODY_BYTES = 1e6;
+/** A small document whose compiled code changes when the compiler's output does. */
+const COMPILER_PROBE = `{@body const [count, setCount] = useState(0)}
+# Probe
+<each of={[1, 2]} as="n">
+{n} {count}
+</each>
+<if test={count > 0}>
+**done**
+</if>`;
+/** 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;
+}
+/** 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`);
+}
+/** An `AbortError`, as `fetch` and other APIs reject with on an aborted signal. */
+function isAbortError(cause) {
+	return cause instanceof Error && cause.name === "AbortError";
+}
+/** A call a policy refused. The procedure stays in the prompt. */
+const denial = (name) => ({ error: {
+	code: "FORBIDDEN",
+	message: `"${name}" is not allowed here`
+} });
+const TOKEN_REFUSALS = {
+	expired: "The confirmation has expired. Try again.",
+	invalid: "The confirmation is not valid for this call.",
+	used: "The confirmation was already used."
+};
+/**
+* The server's confirmer, or null when it has no `secret`. Throws at startup
+* when a mutation's policy is "confirm" and the server cannot sign for it.
+*/
+function confirmerFor(options) {
+	if (options.secret === void 0) {
+		const confirming = Object.entries(options.host.procedures).find(([, procedure]) => procedure.kind === "mutation" && procedure.policy === "confirm");
+		if (confirming !== void 0) throw new Error(`createJigsServer needs a secret and confirmSubject: "${confirming[0]}" asks for confirmation, and its tokens are signed with the secret`);
+		if (options.confirmSubject !== void 0) throw new Error("createJigsServer has confirmSubject but no secret");
+		return null;
+	}
+	if (options.secret.length < 32) throw new Error(`createJigsServer's secret must be at least 32 characters`);
+	if (options.confirmSubject === void 0) throw new Error("createJigsServer has a secret but no confirmSubject: a confirmation token must be bound to who it was issued to");
+	const now = options.now ?? Date.now;
+	return createConfirmer(options.secret, options.confirmations ?? memoryConfirmations(now), now);
+}
+/** FNV-1a, enough to tell versions apart; not a security boundary. */
+function fingerprint(text) {
+	let hash = 2166136261;
+	for (let index = 0; index < text.length; index++) {
+		hash ^= text.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+/** Everything about the host that changes what a source compiles to. */
+function hostFingerprint(host) {
+	return JSON.stringify({
+		catalog: host.components.version,
+		components: host.components.components.map((component) => ({
+			children: component.children,
+			name: component.name,
+			props: Object.entries(component.props).map(([name, definition]) => [
+				name,
+				definition.schema,
+				definition.default ?? null
+			])
+		})),
+		imageHosts: host.imageHosts,
+		procedures: Object.entries(host.procedures).map(([name, procedure]) => ({
+			input: procedure.input === void 0 ? null : z.toJSONSchema(procedure.input),
+			invalidates: procedure.kind === "mutation" ? procedure.invalidates : [],
+			kind: procedure.kind,
+			name,
+			output: procedure.output === void 0 ? null : z.toJSONSchema(procedure.output),
+			projection: procedure.kind === "action" || procedure.kind === "data" || procedure.projection === void 0 ? null : z.toJSONSchema(procedure.projection.schema)
+		})),
+		jigs: host.jigs.map((entry) => [
+			entry.name,
+			splitPragma(entry.source).body,
+			entry.kind,
+			entry.page,
+			entry.tag
+		])
+	});
+}
+/**
+* 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`.
+*/
+function defineRun(procedures, handlers) {
+	return handlers;
+}
+function createJigsServer(options) {
+	const { host } = options;
+	checkMarkdownElements(host.components);
+	for (const [name, procedure] of Object.entries(host.procedures)) if (procedure.kind !== "action" && procedure.kind !== "data" && !Object.hasOwn(options.run, name)) throw new Error(`createJigsServer has no run function for "${name}"`);
+	const confirmer = confirmerFor(options);
+	const checker = createChecker(host);
+	const promptOptions = (mode) => options.instructions === void 0 ? { mode } : {
+		instructions: options.instructions,
+		mode
+	};
+	const documentParts = systemPromptParts(host, promptOptions("document"));
+	const chatParts = systemPromptParts(host, promptOptions("chat"));
+	const system = `${documentParts.stable}\n\n${documentParts.variable}`;
+	const chatSystem = `${chatParts.stable}\n\n${chatParts.variable}`;
+	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 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);
+		} catch {}
+	};
+	const runs = options.run;
+	/** Whether a mutation call may run, by the server's override or else the host. */
+	const policyOf = (name, procedure, input, ctx) => {
+		if (options.policy === void 0) return procedure.policy;
+		try {
+			const policyCall = {
+				ctx,
+				input,
+				name
+			};
+			const decided = options.policy(policyCall);
+			if (decided === void 0) return procedure.policy;
+			if (!isCallPolicy(decided)) throw new Error(`The policy option returned ${String(decided)} for "${name}"; return "allow", "confirm", "deny" or undefined, synchronously`);
+			return decided;
+		} catch (error) {
+			onError(error, {
+				name,
+				type: "call"
+			});
+			return "deny";
+		}
+	};
+	/**
+	* For a mutation whose policy is "confirm": without a token, a new one and
+	* the host's message for the page; with one, null when it is valid for
+	* this call and claimed now, else a refusal.
+	*/
+	const confirmation = async (request, procedure, input, ctx) => {
+		const { name } = request;
+		const refuse = (cause) => {
+			onError(cause, {
+				name,
+				type: "call"
+			});
+			return denial(name);
+		};
+		if (confirmer === null || options.confirmSubject === void 0) return refuse(/* @__PURE__ */ new Error(`The policy for "${name}" is "confirm", but createJigsServer has no secret and confirmSubject to sign a confirmation`));
+		let binding;
+		try {
+			binding = {
+				input,
+				name,
+				subject: options.confirmSubject(ctx)
+			};
+		} catch (error) {
+			return refuse(error);
+		}
+		if (request.confirmation === void 0) {
+			const fallback = `Allow "${name}" to run?`;
+			let message;
+			try {
+				const written = procedure.confirm?.(input);
+				message = written === void 0 ? fallback : confirmMessage(written);
+			} catch (error) {
+				return refuse(error);
+			}
+			if (message === "") message = fallback;
+			const token = await confirmer.issue(binding);
+			return { requiresAction: {
+				message,
+				token
+			} };
+		}
+		let checked;
+		try {
+			checked = await confirmer.check(request.confirmation, binding);
+		} catch (error) {
+			return refuse(error);
+		}
+		if (checked === "ok") return null;
+		return { error: {
+			code: "FORBIDDEN",
+			message: TOKEN_REFUSALS[checked]
+		} };
+	};
+	const dispatch = async (request, context, trace) => {
+		const procedure = Object.hasOwn(host.procedures, request.name) ? host.procedures[request.name] : void 0;
+		const run = procedure?.kind !== "action" && procedure?.kind !== "data" && Object.hasOwn(runs, request.name) ? runs[request.name] : void 0;
+		if (procedure?.kind === "data") return { error: {
+			code: "BAD_INPUT",
+			message: `"${request.name}" is provided data: it is supplied by the page, not fetched`
+		} };
+		if (procedure === void 0 || procedure.kind !== "action" && run === void 0) return { error: {
+			code: "UNKNOWN_PROCEDURE",
+			message: `"${request.name}" is not a query, mutation or action on this host`
+		} };
+		if (request.kind !== procedure.kind) return { error: {
+			code: "BAD_INPUT",
+			message: `"${request.name}" is ${procedure.kind === "action" ? "an" : "a"} ${procedure.kind} on this host, but the call says ${String(request.kind)}`
+		} };
+		let input;
+		if (procedure.input !== void 0) {
+			const parsed = procedure.input.safeParse(request.input);
+			if (!parsed.success) return { error: {
+				code: "BAD_INPUT",
+				message: issuesText(parsed.error)
+			} };
+			input = parsed.data;
+		}
+		trace.input = input;
+		if (procedure.kind === "mutation") {
+			const policy = policyOf(request.name, procedure, input, context.ctx);
+			const gated = policy === "deny" ? denial(request.name) : policy === "confirm" ? await confirmation(request, procedure, input, context.ctx) : null;
+			if (gated !== null) {
+				trace.gate = "requiresAction" in gated ? "requires-action" : "denied";
+				return gated;
+			}
+			if (policy === "confirm") trace.gate = "confirmed";
+		}
+		if (procedure.kind === "action" || run === void 0) return {
+			data: input ?? null,
+			invalidate: []
+		};
+		let result;
+		try {
+			result = await run(input, context);
+		} catch (error) {
+			if (context.signal.aborted || isAbortError(error)) {
+				trace.aborted = true;
+				return { error: errorData(null) };
+			}
+			if (isJigsError(error)) return { error: errorData(error) };
+			onError(error, {
+				name: request.name,
+				type: "call"
+			});
+			return { error: errorData(null) };
+		}
+		let data = null;
+		let output;
+		if (procedure.output !== void 0) {
+			const parsed = procedure.output.safeParse(result);
+			if (!parsed.success) {
+				onError(parsed.error, {
+					name: request.name,
+					type: "call"
+				});
+				return { error: errorData(null) };
+			}
+			output = parsed.data;
+			data = output;
+		}
+		if (procedure.projection !== void 0) {
+			let projected;
+			try {
+				projected = procedure.projection.project(output);
+			} catch (error) {
+				onError(error, {
+					name: request.name,
+					type: "call"
+				});
+				return { error: errorData(null) };
+			}
+			const parsed = procedure.projection.schema.safeParse(projected);
+			if (!parsed.success) {
+				onError(parsed.error, {
+					name: request.name,
+					type: "call"
+				});
+				return { error: errorData(null) };
+			}
+			data = parsed.data;
+		}
+		if (procedure.kind === "query") return { data };
+		const invalidate = invalidationsOf(procedure, input, output, (cause) => {
+			onError(cause, {
+				name: request.name,
+				type: "call"
+			});
+		});
+		return {
+			data,
+			invalidate
+		};
+	};
+	const reportCall = (report) => {
+		if (options.onCall === void 0) return;
+		const failed = (cause) => {
+			onError(cause, {
+				name: report.name,
+				type: report.kind === "page" ? "page" : "call"
+			});
+		};
+		try {
+			Promise.resolve(options.onCall(report)).catch(failed);
+		} catch (error) {
+			failed(error);
+		}
+	};
+	const call = async (request, context) => {
+		const started = performance.now();
+		const trace = {
+			aborted: false,
+			gate: null,
+			input: request.input
+		};
+		const outcome = await dispatch(request, context, trace);
+		const report = {
+			ctx: context.ctx,
+			durationMs: performance.now() - started,
+			input: trace.input,
+			kind: request.kind,
+			name: request.name,
+			outcome: trace.gate ?? "success"
+		};
+		if (trace.aborted) report.outcome = "aborted";
+		else if ("error" in outcome) {
+			report.error = outcome.error;
+			report.outcome = trace.gate === "denied" ? "denied" : "error";
+		}
+		reportCall(report);
+		return outcome;
+	};
+	/** A stored source: its pragma's versions are checked, then its body compiled. */
+	const compileStored = (source, placement = "document") => {
+		const stored = splitPragma(source);
+		const compiled = checker.compile(stored.body);
+		const prefix = source.slice(0, source.length - stored.body.length);
+		return {
+			advice: belowPrefix(compiled.advise(placement), prefix),
+			diagnostics: [...versionDiagnostics(stored.versions, host.components.version), ...belowPrefix(compiled.diagnostics, prefix)],
+			program: compiled.program
+		};
+	};
+	/**
+	* `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 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
+		};
+	};
+	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
+		};
+	};
+	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 {
+			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;
+			throw internal(error, name);
+		}
+		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 {
+			...lookup.strict === true ? strictly(`Page "${name}"`, compiled) : compiled,
+			origin: "saved",
+			source
+		};
+	};
+	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
+			};
+		} catch (error) {
+			if (!isJigsError(error)) onError(error, {
+				name,
+				type: "page"
+			});
+			outcome = { error: errorData(isJigsError(error) ? error : null) };
+		}
+		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";
+		}
+		reportCall(report);
+		return outcome;
+	};
+	/**
+	* 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 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() : 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}"`);
+		headers.set(VERSION_HEADER, version);
+		headers.set("x-content-type-options", "nosniff");
+		if (request?.headers.get("if-none-match") === `"${version}"`) return new Response(null, {
+			headers,
+			status: 304
+		});
+		return new Response(frameHtml, {
+			headers,
+			status: 200
+		});
+	};
+	const contextFor = async (request, type) => {
+		try {
+			return { ctx: await options.context(request) };
+		} catch (error) {
+			if (isJigsError(error)) return { error: errorData(error) };
+			onError(error, { type });
+			return { error: {
+				code: "INTERNAL",
+				message: INTERNAL_MESSAGE
+			} };
+		}
+	};
+	/**
+	* 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: 204
+		});
+	};
+	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: request.signal
+		});
+	};
+	const handlerDeps = {
+		allowedOrigins,
+		call,
+		contextFor,
+		events: eventsRoute,
+		frame,
+		http,
+		maxBodyBytes,
+		onError,
+		page: pageRequest
+	};
+	const data = (name, value) => {
+		const slot = Object.hasOwn(host.procedures, name) ? host.procedures[name] : void 0;
+		if (slot?.kind !== "data") throw new JigsError("BAD_INPUT", `"${name}" is not provided data on this host`);
+		const parsed = slot.output.safeParse(value);
+		if (!parsed.success) throw new JigsError("BAD_INPUT", `"${name}": ${issuesText(parsed.error)}`);
+		return parsed.data;
+	};
+	const core = {
+		call,
+		compile,
+		data,
+		events,
+		frame,
+		handler: createHandler({
+			...handlerDeps,
+			session: restoreOnly
+		}),
+		maxBodyBytes,
+		page,
+		prompt: (mode) => mode === "chat" ? chatSystem : system,
+		promptPrefix: (mode) => mode === "chat" ? chatParts.stable : documentParts.stable,
+		version,
+		withModel: (modelOptions) => createModelServer({
+			checker,
+			context: options.context,
+			handlerDeps,
+			host,
+			onError,
+			prepareSession
+		}, core, modelOptions)
+	};
+	return core;
+}
+//#endregion
+export { createJigsServer, defineRun };