@jigs.design/server 0.2.0 → 0.3.1

package/dist/server.js

@@ -1,786 +0,0 @@
-import { INTERNAL_MESSAGE, JigsCompileError, JigsError, errorData, fatalDiagnostics, isJigsError, statusOf } from "./errors.js";
-import { checkMarkdownElements, createChecker } from "./compile.js";
-import { belowPrefix, splitPragma, versionDiagnostics } from "./pragma.js";
-import { MAX_CONTENT, messagesSchema, runSession } from "./session.js";
-import { createReplyParser, repairBlock, streamChat } from "./chat.js";
-import { confirmMessage, createConfirmer, memoryConfirmations } from "./confirm.js";
-import { invalidationsOf } from "./invalidation.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";
-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
-<each of={[1, 2]} as="n">
-{n} {count}
-</each>
-<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);
-}
-/**
-* 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;
-}
-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",
-	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.projection === void 0 ? null : z.toJSONSchema(procedure.projection.schema)
-		})),
-		recipes: host.recipes.map((entry) => [entry.name, entry.source])
-	});
-}
-/**
-* 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`.
-*/
-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" && !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}`;
-	/** 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([
-		PROGRAM_FORMAT,
-		0,
-		frameHtml,
-		compilerProbe,
-		hostFingerprint(host)
-	]));
-	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" && Object.hasOwn(runs, request.name) ? runs[request.name] : void 0;
-		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 (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: "call"
-			});
-		};
-		try {
-			Promise.resolve(options.onCall(report)).catch(failed);
-		} catch (error) {
-			failed(error);
-		}
-	};
-	const call = async (request, context) => {
-		const started = performance.now();
-		const trace = {
-			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 ("error" in outcome) {
-			report.error = outcome.error;
-			report.outcome = trace.gate === "denied" ? "denied" : "error";
-		}
-		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);
-		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
-		};
-	};
-	/** 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.
-	*/
-	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."
-		};
-		if (!(request.headers.get("content-type") ?? "").toLowerCase().startsWith("application/json")) return {
-			code: "BAD_INPUT",
-			message: "Send the request body as application/json."
-		};
-		return null;
-	};
-	const chat = async (request, chatOptions) => {
-		const refused = refusal(request);
-		if (refused !== null) throw new JigsError(refused.code, refused.message);
-		let ctx;
-		try {
-			ctx = await options.context(request);
-		} 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;
-		}
-		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);
-		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
-		};
-	};
-	async function* session(body, context) {
-		const parsed = parseSession(body);
-		if ("error" in parsed) {
-			yield {
-				error: parsed.error,
-				type: "error"
-			};
-			return;
-		}
-		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");
-		}
-		return headers;
-	};
-	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
-		});
-	};
-	const failure = (request, error) => json(request, statusOf(error.code), { error });
-	const frame = (request) => {
-		const ancestors = ["'self'", ...allowedOrigins].join(" ");
-		const headers = request === void 0 ? new Headers() : 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.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
-			} };
-		}
-	};
-	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, {
-			headers,
-			status: 200
-		});
-	};
-	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, {
-			ctx: context.ctx,
-			signal: abort.signal
-		}), abort, () => request.signal.removeEventListener("abort", forward));
-	};
-	return {
-		call,
-		chat,
-		compile,
-		frame,
-		handler,
-		maxBodyBytes,
-		prompt: (mode) => mode === "chat" ? chatSystem : system,
-		promptPrefix: (mode) => mode === "chat" ? chatParts.stable : documentParts.stable,
-		session,
-		spec,
-		version
-	};
-}
-//#endregion
-export { createJigsServer, defineRun };