@jigs.design/server 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @jigs.design/server
 
-`createJigsServer` turns a host into one fetch handler. That handler streams checked programs, runs queries and mutations, and serves the sandbox frame. You give it a `run` function per procedure, a `context` for each request, and a `model` function that calls your LLM.
+`createJigsServer` turns a host into one fetch handler. That handler streams checked programs, runs queries and mutations, and serves the sandbox frame. You give it a `run` function per procedure, and a `context` for each request; `.withModel` adds a `model` function that calls your LLM. Without it, the server serves calls, pages, the push stream and a session that opens a document with no ask, and nothing that asks a model.
 
 Import it from server code only.
 
@@ -21,8 +21,9 @@ export const jigs = createJigsServer({
 			}
 		},
 	},
-	model: aiSdkModel("anthropic/claude-sonnet-5.5"),
 	instructions: "You are Acme's order assistant. Today is 2026-10-18.",
+}).withModel({
+	model: aiSdkModel("anthropic/claude-sonnet-5.5"),
 });
 
 // Mount it as GET, POST and OPTIONS on one route, e.g. /api/jigs.
@@ -31,26 +32,31 @@ export const handler = jigs.handler;
 
 The server renders the prompt from the host, calls the model, checks each streamed prefix and compiles it to a program. `instructions`, such as who the assistant is and today's date, reach every prompt: document-mode sessions, chat and repairs. When the checker finds errors, it runs repair rounds. A call carries its procedure's `kind`, and the server refuses one that does not match the host. A follow-up turn may answer with SEARCH/REPLACE edits instead of a whole document.
 
-Specs need not come from the model. `jigs.spec(name)` returns a spec your product ships in `specs`, compiled once at startup. `jigs.compile(source)` checks and compiles one a user saved.
+UIs need not come from the model. `await jigs.page(name, props)` returns a page your product ships as a jig on the host, compiled at startup or, for new props, at its first call; `await jigs.page(id, undefined, { ctx })` also answers a page a user saved, which `resolvePage` finds for that `ctx`. The handler serves both as `POST { type: "page" }`, gated by `context` and `pagePolicy`, and compiled pages go through an in-process cache bounded by size. A session can open either as its document, `{ name, props }`.
+
+With an `events` option, a `GET` that accepts `text/event-stream` opens a push stream, on which your server names the queries and pages to refetch.
 
 ## Exports
 
-| Export                     | What it is                                                                          |
-| -------------------------- | ----------------------------------------------------------------------------------- |
-| `createJigsServer`         | The server: `handler`, `spec`, `compile`, `chat`, and the functions `handler` wraps |
-| `defineRun`                | Types `run` functions outside a server, to share them between two servers           |
-| `JigsError`                | Throw from `context` or `run` with a code the browser can read                      |
-| `JigsCompileError`         | What a strict `jigs.compile` rejects with, carrying the `diagnostics`               |
-| `chatBlockText`            | Writes a chat block back as a fenced block, for the model's history                 |
-| `@jigs.design/server/node` | `nodeHandler`, for Node's `http` and Express                                        |
+| Export                     | What it is                                                                     |
+| -------------------------- | ------------------------------------------------------------------------------ |
+| `createJigsServer`         | The server: `handler`, `page`, `compile`, `withModel` for `session` and `chat` |
+| `defineRun`                | Types `run` functions outside a server, to share them between two servers      |
+| `JigsError`                | Throw from `context` or `run` with a code the browser can read                 |
+| `JigsCompileError`         | What a strict `jigs.compile` rejects with, carrying the `diagnostics`          |
+| `chatBlockText`            | Writes a chat block back as a fenced block, for the model's history            |
+| `@jigs.design/server/node` | `nodeHandler`, for Node's `http` and Express                                   |
 
 It re-exports the shared types from `@jigs.design/protocol`.
 
 ## Source
 
-- `src/server.ts`: `createJigsServer` and the request routing.
+- `src/core.ts`: `createJigsServer`, the model-free core: calls, pages, compiling, the frame and prompts.
+- `src/compile-cache.ts`: the process's compile cache, bounded by the size of its programs.
+- `src/handler.ts`: the fetch handler: refusals, body parsing, routing and the event stream.
+- `src/model-server.ts`: `withModel`: `session`, `chat` and the handler that runs turns.
 - `src/session.ts`: one turn: prompt, model, checking, repair and edits.
-- `src/compile.ts`: compiling a document against the host's catalog and recipes.
+- `src/compile.ts`: compiling a document against the host's catalog and tags, a page against every define jig, and the checks on a page's props.
 - `src/inputs.ts`, `src/literal.ts`: literal procedure inputs checked against their schemas.
 - `src/chat.ts`: chat mode, where a Markdown reply carries fenced `jigs` blocks.
 - `src/invalidation.ts`: which queries a mutation refreshes.

package/dist/chat.d.ts

@@ -2,11 +2,11 @@ import "./design.js";
 import { ChatBlockSource } from "./types.js";
 import "./session.js";
 import "@jigs.design/compiler";
-import { ChatBlock, Diagnostic, Program } from "@jigs.design/protocol";
+import { ChatBlock, Diagnostic, PageRef, Program } from "@jigs.design/protocol";
 //#region src/chat.d.ts
 /**
  * A block as the model wrote it, for the model's history: a fenced `jigs`
- * block with its id, and its source without the pragma line.
+ * block with its name as the fence id, and its source without the pragma line.
  */
 export declare function chatBlockText(block: ChatBlockSource): string;
 //#endregion

package/dist/chat.js

@@ -1,5 +1,5 @@
-import { MARKDOWN_ELEMENTS } from "./compile.js";
 import { belowPrefix, pragmaLine, splitPragma, withPragma } from "./pragma.js";
+import { MARKDOWN_ELEMENTS } from "./compile.js";
 import { reorderDeclarations } from "./rewrite.js";
 import { applyChecked, editResult, runSession } from "./session.js";
 import { applyEdits, isEditReply, parseEdits } from "@jigs.design/compiler";
@@ -87,11 +87,11 @@ const AUTO_ID = /^jigs-(\d+)$/;
 const VALID_ID = /^[a-z][a-z0-9-]*$/;
 /**
 * A block as the model wrote it, for the model's history: a fenced `jigs`
-* block with its id, and its source without the pragma line.
+* block with its name as the fence id, and its source without the pragma line.
 */
 function chatBlockText(block) {
 	const body = splitPragma(block.source).body.replace(/\n+$/, "");
-	return `\`\`\`jigs ${block.id}\n${body}\n\`\`\``;
+	return `\`\`\`jigs ${block.name}\n${body}\n\`\`\``;
 }
 /** The block's id from the fence's info string, made kebab-case. */
 function slug(info) {
@@ -133,18 +133,18 @@ function depthChange(line) {
 * its program changes.
 */
 function createReplyParser(deps, history) {
-	/** Latest body (no pragma) by id. */
+	/** Latest body (no pragma) by name. */
 	const latest = /* @__PURE__ */ new Map();
 	/**
-	* The body as this reply wrote it, by id, for a block whose `{@body}`
+	* The body as this reply wrote it, by name, for a block whose `{@body}`
 	* lines the server moved: an edit later in the same reply was written
 	* against it, not against the moved source.
 	*/
 	const asWritten = /* @__PURE__ */ new Map();
 	/** The version `edits` apply to: the latest, or the one the reply wrote. */
-	const baseFor = (id, edits) => {
-		const base = latest.get(id);
-		const written = asWritten.get(id);
+	const baseFor = (name, edits) => {
+		const base = latest.get(name);
+		const written = asWritten.get(name);
 		return base !== void 0 && written !== void 0 && !applyEdits(base, edits).ok && applyEdits(written, edits).ok ? written : base;
 	};
 	const versions = /* @__PURE__ */ new Map();
@@ -156,10 +156,10 @@ function createReplyParser(deps, history) {
 	let opened = 0;
 	let repairsLeft = MAX_BLOCK_REPAIRS;
 	for (const entry of history) {
-		if (!VALID_ID.test(entry.id)) continue;
-		latest.set(entry.id, splitPragma(entry.source).body);
-		versions.set(entry.id, (versions.get(entry.id) ?? 0) + 1);
-		const auto = AUTO_ID.exec(entry.id);
+		if (!VALID_ID.test(entry.name)) continue;
+		latest.set(entry.name, splitPragma(entry.source).body);
+		versions.set(entry.name, (versions.get(entry.name) ?? 0) + 1);
+		const auto = AUTO_ID.exec(entry.name);
 		if (auto !== null) autoId = Math.max(autoId, Number(auto[1]));
 	}
 	const empty = deps.compile("");
@@ -209,14 +209,15 @@ function createReplyParser(deps, history) {
 	const blockOf = (open, body, compiled, status, error) => {
 		const block = {
 			diagnostics: belowPrefix(compiled.diagnostics, pragmaLine(deps.catalogVersion)),
-			id: open.id,
-			key: `${open.id}@${open.version}`,
+			key: `${open.name}@${open.version}`,
+			name: open.name,
 			program: compiled.program,
 			source: withPragma(body, deps.catalogVersion),
 			status,
 			version: open.version
 		};
 		if (error !== void 0) block.error = error;
+		if (compiled.ref !== null) block.ref = compiled.ref;
 		return block;
 	};
 	const emit = (block) => {
@@ -236,34 +237,35 @@ function createReplyParser(deps, history) {
 			advice: belowPrefix(advice, pragmaLine(deps.catalogVersion)),
 			diagnostics: edits?.applied === false ? [] : block.diagnostics,
 			fenced: !open.implicit,
-			id: block.id,
 			key: block.key,
+			name: block.name,
 			repairs: [],
 			status: block.status === "repairing" ? "repairing" : "done"
 		};
 		if (edits !== void 0) result.edits = edits;
 		if (block.error !== void 0) result.error = block.error;
 		if (rewrite !== void 0) result.rewrites = [rewrite];
+		if (block.ref !== void 0) result.ref = block.ref;
 		results.set(block.key, result);
 		emit(block);
 	};
 	const open = (info, indent, implicit = false) => {
 		const named = slug(info ?? "");
-		const id = named === "" ? `jigs-${++autoId}` : named;
-		const version = (versions.get(id) ?? 0) + 1;
-		versions.set(id, version);
+		const name = named === "" ? `jigs-${++autoId}` : named;
+		const version = (versions.get(name) ?? 0) + 1;
+		versions.set(name, version);
 		opened++;
 		const block = {
 			baseShown: false,
 			depth: 0,
 			dirty: false,
 			editsShown: 0,
-			id,
 			implicit,
 			indent,
 			lastKey: JSON.stringify(empty.program),
 			lastSentAt: Number.NEGATIVE_INFINITY,
 			lines: [],
+			name,
 			over: opened > MAX_BLOCKS,
 			partial: "",
 			version,
@@ -286,7 +288,7 @@ function createReplyParser(deps, history) {
 		const editing = isEditReply(body);
 		if (editing === true) {
 			const edits = parseEdits(body);
-			const base = baseFor(block.id, edits);
+			const base = baseFor(block.name, edits);
 			if (base === void 0) return;
 			if (!block.baseShown) {
 				block.baseShown = true;
@@ -328,11 +330,11 @@ function createReplyParser(deps, history) {
 		let edits;
 		if (isEditReply(written) === true) {
 			const parsed = parseEdits(written);
-			const base = baseFor(block.id, parsed);
+			const base = baseFor(block.name, parsed);
 			if (base === void 0) {
 				settle(block, blockOf(block, "", empty, "done", {
 					code: "NOT_FOUND",
-					message: `There is no earlier jig "${block.id}" to change.`
+					message: `There is no earlier jig "${block.name}" to change.`
 				}), {
 					applied: false,
 					blocks: parsed.length
@@ -364,12 +366,12 @@ function createReplyParser(deps, history) {
 		}
 		let compiled = deps.compile(body);
 		const reordered = reorderDeclarations(body, compiled, deps.compile);
-		if (reordered === null) asWritten.delete(block.id);
+		if (reordered === null) asWritten.delete(block.name);
 		else {
-			asWritten.set(block.id, body);
+			asWritten.set(block.name, body);
 			({body, compiled} = reordered);
 		}
-		latest.set(block.id, body);
+		latest.set(block.name, body);
 		const advice = compiled.advise("chat");
 		const chosen = advice.filter((entry) => deps.designRepair.has(entry.code));
 		if ((needsRepair(compiled.diagnostics) || chosen.length > 0) && repairable()) {
@@ -544,9 +546,9 @@ function createReplyParser(deps, history) {
 		end,
 		plan: (block) => plans.get(block.key),
 		push,
-		remember: (id, body) => {
-			asWritten.delete(id);
-			latest.set(id, body);
+		remember: (name, body) => {
+			asWritten.delete(name);
+			latest.set(name, body);
 		},
 		result: (key) => results.get(key),
 		results: () => [...results.values()].map((result) => ({ ...result }))
@@ -576,7 +578,7 @@ async function* repairBlock(deps, block) {
 	}
 	const result = deps.parser.result(block.key);
 	const base = plan.kind === "edit" ? plan.base : plan.body;
-	const ask = `Write the "${block.id}" UI.`;
+	const ask = `Write the "${block.name}" UI.`;
 	const messages = [
 		{
 			content: deps.prompt === void 0 ? ask : `${deps.prompt}\n\n${ask}`,
@@ -587,7 +589,7 @@ async function* repairBlock(deps, block) {
 			role: "assistant"
 		},
 		{
-			content: plan.kind === "edit" ? editRepairText(plan.failure, plan.base) : repairText(plan.diagnostics, plan.advice),
+			content: plan.kind === "edit" ? editRepairText(plan.failure, plan.base) : repairText(plan.diagnostics, plan.advice, "answer"),
 			role: "user"
 		}
 	];
@@ -606,17 +608,27 @@ async function* repairBlock(deps, block) {
 			await forward?.(turn);
 		}
 	};
-	for await (const event of runSession(session, messages, deps.options, deps.call)) if (event.type === "program") program = event.program;
+	for await (const event of runSession(session, {
+		document: base,
+		messages
+	}, deps.options, deps.call)) if (event.type === "program") program = event.program;
 	else if (event.type === "done") {
-		deps.parser.remember(block.id, splitPragma(event.source).body);
-		if (result !== void 0) result.status = "done";
-		yield {
+		const body = splitPragma(event.source).body;
+		deps.parser.remember(block.name, body);
+		const repaired = {
 			...block,
 			diagnostics: event.diagnostics,
 			program: program ?? block.program,
 			source: event.source,
 			status: "done"
 		};
+		const { ref } = deps.session.checker.compile(body);
+		if (ref !== null) repaired.ref = ref;
+		if (result !== void 0) {
+			result.status = "done";
+			if (ref !== null) result.ref = ref;
+		}
+		yield repaired;
 		return;
 	} else failure = event.error;
 	if (result !== void 0) {

package/dist/compile-cache.js

@@ -0,0 +1,60 @@
+//#region src/compile-cache.ts
+/** The default bound: 32 MB of programs, as JSON. */
+const DEFAULT_MAX_BYTES = 33554432;
+/**
+* A cache bounded by the size of its programs, least recently used out
+* first. A program larger than the whole bound is not kept.
+*/
+function memoryCompileCache(maxBytes = DEFAULT_MAX_BYTES) {
+	const entries = /* @__PURE__ */ new Map();
+	let bytes = 0;
+	const drop = (key) => {
+		const entry = entries.get(key);
+		if (entry !== void 0) {
+			entries.delete(key);
+			bytes -= entry.size;
+		}
+	};
+	return {
+		get bytes() {
+			return bytes;
+		},
+		get: (key) => {
+			const entry = entries.get(key);
+			if (entry === void 0) return;
+			entries.delete(key);
+			entries.set(key, entry);
+			return entry.value;
+		},
+		set: (key, value) => {
+			drop(key);
+			const size = JSON.stringify(value.program).length;
+			if (size > maxBytes) return;
+			entries.set(key, {
+				size,
+				value
+			});
+			bytes += size;
+			for (const oldest of entries.keys()) {
+				if (bytes <= maxBytes) break;
+				drop(oldest);
+			}
+		},
+		get size() {
+			return entries.size;
+		}
+	};
+}
+/**
+* The one cache every server in this process shares. Keys start with a
+* hash of what the server compiles against, so two hosts never read each
+* other's entries.
+*/
+const processCompileCache = memoryCompileCache();
+/** SHA-256 of `text`, as hex: collisions here would serve the wrong page. */
+async function sha256(text) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
+export { memoryCompileCache, processCompileCache, sha256 };

package/dist/compile.d.ts

@@ -1,3 +1,3 @@
 import "./design.js";
 import { Catalog, Host } from "@jigs.design/host";
-import { Diagnostic, Program } from "@jigs.design/protocol";
+import { Diagnostic, PageProps, PageRef, Program } from "@jigs.design/protocol";

package/dist/compile.js

@@ -1,7 +1,8 @@
 import { designChecks } from "./design.js";
-import { JigsCompileError, fatalDiagnostics } from "./errors.js";
+import { JigsCompileError, JigsError, fatalDiagnostics } from "./errors.js";
 import { inputDiagnostics } from "./inputs.js";
 import { outputDiagnostics } from "./outputs.js";
+import { splitPragma, versionDiagnostics } from "./pragma.js";
 import { compileJigs, compileLibrary, spanIn } from "@jigs.design/compiler";
 import { componentSchema } from "@jigs.design/host";
 import { PROGRAM_FORMAT } from "@jigs.design/protocol";
@@ -110,68 +111,162 @@ function tagsIn(source) {
 	for (const match of source.matchAll(TAG)) if (match[1] !== void 0) tags.add(match[1]);
 	return tags;
 }
+/** The longest canonical props, as JSON, a page accepts. */
+const MAX_PAGE_PROPS = 4096;
+/** A JavaScript identifier, as the compiler requires of a define prop. */
+const BINDING_NAME = /^[A-Za-z_$][\w$]*$/;
+/** What the compiler reads as a number literal; anything else is an expression. */
+const NUMBER_LITERAL = /^-?\d+(?:\.\d+)?$/;
+const SCALAR_KINDS = [
+	"boolean",
+	"number",
+	"string"
+];
+/**
+* Whether `value` is a literal of `kind`. Props reach the server from
+* untyped callers too, so a value may be none of the three.
+*/
+function isOfKind(value, kind) {
+	return typeof value === kind;
+}
+/** `props` with keys sorted, so equal props make equal bodies. */
+function sortedProps(props) {
+	return Object.fromEntries(Object.entries(props).toSorted(([a], [b]) => a < b ? -1 : 1));
+}
+/** Each prop a literal in braces, keys sorted, so equal props make equal bodies. */
+function oneTag(name, props) {
+	const attrs = Object.entries(sortedProps(props)).map(([key, value]) => `${key}={${JSON.stringify(value)}}`);
+	return attrs.length === 0 ? `<${name}/>` : `<${name} ${attrs.join(" ")}/>`;
+}
+/**
+* Why `props` cannot be a page's props for `define`, or null when they can.
+* Each value must be one the compiler reads as a literal, so the compile
+* that follows types it.
+*/
+function pagePropsProblem(define, props) {
+	const declared = new Map(define.props.map((prop) => [prop.name, prop]));
+	for (const [key, value] of Object.entries(props)) {
+		if (key === "name" || key === "key" || !BINDING_NAME.test(key)) return `"${key}" cannot be a prop name`;
+		const prop = declared.get(key);
+		if (prop === void 0) {
+			const known = [...declared.keys()];
+			return `<${define.name}> has no prop "${key}"${known.length === 0 ? "" : `; its props are ${known.join(", ")}`}`;
+		}
+		const kind = SCALAR_KINDS.find((candidate) => isOfKind(value, candidate));
+		if (kind === void 0) return `"${key}" must be a string, a number or a boolean`;
+		if (prop.kind !== null && prop.kind !== kind) return `"${key}" must be a ${prop.kind}`;
+		if (kind === "number" && !NUMBER_LITERAL.test(JSON.stringify(value))) return `"${key}" must be a finite number written without an exponent`;
+		if (kind === "string" && /["\\\r\n\u2028\u2029]/.test(String(value))) return `"${key}" must not contain a quote, a backslash or a line break`;
+	}
+	const missing = define.props.find((prop) => prop.required && !Object.hasOwn(props, prop.name));
+	if (missing !== void 0) return `<${define.name}> needs the prop "${missing.name}"`;
+	if (JSON.stringify(sortedProps(props)).length > MAX_PAGE_PROPS) return `The props are longer than ${MAX_PAGE_PROPS} characters`;
+	return null;
+}
+/**
+* The page a tree names, when it is one call to a library jig that is a
+* page, with no children and literal props only.
+*/
+function refOf(tree, pages) {
+	const nodes = tree.filter((node) => node.type !== "text" || node.value.trim() !== "");
+	const [node] = nodes;
+	if (nodes.length !== 1 || node?.type !== "call" || node.origin !== "library" || node.key !== null || node.children.length > 0 || !pages.has(node.name)) return null;
+	const props = {};
+	for (const [key, value] of Object.entries(node.props)) {
+		if (value.kind !== "literal") return null;
+		props[key] = value.value;
+	}
+	return {
+		name: node.name,
+		props: sortedProps(props)
+	};
+}
 /**
 * The host, ready to check sources: its catalog in the compiler's form and
-* its recipes compiled into a library. Throws when a recipe does not compile
-* or calls a procedure the host does not have, so a bad recipe stops the
-* server at startup instead of reaching the model. Throws too when a
-* situation's example has a diagnostic worse than info, so the prompt never
-* shows the model Jigs the checker refuses.
+* its define jigs compiled into two libraries, one of the tags the model
+* may write and one of every define jig, for pages. Throws when a jig does
+* not compile, carries a pragma for a newer language or catalog, calls a
+* procedure the host does not have, or is a tag that uses a page-only jig,
+* so a bad jig stops the server at startup instead of reaching the model.
+* Throws too when a situation's example has a diagnostic worse than info,
+* so the prompt never shows the model Jigs the checker refuses.
 */
 function createChecker(host) {
 	const catalog = compileCatalog(host.components);
-	const library = compileLibrary(host.recipes.map((entry) => ({
+	const defines = [];
+	for (const entry of host.jigs) {
+		const split = splitPragma(entry.source);
+		const fatal = fatalDiagnostics(versionDiagnostics(split.versions, host.components.version));
+		if (fatal.length > 0) throw new JigsCompileError(`Jig "${entry.name}"`, fatal);
+		if (entry.kind === "define") defines.push({
+			body: split.body,
+			name: entry.name,
+			tag: entry.tag
+		});
+	}
+	const tagLibrary = compileLibrary(defines.filter((entry) => entry.tag).map((entry) => ({
 		name: entry.name,
-		source: entry.source
+		source: entry.body
 	})), catalog);
-	const recipes = /* @__PURE__ */ new Map();
-	for (const entry of host.recipes) {
-		const uses = [...library.get(entry.name)?.procedures ?? []];
-		const problem = [...procedureDiagnostics(host, entry.source, uses), ...inputDiagnostics(host, entry.source)][0];
-		if (problem !== void 0) throw new Error(`Recipe "${entry.name}" failed to compile: line ${problem.span.line}: ${problem.message}`);
-		recipes.set(entry.name, {
-			tags: tagsIn(entry.source),
+	const fullLibrary = compileLibrary(defines.map((entry) => ({
+		name: entry.name,
+		source: entry.body
+	})), catalog);
+	const allFacts = /* @__PURE__ */ new Map();
+	for (const entry of defines) {
+		const uses = [...fullLibrary.get(entry.name)?.procedures ?? []];
+		const problem = [...procedureDiagnostics(host, entry.body, uses), ...inputDiagnostics(host, entry.body)][0];
+		if (problem !== void 0) throw new Error(`Jig "${entry.name}" failed to compile: line ${problem.span.line}: ${problem.message}`);
+		allFacts.set(entry.name, {
+			tags: tagsIn(entry.body),
 			uses
 		});
 	}
-	/** The tags a source draws, through every recipe it uses, and the procedures those recipes call. */
-	const reach = (body) => {
-		const tags = new Set(MARKDOWN_ELEMENTS);
+	const tagFacts = new Map([...allFacts].filter(([name]) => tagLibrary.has(name)));
+	const pages = new Set(host.jigs.filter((entry) => entry.page).map((entry) => entry.name));
+	const tags = /* @__PURE__ */ new Set([...host.components.components.map((component) => component.name), ...tagLibrary.keys()]);
+	/** The tags a source draws, through every jig it uses, and the procedures those jigs call. */
+	const reach = (body, facts) => {
+		const drawn = new Set(MARKDOWN_ELEMENTS);
 		const uses = [];
 		const pending = [...tagsIn(body)];
 		for (let tag = pending.pop(); tag !== void 0; tag = pending.pop()) {
-			if (tags.has(tag)) continue;
-			tags.add(tag);
-			const facts = recipes.get(tag);
-			if (facts !== void 0) {
-				uses.push(...facts.uses);
-				pending.push(...facts.tags);
+			if (drawn.has(tag)) continue;
+			drawn.add(tag);
+			const found = facts.get(tag);
+			if (found !== void 0) {
+				uses.push(...found.uses);
+				pending.push(...found.tags);
 			}
 		}
 		return {
-			tags,
+			tags: drawn,
 			uses
 		};
 	};
-	const compile = (body) => {
+	const compileWith = (body, library, facts) => {
 		const result = compileJigs(body, {
 			catalog,
 			library
 		});
 		const own = result.procedures;
-		const reached = reach(result.source);
+		const reached = reach(result.source, facts);
+		const diagnostics = [
+			...result.diagnostics,
+			...procedureDiagnostics(host, body, own),
+			...outputDiagnostics(host, body, result.reads),
+			...inputDiagnostics(host, body)
+		].toSorted((a, b) => a.span.line - b.span.line);
+		let ref = diagnostics.some((diagnostic) => diagnostic.severity === "error") ? null : refOf(result.program.tree, pages);
+		const define = ref === null ? void 0 : fullLibrary.get(ref.name);
+		if (ref !== null && (define === void 0 || pagePropsProblem(define, ref.props) !== null)) ref = null;
 		return {
 			advise: (placement) => designChecks({
 				catalog: host.components,
 				compiled: result,
 				placement
 			}),
-			diagnostics: [
-				...result.diagnostics,
-				...procedureDiagnostics(host, body, own),
-				...outputDiagnostics(host, body, result.reads),
-				...inputDiagnostics(host, body)
-			].toSorted((a, b) => a.span.line - b.span.line),
+			diagnostics,
 			program: {
 				code: result.output.code,
 				components: Object.fromEntries(host.components.components.filter((component) => reached.tags.has(component.name)).map((component) => [component.name, componentSchema(component)])),
@@ -179,15 +274,52 @@ function createChecker(host) {
 				imageHosts: host.imageHosts,
 				procedures: procedureTable(host, [...own, ...reached.uses]),
 				prose: result.output.constants
-			}
+			},
+			ref
 		};
 	};
+	const compile = (body) => compileWith(body, tagLibrary, tagFacts);
+	const definePage = (name) => {
+		const define = fullLibrary.get(name);
+		if (define === void 0 || !pages.has(name)) throw new Error(`"${name}" is not a define page on this host`);
+		return define;
+	};
+	const pageBody = (name, props) => {
+		const problem = pagePropsProblem(definePage(name), props);
+		if (problem !== null) throw new JigsError("BAD_INPUT", problem);
+		return oneTag(name, props);
+	};
+	const pageDocument = (name, props) => {
+		const use = pageBody(name, props);
+		const reached = /* @__PURE__ */ new Set();
+		const pending = [...allFacts.get(name)?.tags ?? []];
+		for (let tag = pending.pop(); tag !== void 0; tag = pending.pop()) {
+			const facts = allFacts.get(tag);
+			if (reached.has(tag) || facts === void 0 || tagLibrary.has(tag)) continue;
+			reached.add(tag);
+			pending.push(...facts.tags);
+		}
+		const bodies = defines.filter((entry) => entry.name !== name && reached.has(entry.name)).map((entry) => entry.body.trim());
+		const own = defines.find((entry) => entry.name === name)?.body ?? "";
+		return [
+			...bodies,
+			own.trim(),
+			use
+		].join("\n\n");
+	};
 	for (const entry of host.situations) {
 		if (entry.example === void 0) continue;
 		const fatal = fatalDiagnostics(compile(entry.example).diagnostics);
 		if (fatal.length > 0) throw new JigsCompileError(`Situation "${entry.name}" example`, fatal);
 	}
-	return { compile };
+	return {
+		compile,
+		needsProps: (name) => definePage(name).props.some((prop) => prop.required),
+		page: (name, props) => compileWith(pageBody(name, props), fullLibrary, allFacts),
+		pageBody,
+		pageDocument,
+		tags
+	};
 }
 /** Props the parser sets on Markdown elements, with the values it uses. */
 const MARKDOWN_PROPS = [{

package/dist/{server.d.ts → core.d.ts}

@@ -1,6 +1,10 @@
+import "./compile.js";
 import { ContextFunction, JigsServer, JigsServerOptions, RunFunctions } from "./types.js";
-import { Catalog, Procedures } from "@jigs.design/host";
-//#region src/server.d.ts
+import "./session.js";
+import "./handler.js";
+import { Catalog, Host, JigDefinition, PageName, Procedures } from "@jigs.design/host";
+import { JigsErrorData } from "@jigs.design/protocol";
+//#region src/core.d.ts
 /**
  * Types a `context` and `run` pair outside `createJigsServer`, so two
  * servers (one per platform) can share them. `TContext` comes from `context`
@@ -13,5 +17,5 @@ export declare function defineRun<const TProcedures extends Procedures, TContext
   context: ContextFunction<TContext>;
   run: RunFunctions<TProcedures, TContext>;
 };
-export declare function createJigsServer<const TProcedures extends Procedures, const TCatalog extends Catalog, TContext = any, TOptions = undefined, const TSpecName extends string = never>(options: JigsServerOptions<TProcedures, TCatalog, TContext, TOptions, TSpecName>): JigsServer<TContext, TSpecName>;
+export declare function createJigsServer<const TProcedures extends Procedures, const TCatalog extends Catalog, TContext = any, const TJigs extends ReadonlyArray<JigDefinition> = readonly []>(options: JigsServerOptions<TProcedures, TCatalog, TContext, TJigs>): JigsServer<TContext, PageName<TJigs>>;
 //#endregion