@jigs.design/server 0.3.5 → 0.3.6

package/dist/chat.js

@@ -624,7 +624,7 @@ async function* repairBlock(deps, block) {
 			source: event.source,
 			status: "done"
 		};
-		const compiled = deps.session.checker.compile(body);
+		const compiled = deps.session.compile(body);
 		const { ref } = compiled;
 		if (ref !== null) repaired.ref = ref;
 		if (compiled.toolKeys !== null) repaired.toolKeys = compiled.toolKeys;

package/dist/compile-cache.d.ts

@@ -0,0 +1,2 @@
+import "./design.js";
+import { Diagnostic, Program } from "@jigs.design/protocol";

package/dist/compile-cache.js

@@ -2,10 +2,11 @@
 /** 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.
+* A cache bounded by the sum of `sizeOf` over its values, and by
+* `maxEntries`, least recently used out first. A value larger than the
+* whole bound is not kept.
 */
-function memoryCompileCache(maxBytes = DEFAULT_MAX_BYTES) {
+function boundedCache(maxBytes, sizeOf, maxEntries = Number.POSITIVE_INFINITY) {
 	const entries = /* @__PURE__ */ new Map();
 	let bytes = 0;
 	const drop = (key) => {
@@ -28,7 +29,7 @@ function memoryCompileCache(maxBytes = DEFAULT_MAX_BYTES) {
 		},
 		set: (key, value) => {
 			drop(key);
-			const size = JSON.stringify(value.program).length;
+			const size = sizeOf(value);
 			if (size > maxBytes) return;
 			entries.set(key, {
 				size,
@@ -36,7 +37,7 @@ function memoryCompileCache(maxBytes = DEFAULT_MAX_BYTES) {
 			});
 			bytes += size;
 			for (const oldest of entries.keys()) {
-				if (bytes <= maxBytes) break;
+				if (bytes <= maxBytes && entries.size <= maxEntries) break;
 				drop(oldest);
 			}
 		},
@@ -46,6 +47,13 @@ function memoryCompileCache(maxBytes = DEFAULT_MAX_BYTES) {
 	};
 }
 /**
+* 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) {
+	return boundedCache(maxBytes, (value) => JSON.stringify(value.program).length);
+}
+/**
 * 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.
@@ -57,4 +65,4 @@ async function sha256(text) {
 	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 //#endregion
-export { memoryCompileCache, processCompileCache, sha256 };
+export { boundedCache, memoryCompileCache, processCompileCache, sha256 };

package/dist/compile.js

@@ -3,7 +3,7 @@ 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, nearest, spanIn } from "@jigs.design/compiler";
+import { compileJigs, compileLibrary, extendLibrary, nearest, parseJigs, spanIn } from "@jigs.design/compiler";
 import { TOOL_RESULTS } from "@jigs.design/prompt";
 import { componentSchema } from "@jigs.design/host";
 import { PROGRAM_FORMAT } from "@jigs.design/protocol";
@@ -198,6 +198,40 @@ function refOf(tree, pages) {
 		props: sortedProps(props)
 	};
 }
+/** The element names `source` writes, whether or not the library has them. */
+function writtenNames(source) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (nodes) => {
+		for (const node of nodes) if (node.type === "element") {
+			names.add(node.name);
+			visit(node.children);
+		}
+	};
+	visit(parseJigs(source).children);
+	return names;
+}
+/**
+* `defines` ordered so each comes after the others it writes, in list
+* order where the order is free; the members of a cycle, and what waits on
+* them, last, in list order. Read from the parse rather than a compile: a
+* compile drops an element its library lacks, so a define compiled before
+* the one it writes would not show it.
+*/
+function dependencyOrder(defines) {
+	const names = new Set(defines.map((entry) => entry.name));
+	const needs = new Map(defines.map((entry) => [entry.name, [...writtenNames(entry.body)].filter((name) => name !== entry.name && names.has(name))]));
+	const ordered = [];
+	const placed = /* @__PURE__ */ new Set();
+	for (let progressed = true; progressed;) {
+		progressed = false;
+		for (const entry of defines) if (!placed.has(entry.name) && (needs.get(entry.name) ?? []).every((name) => placed.has(name))) {
+			ordered.push(entry);
+			placed.add(entry.name);
+			progressed = true;
+		}
+	}
+	return [...ordered, ...defines.filter((entry) => !placed.has(entry.name))];
+}
 /**
 * The host, ready to check sources: its catalog in the compiler's form and
 * its define jigs compiled into two libraries, one of the tags the model
@@ -298,6 +332,35 @@ function createChecker(host) {
 		};
 	};
 	const compile = (body) => compileWith(body, tagLibrary, tagFacts);
+	const extend = (saved) => {
+		const extended = extendLibrary(tagLibrary, dependencyOrder(saved).map((entry) => ({
+			name: entry.name,
+			source: entry.body
+		})), catalog);
+		const facts = new Map(tagFacts);
+		const diagnostics = /* @__PURE__ */ new Map();
+		const kept = /* @__PURE__ */ new Set();
+		for (const entry of saved) {
+			const found = [...extended.diagnostics.get(entry.name) ?? []];
+			const define = extended.library.get(entry.name);
+			if (define !== void 0 && !tagLibrary.has(entry.name)) {
+				const uses = [...define.procedures];
+				found.push(...procedureDiagnostics(host, entry.body, uses), ...inputDiagnostics(host, entry.body));
+				facts.set(entry.name, {
+					tags: define.tags,
+					uses
+				});
+				kept.add(entry.name);
+			}
+			diagnostics.set(entry.name, found.toSorted((a, b) => a.span.line - b.span.line));
+		}
+		return {
+			compile: (body) => compileWith(body, extended.library, facts),
+			diagnostics,
+			kept,
+			tags: /* @__PURE__ */ new Set([...tags, ...kept])
+		};
+	};
 	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`);
@@ -333,6 +396,7 @@ function createChecker(host) {
 	}
 	return {
 		compile,
+		extend,
 		needsProps: (name) => definePage(name).props.some((prop) => prop.required),
 		page: (name, props) => compileWith(pageBody(name, props), fullLibrary, allFacts),
 		pageBody,

package/dist/core.d.ts

@@ -1,7 +1,7 @@
-import "./compile.js";
 import { ContextFunction, JigsServer, JigsServerOptions, RunFunctions } from "./types.js";
 import "./session.js";
 import "./handler.js";
+import "./scope.js";
 import { Catalog, Host, JigDefinition, PageName, Procedures } from "@jigs.design/host";
 import { JigsErrorData } from "@jigs.design/protocol";
 //#region src/core.d.ts

package/dist/core.js

@@ -8,8 +8,10 @@ import { processCompileCache, sha256 } from "./compile-cache.js";
 import { eventStream } from "./events.js";
 import { invalidationsOf } from "./invalidation.js";
 import { withToolResults } from "./tool-results.js";
+import { checkedTag, listHashInput, processScopeCache, promptTag, savedTagListSchema, savedTagSchema, scanTag, scopeHashInput, tagDiagnostics, withTail } from "./scope.js";
 import { createModelServer } from "./model-server.js";
-import { systemPromptParts } from "@jigs.design/prompt";
+import { RESERVED_TAGS } from "@jigs.design/compiler";
+import { savedTagsSection, systemPromptParts } from "@jigs.design/prompt";
 import { isCallPolicy } from "@jigs.design/host";
 import { PROGRAM_FORMAT } from "@jigs.design/protocol";
 import { z } from "zod";
@@ -380,10 +382,19 @@ function createJigsServer(options) {
 		reportCall(report);
 		return outcome;
 	};
-	/** A stored source: its pragma's versions are checked, then its body compiled. */
-	const compileStored = (source, placement = "document") => {
+	/** What a request without saved tags compiles and prompts with: the host alone. */
+	const hostScope = {
+		compile: checker.compile,
+		hash: null,
+		rows: [],
+		saved: [],
+		tags: checker.tags,
+		tail: ""
+	};
+	/** A stored source: its pragma's versions are checked, then its body compiled in `scope`. */
+	const compileStored = (source, placement = "document", scope = hostScope) => {
 		const stored = splitPragma(source);
-		const compiled = checker.compile(stored.body);
+		const compiled = scope.compile(stored.body);
 		const prefix = source.slice(0, source.length - stored.body.length);
 		const result = {
 			advice: belowPrefix(compiled.advise(placement), prefix),
@@ -395,19 +406,21 @@ function createJigsServer(options) {
 	};
 	/**
 	* `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`.
+	* compiles against, the scope's hash when the caller has saved tags, the
+	* placement (or "page", for a define page's body, which compiles against
+	* every define jig and never a scope) 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 cached = async (placement, body, compile, scope = hostScope) => {
+		const hash = await sha256(body);
+		const key = scope.hash === null ? `${await namespace}.${placement}.${hash}` : `${await namespace}.${scope.hash}.${placement}.${hash}`;
 		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 compileCached = (source, placement = "document", scope = hostScope) => cached(placement, source, () => compileStored(source, placement, scope), scope);
 	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) => {
@@ -488,7 +501,8 @@ function createJigsServer(options) {
 	const savedPage = async (name, props, lookup) => {
 		const saved = await savedSource(name, props, lookup);
 		if (saved === null) return null;
-		const compiled = await compileCached(saved.source);
+		const scope = await scopeFor(lookup);
+		const compiled = await compileCached(saved.source, "document", scope);
 		return {
 			...lookup.strict === true ? strictly(`Page "${name}"`, compiled) : compiled,
 			data: saved.data,
@@ -503,10 +517,12 @@ function createJigsServer(options) {
 		return entry === void 0 ? savedPage(name, props, lookup) : null;
 	};
 	const page = resolve;
-	const compile = async (source, compileOptions) => {
-		const compiled = await compileCached(source, compileOptions?.placement);
+	/** `compile` in `scope`. Async so a strict failure is a rejection. */
+	const compileIn = async (scope, source, compileOptions) => {
+		const compiled = await compileCached(source, compileOptions?.placement, scope);
 		return compileOptions?.strict === false ? compiled : strictly("The source", compiled);
 	};
+	const compile = (source, compileOptions) => compileIn(hostScope, source, compileOptions);
 	/** Whether `pagePolicy` lets this `ctx` read a shipped page; it fails closed. */
 	const pageAllowed = (ctx, name, props) => {
 		if (options.pagePolicy === void 0) return true;
@@ -594,7 +610,8 @@ function createJigsServer(options) {
 		}
 		return checker.pageDocument(name, props);
 	};
-	const prepareSession = async (body, context) => {
+	/** The session's turn, its named page resolved for `ctx`. */
+	const sessionTurn = async (body, context) => {
 		const input = parseSessionInput(body);
 		if ("error" in input) return input;
 		const document = input.document;
@@ -621,6 +638,155 @@ function createJigsServer(options) {
 			messages: input.messages
 		};
 	};
+	const prepareSession = async (body, context) => {
+		const turn = await sessionTurn(body, context);
+		if ("error" in turn) return turn;
+		try {
+			return {
+				scope: await scopeFor(context),
+				turn
+			};
+		} catch (error) {
+			if (!isJigsError(error)) onError(error, { type: "tag" });
+			return { error: errorData(isJigsError(error) ? error : null) };
+		}
+	};
+	/**
+	* Names a saved tag may not take: the catalog's components, the
+	* language's own tags and every jig of the host, tag, page-only define
+	* or document page. The compiler keeps a define that shadows its library
+	* (`shadows_library` is info), so the scope refuses these itself.
+	*/
+	const reservedNames = /* @__PURE__ */ new Set([
+		...host.components.components.map((component) => component.name),
+		...RESERVED_TAGS,
+		...jigsByName.keys()
+	]);
+	/** A scanned tag's diagnostics, compiled among `others`, which it replaces one of by name. */
+	const checkAmong = (others, tag) => {
+		const extended = checker.extend([...others.filter((entry) => entry.name !== tag.name), tag].map((entry) => ({
+			body: entry.body,
+			name: entry.name
+		})));
+		return tagDiagnostics(tag, extended.diagnostics.get(tag.name) ?? [], host.components.version);
+	};
+	/** `checkTag` among a scope's rows: the host's, or a caller's. */
+	const checkTagIn = (rows, row, checkOptions) => {
+		const parsed = savedTagSchema.safeParse(row);
+		if (!parsed.success) throw new JigsError("BAD_INPUT", `A saved tag is { description, example?, source }: ${issuesText(parsed.error)}`);
+		const scanned = scanTag(parsed.data, reservedNames);
+		if ("message" in scanned) throw new JigsError("BAD_INPUT", scanned.message);
+		const diagnostics = checkAmong(rows, scanned);
+		if (checkOptions?.strict !== false) {
+			const fatal = fatalDiagnostics(diagnostics);
+			if (fatal.length > 0) throw new JigsCompileError(`Tag "${scanned.name}"`, fatal);
+		}
+		return checkedTag(scanned, diagnostics);
+	};
+	/**
+	* The scope for rows the resolver returned, each checked as `checkTag`
+	* would and dropped with `onError` when it fails: the host extended by
+	* the rest, in dependency order. The host's scope when none is kept.
+	*/
+	const buildScope = async (rows) => {
+		const kept = [];
+		const names = /* @__PURE__ */ new Set();
+		let total = 0;
+		for (const [index, row] of rows.entries()) {
+			if (row === null) {
+				onError(new JigsError("BAD_INPUT", "resolveTags returned an entry that is not { description, example?, source }"), { type: "tag" });
+				continue;
+			}
+			const scanned = scanTag(row, reservedNames);
+			if ("message" in scanned) {
+				onError(new JigsError("BAD_INPUT", scanned.message), scanned.name === void 0 ? { type: "tag" } : {
+					name: scanned.name,
+					type: "tag"
+				});
+				continue;
+			}
+			if (names.has(scanned.name)) {
+				onError(new JigsError("BAD_INPUT", `resolveTags returned <${scanned.name}> twice; the first was kept`), {
+					name: scanned.name,
+					type: "tag"
+				});
+				continue;
+			}
+			if (kept.length >= 50 || total + scanned.source.length > 2e5) {
+				onError(/* @__PURE__ */ new Error(`resolveTags returned more than 50 tags or ${MAX_CONTENT} characters of source; <${scanned.name}> and the ${rows.length - index - 1} after it were dropped`), { type: "tag" });
+				break;
+			}
+			kept.push(scanned);
+			names.add(scanned.name);
+			total += scanned.source.length;
+		}
+		if (kept.length === 0) return hostScope;
+		const extended = checker.extend(kept.map((tag) => ({
+			body: tag.body,
+			name: tag.name
+		})));
+		const saved = [];
+		for (const tag of kept) {
+			const diagnostics = tagDiagnostics(tag, extended.diagnostics.get(tag.name) ?? [], host.components.version);
+			if (extended.kept.has(tag.name)) saved.push(checkedTag(tag, diagnostics));
+			else onError(new JigsCompileError(`Tag "${tag.name}"`, fatalDiagnostics(diagnostics)), {
+				name: tag.name,
+				type: "tag"
+			});
+		}
+		if (saved.length === 0) return hostScope;
+		return {
+			compile: extended.compile,
+			hash: await sha256(scopeHashInput(kept)),
+			rows: kept,
+			saved,
+			tags: extended.tags,
+			tail: savedTagsSection(kept.filter((tag) => extended.kept.has(tag.name)).map((tag) => promptTag(tag)))
+		};
+	};
+	/**
+	* The scope for one request, after `context`: the host's without
+	* `resolveTags` or when it returns none, else the host extended by the
+	* caller's tags, from the process's scope cache when the same list was
+	* built before. A `JigsError` the resolver throws passes through; any
+	* other throw, or a value that is not an array, is `INTERNAL`.
+	*/
+	const scopeFor = async (lookup) => {
+		const resolveTags = options.resolveTags;
+		if (resolveTags === void 0) return hostScope;
+		let listed;
+		try {
+			listed = await resolveTags(lookup.signal === void 0 ? { ctx: lookup.ctx } : {
+				ctx: lookup.ctx,
+				signal: lookup.signal
+			});
+		} catch (error) {
+			if (isJigsError(error)) throw error;
+			onError(error, { type: "tag" });
+			throw new JigsError("INTERNAL", INTERNAL_MESSAGE);
+		}
+		const list = savedTagListSchema.safeParse(listed);
+		if (!list.success) {
+			onError(/* @__PURE__ */ new Error(`resolveTags returned ${String(listed)}; return an array of { description, example?, source }`), { type: "tag" });
+			throw new JigsError("INTERNAL", INTERNAL_MESSAGE);
+		}
+		const rows = list.data;
+		if (rows.length === 0) return hostScope;
+		const key = `${await namespace}.${await sha256(listHashInput(rows))}`;
+		const hit = processScopeCache.get(key);
+		if (hit !== void 0) return hit;
+		const scope = await buildScope(rows);
+		processScopeCache.set(key, scope);
+		return scope;
+	};
+	/** What `forUser` hands out for a scope. */
+	const userScope = (scope) => ({
+		checkTag: async (row, checkOptions) => checkTagIn(scope.rows, row, checkOptions),
+		compile: async (source, compileOptions) => compileIn(scope, source, compileOptions),
+		prompt: (mode) => withTail(mode === "chat" ? chatSystem : system, scope.tail),
+		promptPrefix: (mode) => mode === "chat" ? chatParts.stable : documentParts.stable,
+		tags: scope.saved
+	});
 	const http = createHttp({
 		allowedOrigins,
 		ownOrigin,
@@ -665,13 +831,13 @@ function createJigsServer(options) {
 	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: {
+		const document = prepared.turn.document;
+		if (document === null || asksModel(prepared.turn.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);
+			yield* restoreTurn(prepared.scope.compile, host.components.version, document, true);
 		} };
 	};
 	const hostEvents = options.events;
@@ -731,9 +897,11 @@ function createJigsServer(options) {
 	};
 	const core = {
 		call,
+		checkTag: async (row, checkOptions) => checkTagIn(hostScope.rows, row, checkOptions),
 		compile,
 		data,
 		events,
+		forUser: async (lookup) => userScope(await scopeFor(lookup)),
 		frame,
 		handler: createHandler({
 			...handlerDeps,
@@ -745,12 +913,12 @@ function createJigsServer(options) {
 		promptPrefix: (mode) => mode === "chat" ? chatParts.stable : documentParts.stable,
 		version,
 		withModel: (modelOptions) => createModelServer({
-			checker,
 			context: options.context,
 			handlerDeps,
 			host,
 			onError,
 			prepareSession,
+			scopeFor,
 			toolPrompt: toolParts === null ? null : {
 				system: `${toolParts.stable}\n\n${toolParts.variable}`,
 				systemPrefix: toolParts.stable

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { Advice, DesignCheckCode, Placement } from "./design.js";
 import { ConfirmationStore, memoryConfirmations } from "./confirm.js";
-import { CallContext, CallOutcome, CallReport, CallReportOutcome, CallRequest, ChatBlockResult, ChatBlockSource, ChatEvent, ChatOptions, ChatTurn, CompileOptions, ContextFunction, EditFailureReason, ErrorInfo, EventSubscriber, EventsFunction, JigsModelServer, JigsServer, JigsServerOptions, ModelFunction, ModelOptions, ModelRequest, ModelRequestKind, PageCall, PageFunction, PagePolicy, PageResolver, PolicyCall, PushInvalidate, PushInvalidatePages, PushInvalidation, PushPage, PushSend, RequiresAction, ResolvedPage, RunFunctions, SavedPage, SessionRequest, Turn, TurnEdits, TurnRewrite, TurnRound, Usage } from "./types.js";
+import { CallContext, CallOutcome, CallReport, CallReportOutcome, CallRequest, ChatBlockResult, ChatBlockSource, ChatEvent, ChatOptions, ChatTurn, CheckTagOptions, CheckedTag, CompileOptions, ContextFunction, EditFailureReason, ErrorInfo, EventSubscriber, EventsFunction, JigsModelServer, JigsServer, JigsServerOptions, ModelFunction, ModelOptions, ModelRequest, ModelRequestKind, PageCall, PageFunction, PagePolicy, PageResolver, PolicyCall, PushInvalidate, PushInvalidatePages, PushInvalidation, PushPage, PushSend, RequiresAction, ResolvedPage, RunFunctions, SavedPage, SavedTag, SessionRequest, TagResolver, Turn, TurnEdits, TurnRewrite, TurnRound, Usage, UserScope } from "./types.js";
 import { chatBlockText } from "./chat.js";
 import { JigsCompileError, JigsError, ThrownCode } from "./errors.js";
 import { createJigsServer, defineRun } from "./core.js";
 import { addUsage } from "./usage.js";
 import { PromptMode, askOf, withDocument } from "@jigs.design/prompt";
 import { ChatBlock, ChatBlockStatus, Diagnostic, JigsErrorCode, JigsErrorData, Message, PageProps, PageRef, Program, SessionDocument, SessionEvent, Severity, Span } from "@jigs.design/protocol";
-export { type Advice, type CallContext, type CallOutcome, type CallReport, type CallReportOutcome, type CallRequest, type ChatBlock, type ChatBlockResult, type ChatBlockSource, type ChatBlockStatus, type ChatEvent, type ChatOptions, type ChatTurn, type CompileOptions, type ConfirmationStore, type ContextFunction, type DesignCheckCode, type Diagnostic, type EditFailureReason, type ErrorInfo, type EventSubscriber, type EventsFunction, JigsCompileError, JigsError, type JigsErrorCode, type JigsErrorData, type JigsModelServer, type JigsServer, type JigsServerOptions, type Message, type ModelFunction, type ModelOptions, type ModelRequest, type ModelRequestKind, type PageCall, type PageFunction, type PagePolicy, type PageProps, type PageRef, type PageResolver, type Placement, type PolicyCall, type Program, type PromptMode, type PushInvalidate, type PushInvalidatePages, type PushInvalidation, type PushPage, type PushSend, type RequiresAction, type ResolvedPage, type RunFunctions, type SavedPage, type SessionDocument, type SessionEvent, type SessionRequest, type Severity, type Span, type ThrownCode, type Turn, type TurnEdits, type TurnRewrite, type TurnRound, type Usage, addUsage, askOf, chatBlockText, createJigsServer, defineRun, memoryConfirmations, withDocument };
+export { type Advice, type CallContext, type CallOutcome, type CallReport, type CallReportOutcome, type CallRequest, type ChatBlock, type ChatBlockResult, type ChatBlockSource, type ChatBlockStatus, type ChatEvent, type ChatOptions, type ChatTurn, type CheckTagOptions, type CheckedTag, type CompileOptions, type ConfirmationStore, type ContextFunction, type DesignCheckCode, type Diagnostic, type EditFailureReason, type ErrorInfo, type EventSubscriber, type EventsFunction, JigsCompileError, JigsError, type JigsErrorCode, type JigsErrorData, type JigsModelServer, type JigsServer, type JigsServerOptions, type Message, type ModelFunction, type ModelOptions, type ModelRequest, type ModelRequestKind, type PageCall, type PageFunction, type PagePolicy, type PageProps, type PageRef, type PageResolver, type Placement, type PolicyCall, type Program, type PromptMode, type PushInvalidate, type PushInvalidatePages, type PushInvalidation, type PushPage, type PushSend, type RequiresAction, type ResolvedPage, type RunFunctions, type SavedPage, type SavedTag, type SessionDocument, type SessionEvent, type SessionRequest, type Severity, type Span, type TagResolver, type ThrownCode, type Turn, type TurnEdits, type TurnRewrite, type TurnRound, type Usage, type UserScope, addUsage, askOf, chatBlockText, createJigsServer, defineRun, memoryConfirmations, withDocument };

package/dist/model-server.js

@@ -3,6 +3,7 @@ import { splitPragma } from "./pragma.js";
 import { createHandler, issuesText, parseBounded } from "./handler.js";
 import { MAX_CONTENT, runSession } from "./session.js";
 import { createReplyParser, repairBlock, streamChat } from "./chat.js";
+import { withTail } from "./scope.js";
 import { TOOL_RESULTS } from "@jigs.design/prompt";
 import { z } from "zod";
 //#region src/model-server.ts
@@ -25,7 +26,10 @@ function createModelServer(internals, core, options) {
 	const maxRepairs = options.maxRepairs ?? 1;
 	const programIntervalMs = options.programIntervalMs ?? 250;
 	const designRepair = new Set(options.designRepair ?? []);
-	/** A session request checked, its options parsed, and a named document resolved for `ctx`. */
+	/**
+	* A session request checked, its options parsed, a named document
+	* resolved for `ctx`, and the scope `ctx` compiles and prompts in.
+	*/
 	const prepareSession = async (body, call) => {
 		let turnOptions;
 		if (options.options === void 0) turnOptions = void 0;
@@ -37,33 +41,47 @@ function createModelServer(internals, core, options) {
 			} };
 			turnOptions = parsed.data;
 		}
-		const turn = await internals.prepareSession(body, call);
-		return "error" in turn ? turn : {
+		const prepared = await internals.prepareSession(body, call);
+		return "error" in prepared ? prepared : {
 			options: turnOptions,
-			turn
+			scope: prepared.scope,
+			turn: prepared.turn
 		};
 	};
-	const sessionDeps = {
-		checker: internals.checker,
-		designRepair,
-		host: internals.host,
-		kind: "session",
-		maxRepairs,
-		model: options.model,
-		onError: internals.onError,
-		onTurn: options.onTurn,
-		programIntervalMs,
+	const toolPrompt = internals.toolPrompt;
+	const documentPrompt = {
 		system,
 		systemPrefix: core.promptPrefix("document")
 	};
-	const toolPrompt = internals.toolPrompt;
-	const toolSessionDeps = toolPrompt === null ? sessionDeps : {
-		...sessionDeps,
-		system: toolPrompt.system,
-		systemPrefix: toolPrompt.systemPrefix
+	/**
+	* A turn's deps in `scope`: its compile, and the document prompt (the
+	* slot's when `tools` and the server has one) with the scope's saved
+	* tags at the end.
+	*/
+	const sessionDeps = (scope, tools) => {
+		const prompt = tools && toolPrompt !== null ? toolPrompt : documentPrompt;
+		return {
+			compile: scope.compile,
+			designRepair,
+			host: internals.host,
+			kind: "session",
+			maxRepairs,
+			model: options.model,
+			onError: internals.onError,
+			onTurn: options.onTurn,
+			programIntervalMs,
+			savedTags: scope.saved.map((tag) => tag.name),
+			system: withTail(prompt.system, scope.tail),
+			systemPrefix: prompt.systemPrefix,
+			systemTail: scope.tail
+		};
 	};
-	/** A session's deps: the slot's prompt when its document reads `toolResults`. */
-	const depsFor = (turn) => toolPrompt !== null && turn.document !== null && Object.hasOwn(internals.checker.compile(splitPragma(turn.document).body).program.procedures, TOOL_RESULTS) ? toolSessionDeps : sessionDeps;
+	/**
+	* A session's deps: the slot's prompt when its document reads
+	* `toolResults`, compiled in the request's scope, so a document that
+	* reads it only through a saved tag gets it too.
+	*/
+	const depsFor = (turn, scope) => sessionDeps(scope, toolPrompt !== null && turn.document !== null && Object.hasOwn(scope.compile(splitPragma(turn.document).body).program.procedures, TOOL_RESULTS));
 	const chat = async (request, chatOptions) => {
 		const refused = internals.handlerDeps.http.refusal(request);
 		if (refused !== null) throw new JigsError(refused.code, refused.message);
@@ -92,15 +110,16 @@ function createModelServer(internals, core, options) {
 			ctx,
 			signal: chatOptions?.signal ?? new AbortController().signal
 		};
+		const scope = await internals.scopeFor(turnCall);
 		const repairRounds = Math.max(0, maxRepairs - 1);
 		const parser = createReplyParser({
 			catalogVersion: internals.host.components.version,
-			compile: (body) => internals.checker.compile(body),
+			compile: (body) => scope.compile(body),
 			designRepair,
 			now: () => performance.now(),
 			programIntervalMs,
 			repairs: maxRepairs > 0,
-			tags: internals.checker.tags
+			tags: scope.tags
 		}, input.data.blocks ?? []);
 		const turnDeps = {
 			call: turnCall,
@@ -108,7 +127,7 @@ function createModelServer(internals, core, options) {
 			parser,
 			prompt: input.data.prompt,
 			session: {
-				...toolSessionDeps,
+				...sessionDeps(scope, true),
 				kind: "chat-repair",
 				maxRepairs: repairRounds
 			}
@@ -124,23 +143,26 @@ function createModelServer(internals, core, options) {
 				push: parser.push,
 				repair
 			}, reply, chatOptions?.signal),
-			system: chatSystem,
-			systemPrefix: core.promptPrefix("chat")
+			system: withTail(chatSystem, scope.tail),
+			systemPrefix: core.promptPrefix("chat"),
+			systemTail: scope.tail
 		};
 	};
 	return {
 		call: core.call,
 		chat,
+		checkTag: core.checkTag,
 		compile: core.compile,
 		data: core.data,
 		events: core.events,
+		forUser: core.forUser,
 		frame: core.frame,
 		handler: createHandler({
 			...internals.handlerDeps,
 			session: async (body, call) => {
 				const prepared = await prepareSession(body, call);
 				if ("error" in prepared) return prepared;
-				return { turn: (turnCall) => runSession(depsFor(prepared.turn), prepared.turn, prepared.options, turnCall) };
+				return { turn: (turnCall) => runSession(depsFor(prepared.turn, prepared.scope), prepared.turn, prepared.options, turnCall) };
 			}
 		}),
 		maxBodyBytes: core.maxBodyBytes,
@@ -156,7 +178,7 @@ function createModelServer(internals, core, options) {
 				};
 				return;
 			}
-			yield* runSession(depsFor(prepared.turn), prepared.turn, prepared.options, context);
+			yield* runSession(depsFor(prepared.turn, prepared.scope), prepared.turn, prepared.options, context);
 		},
 		version: core.version
 	};

package/dist/pragma.d.ts

@@ -0,0 +1 @@
+import { Diagnostic, Span } from "@jigs.design/protocol";

package/dist/scope.d.ts

@@ -0,0 +1,7 @@
+import "./compile.js";
+import "./types.js";
+import "./compile-cache.js";
+import "./pragma.js";
+import "@jigs.design/prompt";
+import { Diagnostic } from "@jigs.design/protocol";
+import { z } from "zod";

package/dist/scope.js

@@ -0,0 +1,150 @@
+import { belowPrefix, splitPragma, versionDiagnostics } from "./pragma.js";
+import { MAX_CONTENT } from "./session.js";
+import { boundedCache } from "./compile-cache.js";
+import { jigSignature } from "@jigs.design/compiler";
+import { scanDefine } from "@jigs.design/host";
+import { z } from "zod";
+//#region src/scope.ts
+/** The longest description a saved tag may have, in characters. */
+const MAX_DESCRIPTION = 300;
+/** The longest example a saved tag may have, in characters. */
+const MAX_EXAMPLE = 300;
+/** The longest signature a saved tag may render to, in characters. */
+const MAX_SIGNATURE = 500;
+/** What the scope cache holds at most: 32 MB of sources and tails. */
+const MAX_SCOPE_BYTES = 33554432;
+/** How many scopes the scope cache holds at most. */
+const MAX_SCOPES = 256;
+/** A line terminator, which a description, an example or a signature may not hold. */
+const LINE_BREAK = /[\r\n\u2028\u2029]/;
+/** What `resolveTags` must return each entry as, checked, since a plain-JavaScript one may not. */
+const savedTagSchema = z.object({
+	description: z.string(),
+	example: z.string().exactOptional(),
+	source: z.string()
+});
+/**
+* What `resolveTags` must return, checked: an array, each entry a tag or,
+* when it is not one, null, so the scope drops that entry and keeps the rest.
+*/
+const savedTagListSchema = z.array(savedTagSchema.or(z.unknown().transform(() => null)));
+/**
+* The scan of one saved tag before anything compiles: one `<define>` with a
+* tag name that is not `reserved`, and a description, example and rendered
+* signature on one line each and within their limits.
+*/
+function scanTag(row, reserved) {
+	if (row.source.length > 2e5) return { message: `A saved tag's source is at most ${MAX_CONTENT} characters` };
+	const scanned = scanDefine(row.source);
+	if ("reason" in scanned) {
+		if (scanned.reason === "document") return { message: "A saved tag's source must be one <define name=\"…\"> and nothing else" };
+		return scanned.name === void 0 ? { message: "A saved tag's <define> needs a literal name, e.g. <define name=\"groceryRun\">" } : {
+			message: `Tag name "${scanned.name}" must start with a lowercase letter and use letters and digits only`,
+			name: scanned.name
+		};
+	}
+	const { name } = scanned;
+	if (reserved.has(name)) return {
+		message: `"${name}" is taken by the app: a component, a language tag or one of its jigs. Name the tag something else`,
+		name
+	};
+	const lines = [[
+		"description",
+		row.description,
+		MAX_DESCRIPTION
+	], [
+		"example",
+		row.example,
+		MAX_EXAMPLE
+	]];
+	const split = splitPragma(row.source);
+	const signature = jigSignature({
+		name,
+		source: split.body
+	});
+	lines.push([
+		"signature",
+		signature,
+		MAX_SIGNATURE
+	]);
+	for (const [field, text, limit] of lines) {
+		if (text === void 0) continue;
+		if (LINE_BREAK.test(text)) return {
+			message: `<${name}>'s ${field} must be one line`,
+			name
+		};
+		if (text.length > limit) return {
+			message: `<${name}>'s ${field} is longer than ${limit} characters`,
+			name
+		};
+	}
+	const tag = {
+		body: split.body,
+		description: row.description,
+		name,
+		prefix: row.source.slice(0, row.source.length - split.body.length),
+		signature,
+		source: row.source,
+		versions: split.versions
+	};
+	if (row.example !== void 0) tag.example = row.example;
+	return tag;
+}
+/**
+* A scanned tag's diagnostics in its row's source: its pragma's against
+* `catalogVersion`, then `found`, numbered by its body, moved below the pragma.
+*/
+function tagDiagnostics(tag, found, catalogVersion) {
+	return [...versionDiagnostics(tag.versions, catalogVersion), ...belowPrefix(found, tag.prefix)];
+}
+/** A scanned tag as `checkTag` and `UserScope.tags` show it. */
+function checkedTag(tag, diagnostics) {
+	const checked = {
+		description: tag.description,
+		diagnostics,
+		name: tag.name,
+		signature: tag.signature
+	};
+	if (tag.example !== void 0) checked.example = tag.example;
+	return checked;
+}
+/** A kept tag as the prompt lists it: its signature read from its body. */
+function promptTag(tag) {
+	const listed = {
+		description: tag.description,
+		name: tag.name,
+		source: tag.body
+	};
+	if (tag.example !== void 0) listed.example = tag.example;
+	return listed;
+}
+/** The kept rows as tuples, so no two lists hash alike by concatenation. */
+function scopeHashInput(tags) {
+	return JSON.stringify(tags.map((tag) => [
+		tag.name,
+		tag.source,
+		tag.description,
+		tag.example ?? null
+	]));
+}
+/** A resolved list as tuples, an entry that is not a `SavedTag` as null: the scope cache's key. */
+function listHashInput(rows) {
+	return JSON.stringify(rows.map((row) => row === null ? null : [
+		row.source,
+		row.description,
+		row.example ?? null
+	]));
+}
+/**
+* Scopes by `${namespace}.${list hash}`, shared by every server in this
+* process, as the compile cache is: bounded by the kept sources and the
+* tail, in characters, and by count. On a hit nothing compiles and nothing
+* reaches `onError` again.
+*/
+const processScopeCache = boundedCache(MAX_SCOPE_BYTES, (scope) => scope.tail.length + scope.rows.reduce((sum, tag) => sum + tag.source.length, 0), MAX_SCOPES);
+/** `system` with the caller's saved tags after it, or as it is with none. */
+function withTail(system, tail) {
+	return tail === "" ? system : `${system}\n\n${tail}`;
+}
+//#endregion
+export { checkedTag, listHashInput, processScopeCache, promptTag, savedTagListSchema, savedTagSchema, scanTag, scopeHashInput, tagDiagnostics, withTail };

package/dist/session.js

@@ -107,9 +107,9 @@ function applyChecked(base, edits, compile) {
 * A turn that starts from a document and asks nothing: its source is
 * checked and compiled again, with no model call.
 */
-function* restoreTurn(checker, catalogVersion, content, fresh) {
+function* restoreTurn(compile, catalogVersion, content, fresh) {
 	const restored = splitPragma(content);
-	const compiled = checker.compile(restored.body);
+	const compiled = compile(restored.body);
 	const diagnostics = [...versionDiagnostics(restored.versions, catalogVersion), ...belowPrefix(compiled.diagnostics, restored.versions === null ? pragmaLine(catalogVersion) : content.slice(0, content.length - restored.body.length))];
 	yield {
 		diagnostics,
@@ -151,13 +151,13 @@ async function* runSession(deps, turn, options, call) {
 		if (deps.kind === "chat-repair") return "chat-repair";
 		return round === 0 ? "session" : "repair";
 	};
-	const compile = (body) => deps.checker.compile(body);
+	const compile = (body) => deps.compile(body);
 	const placement = deps.kind === "session" ? "document" : "chat";
 	/** Whether a round already asked for the design changes `designRepair` names. */
 	let designRepaired = false;
 	const { messages } = turn;
 	if (turn.document !== null && !asksModel(messages)) {
-		yield* restoreTurn(deps.checker, catalogVersion, turn.document, true);
+		yield* restoreTurn(deps.compile, catalogVersion, turn.document, true);
 		return;
 	}
 	const conversation = messages.map((message) => message.role === "assistant" ? {
@@ -226,7 +226,8 @@ async function* runSession(deps, turn, options, call) {
 				options,
 				signal: call.signal,
 				system: deps.system,
-				systemPrefix: deps.systemPrefix
+				systemPrefix: deps.systemPrefix,
+				systemTail: deps.systemTail
 			})[Symbol.asyncIterator]();
 			try {
 				for (;;) {
@@ -404,6 +405,7 @@ async function* runSession(deps, turn, options, call) {
 				options,
 				repairs,
 				rounds,
+				savedTags: deps.savedTags,
 				source: finalSource,
 				usage
 			});

package/dist/types.d.ts

@@ -33,7 +33,11 @@ export interface ModelRequest<TContext, TOptions> {
   messages: ReadonlyArray<Message>;
   options: TOptions;
   signal: AbortSignal;
-  /** The document prompt rendered from the host, with the server's `instructions`. */
+  /**
+   * The document prompt for this request: the host's, with the server's
+   * `instructions`, then the caller's saved tags (`systemTail`) when
+   * `resolveTags` returned any.
+   */
   system: string;
   /**
    * The start of `system` that is the same on every turn: the language and
@@ -41,6 +45,13 @@ export interface ModelRequest<TContext, TOptions> {
    * provider's prompt cache, as `aiSdkModel` does.
    */
   systemPrefix: string;
+  /**
+   * The end of `system` that differs per user: the `## Saved tags` section
+   * for the caller's saved tags, or "" with none. Mark it as a third part
+   * (`cachedInstructions(system, systemPrefix, systemTail)`), so the host's
+   * part between stays cached for every user.
+   */
+  systemTail: string;
 }
 /**
  * The product's call to its LLM. Yield text as it arrives. A generator may
@@ -142,6 +153,11 @@ export interface Turn<TContext, TOptions> {
    * a stop or a failure is not a round.
    */
   rounds: ReadonlyArray<TurnRound>;
+  /**
+   * The names of the caller's saved tags the prompt listed, in its order;
+   * empty without `resolveTags`, or when it returned none.
+   */
+  savedTags: ReadonlyArray<string>;
   /** The checked source sent with `done`, with its pragma; null when the turn did not finish. */
   source: string | null;
   usage: Usage;
@@ -281,13 +297,17 @@ export interface EventSubscriber<TProcedures extends Procedures, TContext, TPage
  */
 export type EventsFunction<TProcedures extends Procedures, TContext, TPageName extends string = string> = (subscriber: EventSubscriber<TProcedures, TContext, TPageName>) => (() => void) | Promise<() => void>;
 export interface ErrorInfo {
-  /** The procedure, for a call; the page, for a page. */
+  /**
+   * The procedure, for a call; the page, for a page; the saved tag, for a
+   * tag, when the entry had a name to read.
+   */
   name?: string;
   /**
    * The request it came from: a call, a session turn, a chat turn with its
-   * repairs, the push stream, or a page (`jigs.page` or its wire request).
+   * repairs, the push stream, a page (`jigs.page` or its wire request), or
+   * a saved tag (`resolveTags`, or one entry it returned that was dropped).
    */
-  type: "call" | "chat" | "events" | "page" | "session";
+  type: "call" | "chat" | "events" | "page" | "session" | "tag";
 }
 /** A page `resolvePage` found: the source as the app stored it, and what it reads. */
 export interface SavedPage {
@@ -311,6 +331,89 @@ export type PageResolver<TContext> = (name: string, call: {
   ctx: TContext;
   signal?: AbortSignal;
 }) => Promise<SavedPage | null> | SavedPage | null;
+/**
+ * A tag a user saved, as the app stores it: one `<define>`, which names
+ * it, and what the model is told about it. A saved tag is never a page.
+ */
+export interface SavedTag {
+  /**
+   * One line for the model: when to reach for this tag. At most 300
+   * characters, with no line break.
+   */
+  description: string;
+  /** A one-line use, shown to the model. At most 300 characters. */
+  example?: string;
+  /**
+   * One `<define>` and nothing else, with or without a pragma line; at
+   * most 200,000 characters.
+   */
+  source: string;
+}
+/**
+ * The caller's saved tags, for the `ctx` that `context` returned, in the
+ * order the prompt lists them. Runs on every chat turn, session turn,
+ * saved-page request and `forUser`; cache in it if the store is slow.
+ * Throw a `JigsError` to refuse the request.
+ */
+export type TagResolver<TContext> = (call: {
+  ctx: TContext;
+  signal?: AbortSignal;
+}) => Promise<ReadonlyArray<SavedTag>> | ReadonlyArray<SavedTag>;
+/** A saved tag checked: what the prompt shows for it, and what the checks found. */
+export interface CheckedTag {
+  description: string;
+  /**
+   * What the checks found in its body, numbered by the lines of its
+   * source, pragma included: the compiler's diagnostics, a procedure the
+   * host lacks, a wrong literal input, a pragma for another catalog.
+   */
+  diagnostics: ReadonlyArray<Diagnostic>;
+  example?: string;
+  /** The name its `<define>` gives it. */
+  name: string;
+  /** The heading the prompt shows, such as `<groceryRun week>`. */
+  signature: string;
+}
+export interface CheckTagOptions {
+  /**
+   * Reject with a `JigsCompileError` when the tag's body has an error or
+   * warning diagnostic. Default true; pass false to get the diagnostics
+   * instead.
+   */
+  strict?: boolean;
+}
+/**
+ * The server for one caller: the host extended by the tags `resolveTags`
+ * returned for their `ctx`, resolved once. Pass it where a server is taken
+ * for compiling, such as `reviveJigs`.
+ */
+export interface UserScope {
+  /**
+   * Checks `tag` as the scope would list it, against the host and this
+   * caller's other saved tags, a saved tag of its name replaced by it.
+   * Rejects with `JigsError("BAD_INPUT")` for what the scope would drop
+   * (not one `<define>`, a name that is not a tag name or is the catalog's,
+   * the language's or the host's, a description, example or signature
+   * with a line break or over its limit, a source over 200,000
+   * characters), and, when `strict`, with a `JigsCompileError` for an error
+   * or warning diagnostic.
+   */
+  checkTag: (tag: SavedTag, options?: CheckTagOptions) => Promise<CheckedTag>;
+  /**
+   * `jigs.compile` in this caller's scope: their saved tags compile into the
+   * programs that use them. Strict unless told otherwise.
+   */
+  compile: JigsServer<unknown>["compile"];
+  /** `jigs.prompt(mode)` with this caller's `## Saved tags` at the end. */
+  prompt: (mode?: PromptMode) => string;
+  /** `jigs.promptPrefix(mode)`: the same for every caller. */
+  promptPrefix: (mode?: PromptMode) => string;
+  /**
+   * The saved tags the scope kept, in the order the prompt lists them,
+   * with their lenient diagnostics.
+   */
+  tags: ReadonlyArray<CheckedTag>;
+}
 /**
  * Whether a shipped page may be served on the wire to the caller `ctx`
  * names. Saved pages are scoped by `resolvePage` instead.
@@ -392,6 +495,16 @@ export interface JigsServerOptions<TProcedures extends Procedures, TCatalog exte
    * call says `strict`. See `PageResolver`.
    */
   resolvePage?: PageResolver<NoInfer<TContext>>;
+  /**
+   * The caller's saved tags, on every request that compiles or prompts:
+   * chat and session turns, saved pages and `forUser`. Each request builds
+   * its scope from them: the host's tags extended by the user's, compiled
+   * leniently, listed as `## Saved tags` at the end of the prompt, and
+   * part of the compile cache's key. A bad entry is dropped and reported
+   * to `onError` with `type: "tag"`; past 50 tags or 200,000 characters of
+   * source, the rest are. Shipped pages never see them. See `TagResolver`.
+   */
+  resolveTags?: TagResolver<NoInfer<TContext>>;
   run: RunFunctions<NoInfer<TProcedures>, NoInfer<TContext>>;
   /**
    * Signs confirmation tokens, at least 32 characters; keep it out of the
@@ -601,10 +714,15 @@ export interface ChatTurn {
   results: () => Array<ChatBlockResult>;
   /** `push`, `end` and `repair` together; ends after every repair settles. */
   stream: (reply: AsyncIterable<string>) => AsyncIterable<ChatEvent>;
-  /** The chat-mode prompt, `prompt("chat")`, with the server's `instructions`. */
+  /**
+   * The chat-mode prompt for this request: `prompt("chat")`, with the
+   * server's `instructions`, then the caller's saved tags (`systemTail`).
+   */
   system: string;
   /** The start of `system` that is the same on every turn, as on `ModelRequest`. */
   systemPrefix: string;
+  /** The end of `system` that differs per user, or "", as on `ModelRequest`. */
+  systemTail: string;
 }
 /** A page, compiled, and what the checks said about it. */
 export interface ResolvedPage {
@@ -665,6 +783,11 @@ export interface PageFunction<TContext, TPageName extends string> {
 }
 export interface JigsServer<TContext, TPageName extends string = never> {
   call: (request: CallRequest, context: CallContext<TContext>) => Promise<CallOutcome>;
+  /**
+   * Checks a saved tag against the host alone, as `UserScope.checkTag`
+   * does in a caller's scope.
+   */
+  checkTag: (tag: SavedTag, options?: CheckTagOptions) => Promise<CheckedTag>;
   /** Checks and compiles a source with no model. Strict unless told otherwise. */
   compile: (source: string, options?: CompileOptions) => Promise<{
     /** The design checks' advice, numbered like `diagnostics`. */
@@ -692,6 +815,17 @@ export interface JigsServer<TContext, TPageName extends string = never> {
    * accepts `text/event-stream`, after `context`.
    */
   events: (request: Request, context: CallContext<TContext>) => Promise<Response>;
+  /**
+   * The scope for one caller, for server-side code that has their `ctx`:
+   * `resolveTags` runs once, and the scope compiles, checks tags and
+   * renders prompts with their saved tags. Without `resolveTags`, the host
+   * alone. Rejects as `resolveTags` fails: a `JigsError` it throws, or
+   * `INTERNAL`.
+   */
+  forUser: (call: {
+    ctx: TContext;
+    signal?: AbortSignal;
+  }) => Promise<UserScope>;
   /** The sandbox frame document, with its own content security policy. */
   frame: (request?: Request) => Response;
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigs.design/server",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "createJigsServer: checks and streams programs, runs procedures, and serves the sandbox frame.",
   "license": "MIT",
   "repository": {
@@ -29,11 +29,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@jigs.design/compiler": "0.3.5",
-    "@jigs.design/host": "0.3.5",
-    "@jigs.design/prompt": "0.3.5",
-    "@jigs.design/protocol": "0.3.5",
-    "@jigs.design/runtime": "0.3.5"
+    "@jigs.design/compiler": "0.3.6",
+    "@jigs.design/host": "0.3.6",
+    "@jigs.design/prompt": "0.3.6",
+    "@jigs.design/protocol": "0.3.6",
+    "@jigs.design/runtime": "0.3.6"
   },
   "peerDependencies": {
     "zod": "^4.0.0"