@mark1russell7/coeval 0.23.0 → 0.24.1

package/build/index.js

@@ -1568,7 +1568,7 @@ const MAX_TEXT_VALUES = 8;
 /** The most characters of one JSON value in the text of a type. */
 const MAX_TEXT_VALUE = 40;
 /** This function gives a short text of a JSON value for the text of a type. */
-function valueText$1(value) {
+function valueText$2(value) {
 	let text;
 	try {
 		text = JSON.stringify(value) ?? String(value);
@@ -1590,7 +1590,7 @@ function textAt(type, depth, wrap) {
 	if (term === "one") {
 		if (!Array.isArray(type["one"])) return "unknown";
 		const values = type["one"];
-		const shown = values.slice(0, MAX_TEXT_VALUES).map(valueText$1);
+		const shown = values.slice(0, MAX_TEXT_VALUES).map(valueText$2);
 		return group(values.length > MAX_TEXT_VALUES ? [...shown, `… ${values.length - MAX_TEXT_VALUES} more`] : shown);
 	}
 	if (term === "fn") {
@@ -3744,7 +3744,7 @@ function intersectCaps(a, b) {
 /** This function gives the capability rules of a kind that cover a part and change its capabilities. */
 function rulesFor(rules, path) {
 	if (rules === void 0 || rules.length === 0) return NO_RULES;
-	const out = rules.filter((rule) => rule.rule !== "same" && (rule.in === void 0 || rule.in.some((pattern) => pathMatches(path, pattern))));
+	const out = rules.filter((rule) => rule.rule !== "same" && rule.rule !== "grant" && (rule.in === void 0 || rule.in.some((pattern) => pathMatches(path, pattern))));
 	return out.length === 0 ? NO_RULES : out;
 }
 /** This function applies the rules that cover a part to the capabilities of its document. */
@@ -3768,6 +3768,53 @@ function capsUnder(rules, caps) {
 function partCaps(rules, path, caps) {
 	return capsUnder(rulesFor(rules, path), caps);
 }
+/** This function collects the values at a path in a value. The key `"*"` steps into each item of a list. */
+function collectAt(value, path, index, out) {
+	if (index === path.length) {
+		if (typeof value === "string" || Array.isArray(value) && value.every((key) => typeof key === "string" || typeof key === "number")) out.push(value);
+		return;
+	}
+	const key = path[index];
+	if (key === "*") {
+		if (Array.isArray(value)) for (const item of value) collectAt(item, path, index + 1, out);
+		return;
+	}
+	if (typeof value === "object" && value !== null) collectAt(value[key], path, index + 1, out);
+}
+/**
+* This function gives the capabilities that the rules `grant` of a kind give one part (CAP.GRANT). The check and the
+* walk read them from the document. The kernel gets the same list from the clauses of the runner.
+*
+* @param rules - The capability rules of the kind (`Kind.caps`).
+* @param path - The path of the part in the value of the document.
+* @param value - The value of the document.
+* @returns The capabilities that the rules add, or an empty list.
+*/
+function partGrants(rules, path, value) {
+	if (rules === void 0) return NO_CAPS$2;
+	let out;
+	for (const rule of rules) {
+		if (rule.rule !== "grant" || rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(path, pattern))) continue;
+		collectAt(value, rule.from, 0, out ??= []);
+	}
+	return out ?? NO_CAPS$2;
+}
+/**
+* The key of the frame of a context. Like the grant, it stays through a spread of a context, and only the kernel writes
+* it. It is not a root (D10): a document cannot read it (HANDLE.SEALED).
+*/
+const FRAME = /* @__PURE__ */ Symbol("coeval.frame");
+/** This function gives the frame of a context, when it has one. */
+function frameOf(ctx) {
+	return ctx[FRAME];
+}
+/** This function finds the frame and the clause that answer an effect. The innermost frame wins, then the first clause. */
+function clauseFor(start, keys) {
+	for (let frame = start; frame !== void 0; frame = frame.outer) for (const clause of frame.clauses) if (permits([clause.op], keys)) return {
+		frame,
+		clause
+	};
+}
 /**
 * The key of the grant of a context (CAP.NARROW-CODE): the capabilities that the kernel gave the document of the
 * context. A spread of a context keeps its grant. Thus compiled code passes the grant on in each context that it makes
@@ -4324,13 +4371,33 @@ var Session = class {
 		done.catch(() => void 0);
 		return effect.outcome = fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place });
 	}
+	/**
+	* This function finds the clause that answers an effect (D146). Without it, the effect goes on to the host. An effect
+	* without a capability gets no clause, thus `record` gives its `#CAP!` (HANDLE.NARROW). A clause of a frame that has
+	* ended gives `#CAP!`, because the capability came from that frame (HANDLE.ENDED).
+	*/
+	clauseOf(given, start, kind, place) {
+		const ctx = inEpoch(given, this.epoch) ? granted(given) : ungranted(given, this.epoch);
+		const keys = typeof kind === "string" ? kind.split(".") : kind;
+		if (!this.permitted(ctx, keys)) return void 0;
+		const found = clauseFor(start, keys);
+		if (found === void 0) return void 0;
+		if (found.frame.ended || found.frame.owner !== this) return fail("#CAP!", `The handler of the effect ${keys.join(".")} has ended.`, { place });
+		return found.clause;
+	}
 	effect(ctx, kind, payload, place) {
 		const text = typeof kind === "string" ? kind : kind.join(".");
 		if (this.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
+		const frame = frameOf(ctx);
+		const clause = frame === void 0 ? void 0 : this.clauseOf(ctx, frame, kind, place);
+		if (clause !== void 0) return "ok" in clause ? clause : drive$2(clause.answer(payload), text);
 		const made = this.record(ctx, kind, payload, place);
 		return "ok" in made ? made : this.answer(made, place);
 	}
 	*runEffect(ctx, kind, payload, place) {
+		const frame = frameOf(ctx);
+		const clause = frame === void 0 ? void 0 : this.clauseOf(ctx, frame, kind, place);
+		if (clause !== void 0) return "ok" in clause ? clause : yield* clause.answer(payload);
 		const made = this.record(ctx, kind, payload, place);
 		if ("ok" in made) return made;
 		const perform = this.perform;
@@ -4741,11 +4808,12 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	if (runner !== void 0) {
 		let inner;
 		try {
-			inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill);
+			inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill, kind?.caps?.some((rule) => rule.rule === "grant") === true);
 		} catch (error) {
 			return failingWith(c, meta, placed(thrown(error, `the runner ${name}`), place));
 		}
-		const run = placedRun(inner, place, name);
+		const guard = guardOf(c, place);
+		const run = placedRun(guard === void 0 ? inner : guardRun(inner, guard, c.machine.domains), place, name);
 		return finish$1(c, meta, runnerCode(run, place, kindText), run);
 	}
 	let inner;
@@ -4754,7 +4822,8 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	} catch (error) {
 		return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
 	}
-	const done = finish$1(c, meta, TOTAL.has(inner) ? inner : placedCode(inner, place, name), void 0);
+	const guard = guardOf(c, place);
+	const done = finish$1(c, meta, guard !== void 0 ? placedCode(guardCode(inner, guard, c.machine.domains), place, name) : TOTAL.has(inner) ? inner : placedCode(inner, place, name), void 0);
 	if (frees === void 0 || kind === void 0 || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
 	const free = freeOf(doc, kind, split.parts, frees);
 	if (free === void 0) return done;
@@ -5150,6 +5219,29 @@ function gated(rules, part) {
 * This function gives the steps of a runner, with the place of each error and of each exception. The steps get the
 * context that its grant permits (CAP.NARROW-CODE).
 */
+/** This function gives the key of a place in the guards of a plan. */
+function guardKey(place) {
+	return JSON.stringify(place.map(String));
+}
+/** This function gives the type of the boundary at a place, when the plan has one (PLAN.GUARD). */
+function guardOf(c, place) {
+	return c.guards?.get(guardKey(place));
+}
+/** This function gives the result of a part of a boundary: a value that is not a member gives `#VALUE!` (PLAN.GUARD). */
+function guarded(result, type, domains) {
+	if (!result.ok || member(result.value, type, domains)) return result;
+	return fail("#VALUE!", `The value is not a member of ${typeText(type)}, the type of its boundary.`);
+}
+/** This function adds the test of a boundary to the code of a part. */
+function guardCode(inner, type, domains) {
+	return (ctx, rt) => guarded(inner(ctx, rt), type, domains);
+}
+/** This function adds the test of a boundary to the steps of a part. */
+function guardRun(inner, type, domains) {
+	return function* (ctx, rt) {
+		return guarded(yield* inner(ctx, rt), type, domains);
+	};
+}
 function placedRun(inner, place, name) {
 	return function* (ctx, rt) {
 		try {
@@ -5241,7 +5333,35 @@ function interpret(fn, input, fill) {
 		});
 	};
 }
-function interpretRun(fn, input, fill) {
+/**
+* This function runs a part under a new frame (D146). The part gets the capabilities of the document and the kinds of
+* the clauses (CAP.GRANT), with the grant of the kernel. A rule around an effect narrows them as it narrows any other
+* capability (HANDLE.NARROW). The frame ends with the steps.
+*/
+function* handling(given, clauses, rt, run) {
+	const ctx = granted(given);
+	const frame = {
+		clauses,
+		outer: frameOf(ctx),
+		owner: rt,
+		ended: false
+	};
+	const caps = [...ctx.caps];
+	for (const clause of clauses) if (!permits(caps, clause.op)) caps.push(clause.op);
+	const inner = {
+		...ctx,
+		caps,
+		[GRANT]: caps,
+		[EPOCH]: epochOf(ctx),
+		[FRAME]: frame
+	};
+	try {
+		return yield* run(inner);
+	} finally {
+		frame.ended = true;
+	}
+}
+function interpretRun(fn, input, fill, grants) {
 	const { kind, typePath, doc, data, place, machine } = input;
 	const refill = input.fill;
 	const compiled = input.parts;
@@ -5251,7 +5371,8 @@ function interpretRun(fn, input, fill) {
 			key: part.key,
 			path: part.path,
 			...part.name === void 0 ? {} : { name: part.name },
-			evaluate: (override) => part.run(override === void 0 ? ctx : handed(ctx, override), rt)
+			evaluate: (override) => part.run(override === void 0 ? ctx : handed(ctx, override), rt),
+			...grants ? { handled: (clauses) => handling(ctx, clauses, rt, (inner) => part.run(inner, rt)) } : {}
 		}));
 		return fn({
 			kind,
@@ -5321,6 +5442,7 @@ function prepare(machine, doc, options = {}) {
 	const traced = options.trace === true;
 	const fold = !traced && options.fold !== false;
 	const fixed = fold ? fixedNamesOf(options.fixed?.names) : void 0;
+	const guards = options.guards === void 0 || options.guards.length === 0 ? void 0 : new Map(options.guards.map((each) => [guardKey(each.place), each.type]));
 	const c = {
 		machine,
 		traced,
@@ -5328,7 +5450,8 @@ function prepare(machine, doc, options = {}) {
 		verb,
 		noAnswer,
 		fold,
-		fixed
+		fixed,
+		guards
 	};
 	let root;
 	try {
@@ -5441,7 +5564,8 @@ function evaluate(machine, doc, context = makeContext(), options) {
 	const plan = prepare(machine, doc, {
 		trace: true,
 		...declaredType === void 0 ? {} : { declaredType },
-		...given.verb === void 0 ? {} : { verb: given.verb }
+		...given.verb === void 0 ? {} : { verb: given.verb },
+		...given.guards === void 0 ? {} : { guards: given.guards }
 	});
 	const ctx = rootContext(machine, context);
 	const s = new Session(machine, ctx.caps, false, true, given.perform, void 0, void 0, readingOf(given.reads, ctx));
@@ -5462,6 +5586,7 @@ async function run(machine, doc, context = makeContext(), options = {}) {
 	const plan = prepare(machine, doc, {
 		trace: true,
 		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...options.guards === void 0 ? {} : { guards: options.guards },
 		...options.verb === void 0 ? {} : { verb: options.verb }
 	});
 	const ctx = rootContext(machine, context);
@@ -5729,6 +5854,72 @@ const STD_WORLD = {
 			lazy: [{ after: 1 }],
 			summary: "It evaluates its part without capabilities, thus an effect in it fails."
 		},
+		handle: {
+			verbs: {
+				eval: "control.handle",
+				view: "view.op"
+			},
+			parts: {
+				shape: "record",
+				fields: {
+					with: {
+						shape: "list",
+						item: {
+							shape: "record",
+							fields: {
+								op: { shape: "none" },
+								do: { shape: "term" },
+								abort: { shape: "term" }
+							},
+							required: ["op"],
+							closed: true
+						}
+					},
+					return: { shape: "term" },
+					body: { shape: "term" }
+				},
+				required: ["with", "body"],
+				closed: true
+			},
+			scope: [{
+				names: { fixed: ["payload"] },
+				in: [[
+					"with",
+					"*",
+					"do"
+				], [
+					"with",
+					"*",
+					"abort"
+				]]
+			}, {
+				names: { fixed: ["result"] },
+				in: [["return"]]
+			}],
+			caps: [{
+				rule: "grant",
+				from: [
+					"with",
+					"*",
+					"op"
+				],
+				in: [["body"]]
+			}],
+			lazy: [{ in: [
+				[
+					"with",
+					"*",
+					"do"
+				],
+				[
+					"with",
+					"*",
+					"abort"
+				],
+				["return"]
+			] }],
+			summary: "It answers the effects of its body with its clauses, in place, thus a mock, a retry or a log is a document."
+		},
 		log: {
 			verbs: {
 				eval: "effect.log",
@@ -5766,7 +5957,8 @@ const STD_WORLD = {
 * A literal in a place that takes a document gets its data envelope (K159, D65). Such a place is a part of `if`,
 * `list`, `seq` or `pure`, the value of `write`, or the whole text. The document after a header name is such a place
 * too. Thus `list(1, "a")` evaluates to `[1, "a"]`. The forms `add`, `multiply` and `greater` write an operator document that its operator
-* does not write, for example `add(5)` (K163).
+* does not write, for example `add(5)` (K163). The field `with` of `handle` is a field of data, thus each clause is a
+* record between braces in a list between brackets (D177).
 *
 * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
 * the formula kit.
@@ -5906,6 +6098,18 @@ const WORLD_SYNTAX = /* @__PURE__ */ Object.freeze({
 				kind: "tree.quote",
 				args: "literal"
 			},
+			{
+				name: "handle",
+				kind: "handle",
+				args: "named",
+				fields: [
+					"with",
+					"return",
+					"body"
+				],
+				data: ["with"],
+				wrap: ["return", "body"]
+			},
 			{
 				name: "add",
 				kind: "add"
@@ -6362,6 +6566,7 @@ function leaderOnHost(n, key, rule, host) {
 /**
 * This function gives an attribute of a node with circular attributes, or an attribute in an open fixed point (D113).
 * The memo and the marks of the node do not hold the attribute. An open fixed point does not use the cells of the host.
+* With the cells of a host, only a circular attribute comes here outside a fixed point. A plain attribute takes its cell.
 */
 function circularRead(n, key) {
 	const rule = circularRule(n.tree, key);
@@ -6776,7 +6981,7 @@ function treeThing(input, place, build, outer, host) {
 		const text = attributeText(key, type, place);
 		if (marks.has(key)) return busyAt(state, key);
 		if (tree === void 0 && up?.tree === void 0 && !parts.some((item) => item.key === key)) return void 0;
-		if (circular || openPoint !== void 0) return circularRead(state, key);
+		if (openPoint !== void 0 || circular && circularRule(tree, key) !== void 0) return circularRead(state, key);
 		marks.set(key, BUSY);
 		demands.push({
 			cells: marks,
@@ -7103,6 +7308,30 @@ function* inOrder(parts) {
 	}
 	return { values };
 }
+/** This function tells if a value names a kind of effects: a text, or a list of keys. */
+function isOp(value) {
+	return typeof value === "string" || Array.isArray(value) && value.every(isKey);
+}
+/**
+* This function gives the runner of an `if` with its own truth (RUN.IF-TRUTH). A branch can wait for the host, thus a
+* language with the function `truthy` of a profile does not need a copy of `if`. A missing test and a test without a
+* truth give `#VALUE!`, a failed test gives its failure, and a missing branch gives `null`.
+*
+* @param truth - The function that gives the truth of a value, or `undefined` for a value without a truth.
+* @returns The runner.
+*/
+function ifRunner(truth) {
+	return function* ({ parts }) {
+		const test = parts.find((part) => part.key === "test");
+		if (test === void 0) return fail("#VALUE!", "if needs a test.");
+		const chosen = yield* test.evaluate();
+		if (!chosen.ok) return chosen;
+		const held = truth(chosen.value);
+		if (held === void 0) return fail("#VALUE!", "The test of if must give a truth value.");
+		const branch = parts.find((part) => part.key === (held ? "then" : "else"));
+		return branch === void 0 ? ok(null) : yield* branch.evaluate();
+	};
+}
 /**
 * The runners of the standard world, by name: the kinds that can hold effects. Each one evaluates its parts in
 * order. In a run, an effect ends before the next step starts.
@@ -7134,15 +7363,44 @@ const STD_RUNNERS = {
 		if (only === void 0 || parts.length > 1) return fail("#VALUE!", "pure needs exactly one part.");
 		return yield* only.evaluate();
 	},
-	"control.if": function* ({ parts }) {
-		const test = parts.find((part) => part.key === "test");
-		if (test === void 0) return fail("#VALUE!", "if needs a test.");
-		const chosen = yield* test.evaluate();
-		if (!chosen.ok) return chosen;
-		if (typeof chosen.value !== "boolean") return fail("#VALUE!", "The test of if must give a truth value.");
-		const branch = parts.find((part) => part.key === (chosen.value === true ? "then" : "else"));
-		return branch === void 0 ? ok(null) : yield* branch.evaluate();
+	"control.handle": function* ({ value, context }) {
+		const { with: list, return: after, body } = value;
+		if (body?.handled === void 0) return fail("#VALUE!", "handle needs a body.");
+		let stopped;
+		const clauses = [];
+		for (const item of list) {
+			const part = item.do ?? item.abort;
+			if (!isOp(item.op)) return fail("#VALUE!", "The op of a clause of handle must be a text or a list of keys.");
+			if (part === void 0 || item.do !== void 0 && item.abort !== void 0) return fail("#VALUE!", "Each clause of handle needs exactly one of do and abort.");
+			const stops = item.do === void 0;
+			clauses.push({
+				op: item.op,
+				answer: function* (payload) {
+					const result = yield* part.evaluate({
+						...context,
+						names: {
+							...context.names,
+							payload
+						}
+					});
+					if (!stops) return result;
+					stopped ??= result;
+					return fail("#CALC!", "A clause abort of handle stopped the body.");
+				}
+			});
+		}
+		const result = yield* body.handled(clauses);
+		if (stopped !== void 0) return stopped;
+		if (!result.ok || after === void 0) return result;
+		return yield* after.evaluate({
+			...context,
+			names: {
+				...context.names,
+				result: result.value
+			}
+		});
 	},
+	"control.if": /* @__PURE__ */ ifRunner((value) => typeof value === "boolean" ? value : void 0),
 	"list.all": function* ({ parts }) {
 		const all = yield* inOrder(parts);
 		return "error" in all ? all.error : ok(all.values);
@@ -7565,6 +7823,26 @@ const CONSTRUCTS = [
 * narrows the capabilities for each part, thus the host does not give this type.
 */
 const CAPS_TYPE = { list: { union: ["text", { list: { union: ["text", "number"] } }] } };
+/**
+* This function gives the boundaries of a check. A part with an imprecise type at a position that needs a type is a
+* boundary. A read of a known type is a boundary too, because the check trusts the root types (PLAN.GUARD-BOUNDARY).
+*
+* @param typing - The places of a check of types.
+* @param domains - The domains of the machine.
+* @returns The boundaries, in the order of the document.
+*/
+function boundariesOf(typing, domains) {
+	const found = [];
+	for (const item of typing.places) if (item.expected !== void 0 && item.expected !== "unknown" && !isPrecise(item.type, domains)) found.push({
+		place: item.place,
+		type: item.expected
+	});
+	else if (item.read === true && item.type !== "unknown") found.push({
+		place: item.place,
+		type: item.type
+	});
+	return found;
+}
 /** The roots that can change, as a rule gives them in `PartType.roots`. */
 const CHANGING = [
 	"self",
@@ -7584,7 +7862,7 @@ function pathKey(path) {
 function ruleOf(machine, name) {
 	if (name === void 0 || machine.runners !== void 0 && Object.hasOwn(machine.runners, name)) return void 0;
 	const evaluator = Object.hasOwn(machine.evaluators, name) ? machine.evaluators[name] : void 0;
-	const rule = typeof evaluator === "object" && evaluator !== null ? evaluator.type : void 0;
+	const rule = typeof evaluator === "object" && evaluator !== null || typeof evaluator === "function" ? evaluator.type : void 0;
 	return typeof rule === "object" && rule !== null && typeof rule.synth === "function" ? rule : void 0;
 }
 /** This function gives the order of the parts of a document: first the parts that give the names of a rule `keysAt`. */
@@ -7765,9 +8043,11 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 	}
 	const places = nodes.map((node, index) => {
 		const want = needed[index];
+		const read = !node.marked && ruleOf(machine, node.evaluator)?.read === true;
 		const entry = {
 			type: types[index] ?? "unknown",
-			...want === void 0 ? {} : { expected: want }
+			...want === void 0 ? {} : { expected: want },
+			...read ? { read } : {}
 		};
 		Object.defineProperty(entry, "place", {
 			enumerable: true,
@@ -9180,11 +9460,12 @@ var Visit = class {
 	typePath;
 	address;
 	caps;
+	handled;
 	#place;
 	#at;
 	#bound;
 	#expect;
-	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps, bound, expect) {
+	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps, bound, expect, handled) {
 		this.doc = doc;
 		this.declared = declared;
 		this.depth = depth;
@@ -9196,6 +9477,7 @@ var Visit = class {
 		this.typePath = typePath;
 		this.address = address;
 		this.caps = caps;
+		this.handled = handled;
 		this.#place = place;
 		this.#at = at;
 		this.#bound = bound;
@@ -9241,6 +9523,7 @@ function walk(world, doc, visit, options = {}) {
 		slot: [],
 		parent: void 0,
 		caps: options.caps,
+		handled: void 0,
 		bound: [],
 		expect: void 0
 	}];
@@ -9257,7 +9540,7 @@ function walk(world, doc, visit, options = {}) {
 			continue;
 		}
 		const { doc, kind, split } = read;
-		const here = new Visit(item.place, item.at, doc, read.declared, item.depth, item.names, item.later, item.slot, item.parent, kind, read.typePath, item.address ? true : void 0, item.caps, item.bound, item.expect);
+		const here = new Visit(item.place, item.at, doc, read.declared, item.depth, item.names, item.later, item.slot, item.parent, kind, read.typePath, item.address ? true : void 0, item.caps, item.bound, item.expect, item.handled);
 		if (visit(here) === "skip" || kind === void 0) continue;
 		const base = read.declared ? item.at : {
 			up: item.at,
@@ -9276,10 +9559,13 @@ function walk(world, doc, visit, options = {}) {
 			continue;
 		}
 		const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
+		const grantRules = kind.caps !== void 0 && kind.caps.some((rule) => rule.rule === "grant") ? kind.caps : void 0;
 		for (let index = split.parts.length - 1; index >= 0; index -= 1) {
 			const slot = split.parts[index];
 			const extra = sees[index] ?? [];
 			const hidden = later[index] ?? [];
+			const grants = grantRules === void 0 ? void 0 : partGrants(grantRules, slot.path, doc.value);
+			const granted = grants !== void 0 && grants.length > 0 ? grants : void 0;
 			stack.push({
 				value: slot.item,
 				place: slot.path.length === 0 ? item.place : {
@@ -9297,7 +9583,8 @@ function walk(world, doc, visit, options = {}) {
 				address: slot.address === true,
 				slot: slot.path,
 				parent: here,
-				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : partCaps(kind.caps, slot.path, item.caps),
+				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : granted === void 0 ? partCaps(kind.caps, slot.path, item.caps) : [...partCaps(kind.caps, slot.path, item.caps), ...granted],
+				handled: granted === void 0 ? item.handled : [...item.handled ?? [], ...granted],
 				bound: extra,
 				expect: slot.expect
 			});
@@ -9387,6 +9674,28 @@ function mapRefs(world, doc, change, options = {}) {
 	return out;
 }
 /**
+* This function changes the documents of a document, from the root to the parts (STATIC.MAPDOCS). The function
+* `change` reads only the original documents. It decides at each node, and it can stop at a node. The kinds of a
+* position come from the world, thus this function names no kind. The document is not changed: the function gives a
+* new document that shares each part without a change.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param change - The function that gives the answer for each visit. See `DocChange`.
+* @param options - The type of a bare root value, and the names that the host binds at the root.
+* @returns The new document, or `doc` itself when no document changes.
+*/
+function mapDocs(world, doc, change, options = {}) {
+	let out = doc;
+	walk(world, doc, (visit) => {
+		const next = change(visit);
+		if (next === void 0 || next === "skip") return next;
+		out = setAt(out, visit.at, next.to);
+		return next.into === true ? void 0 : "skip";
+	}, options);
+	return out;
+}
+/**
 * This function gives the parts that the code of a runner evaluates itself, without a wait (RUN.DRIVES, D119). The
 * answer of the hook `facts` for the code wins over the contract. The contract describes only the code of its kind for
 * `eval`. Without a declaration, the runner passes each wait of its parts through.
@@ -9708,6 +10017,7 @@ const KEEPS_SELF = /* @__PURE__ */ new Set([
 	"control.seq",
 	"control.pure",
 	"control.if",
+	"control.handle",
 	"list.all",
 	"effect.log",
 	"effect.write"
@@ -10272,7 +10582,7 @@ function reaching(machine, doc, options) {
 	const rule = options.caps === void 0 ? permits : permitsOf(machine);
 	walk(machine.world, doc, (v) => {
 		const caps = v.caps ?? EACH;
-		for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind)) out.push({
+		for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind) && (v.handled === void 0 || !permits(v.handled, kind))) out.push({
 			kind,
 			visit: v
 		});
@@ -10952,39 +11262,42 @@ function formulaTypes(profile) {
 	});
 	return {
 		"formula.lit": { synth: (input) => valueType(input.doc.value) },
-		"formula.ref": { synth: (input, report) => {
-			const path = input.doc.value;
-			if (input.address || !Array.isArray(path) || path.length === 0) return "unknown";
-			const domains = input.machine.domains;
-			const plain = input.machine.plain === true;
-			let type;
-			let start;
-			if (path[0] === "names") {
-				const name = path[1];
-				if (!isKey(name) || !plain && HEADER_KEYS.has(String(name))) return "unknown";
-				type = input.nameType(String(name)) ?? "unknown";
-				start = 2;
-			} else {
-				type = input.rootType(String(path[0]));
-				start = 1;
-			}
-			for (let index = start;; index += 1) {
-				if (isUnknown(type, domains) || !plain && holdsEnvelope(type, domains)) return "unknown";
-				if (index >= path.length) return type;
-				const step = path[index];
-				if (!isKey(step)) {
-					type = walkType(input, step, type);
-					continue;
+		"formula.ref": {
+			read: true,
+			synth: (input, report) => {
+				const path = input.doc.value;
+				if (input.address || !Array.isArray(path) || path.length === 0) return "unknown";
+				const domains = input.machine.domains;
+				const plain = input.machine.plain === true;
+				let type;
+				let start;
+				if (path[0] === "names") {
+					const name = path[1];
+					if (!isKey(name) || !plain && HEADER_KEYS.has(String(name))) return "unknown";
+					type = input.nameType(String(name)) ?? "unknown";
+					start = 2;
+				} else {
+					type = input.rootType(String(path[0]));
+					start = 1;
 				}
-				const next = stepType(type, step, domains, input.contract);
-				if ("missing" in next) {
-					const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
-					report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
-					return "unknown";
+				for (let index = start;; index += 1) {
+					if (isUnknown(type, domains) || !plain && holdsEnvelope(type, domains)) return "unknown";
+					if (index >= path.length) return type;
+					const step = path[index];
+					if (!isKey(step)) {
+						type = walkType(input, step, type);
+						continue;
+					}
+					const next = stepType(type, step, domains, input.contract);
+					if ("missing" in next) {
+						const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
+						report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
+						return "unknown";
+					}
+					type = next.type;
 				}
-				type = next.type;
 			}
-		} },
+		},
 		"formula.record": {
 			part: (input, path) => {
 				const want = fieldOf(input.expected, String(path[0]), input.machine.domains);
@@ -11937,6 +12250,28 @@ function freeIn(root, ctx, path) {
 	const bound = Object.hasOwn(ctx.names, key);
 	return bound === Object.hasOwn(root.names, key) && (!bound || Object.is(ctx.names[key], root.names[key]));
 }
+/** The key of the frame of a context. */
+const REF_FRAME = /* @__PURE__ */ Symbol("coeval.reference.frame");
+/** This function gives the frame of a context. */
+function refFrame(ctx) {
+	return ctx[REF_FRAME];
+}
+/**
+* This function finds the clause for an effect (HANDLE.DO, HANDLE.FORWARD). An effect without a capability gets no clause
+* (HANDLE.NARROW). A clause of a frame that has ended gives `#CAP!` (HANDLE.ENDED).
+*/
+function clauseAt(env, ctx, kind, place) {
+	let frame = refFrame(ctx);
+	if (frame === void 0) return void 0;
+	const keys = typeof kind === "string" ? kind.split(".") : kind;
+	const machine = env.machine;
+	if (!(machine.permits === void 0 ? permits(ctx.caps, keys) : machine.permits(ctx.caps, keys, ctx))) return void 0;
+	for (; frame !== void 0; frame = frame.outer) for (const clause of frame.clauses) {
+		if (!permits([clause.op], keys)) continue;
+		if (frame.ended || frame.owner !== env.effects) return fail("#CAP!", `The handler of the effect ${keys.join(".")} has ended.`, { place });
+		return clause;
+	}
+}
 /**
 * This function causes an effect when the capabilities permit it (RUN.CAP, CAP.HOOK). It records the effect with its
 * address (RUN.ADDRESS) and its outcome (RUN.OUTCOME). The mock answers the effect at once (RUN.MOCK). Without a
@@ -11955,6 +12290,8 @@ function cause(env, ctx, kind, payload, place) {
 function causeFromEvaluator(env, ctx, kind, payload, place) {
 	const text = typeof kind === "string" ? kind : kind.join(".");
 	if (env.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
+	const clause = clauseAt(env, ctx, kind, place);
+	if (clause !== void 0) return "ok" in clause ? clause : drive$1(clause.answer(payload), place, text);
 	return cause(env, ctx, kind, payload, place);
 }
 /**
@@ -11963,6 +12300,8 @@ function causeFromEvaluator(env, ctx, kind, payload, place) {
 * (RUN.OUTCOME).
 */
 function* causeAndWait(env, ctx, kind, payload, place) {
+	const clause = clauseAt(env, ctx, kind, place);
+	if (clause !== void 0) return "ok" in clause ? clause : yield* clause.answer(payload);
 	if (!env.running) return cause(env, ctx, kind, payload, place);
 	const effect = recordEffect(env, ctx, kind, payload, place);
 	if ("ok" in effect) return effect;
@@ -12109,6 +12448,28 @@ function evalInput(env, seen, at) {
 		fill
 	};
 }
+/** This function evaluates a part under a frame: the part also gets the kinds of the clauses (CAP.GRANT). */
+function* handledAt(env, part, clauses) {
+	const frame = {
+		clauses,
+		outer: refFrame(part.ctx),
+		owner: env.effects,
+		ended: false
+	};
+	const ctx = {
+		...part.ctx,
+		caps: [...part.ctx.caps, ...clauses.map((clause) => clause.op)],
+		[REF_FRAME]: frame
+	};
+	try {
+		return yield* stepsAt(env, {
+			...part,
+			ctx
+		});
+	} finally {
+		frame.ended = true;
+	}
+}
 function runInput(env, seen, at) {
 	const { split, doc } = seen;
 	const parts = split.parts.map((slot) => {
@@ -12117,7 +12478,8 @@ function runInput(env, seen, at) {
 			key: slot.key,
 			path: slot.path,
 			...name === void 0 ? {} : { name },
-			evaluate: (given) => stepsAt(env, partAt(seen, at, slot, given))
+			evaluate: (given) => stepsAt(env, partAt(seen, at, slot, given)),
+			handled: (clauses) => handledAt(env, partAt(seen, at, slot, void 0), clauses)
 		};
 	});
 	const fill = (items) => split.parts.length === 0 ? doc.value : split.fill(items);
@@ -14444,6 +14806,14 @@ function readsUnknown(reads) {
 function resolutions(reads) {
 	return reads.filter((read) => read.free && read.kept !== true);
 }
+/** This function gives the text of a value of a trace. It does not throw for a bigint or a record with a cycle. */
+function valueText$1(value) {
+	try {
+		return JSON.stringify(value) ?? describe(value);
+	} catch {
+		return describe(value);
+	}
+}
 function pathText(path) {
 	if (path === void 0) return "no read";
 	try {
@@ -14599,6 +14969,96 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 		reads: compared
 	};
 }
+/** The type errors of the kernel, by the evaluator that gives them (STATIC.TYPES-AGREE). */
+const TYPE_ERRORS = {
+	"formula.op": "#NAME?",
+	"formula.if": "#VALUE!",
+	"formula.and": "#VALUE!",
+	"formula.or": "#VALUE!"
+};
+/**
+* This function examines the agreement rule for types (STATIC.TYPES-AGREE, D148). A document with no issue evaluates
+* with a trace. Each value of the trace is a member of the type of its place. A value of a precise type is also a member
+* of the type that its position needs. No document with precise parts gives a type error of the kernel.
+*
+* A language imports this function for its own property tests, with `agree`. A failure tells that a signature, a type
+* rule, a cover or a root type does not hold. A value that breaks a position of an imprecise type ends the promise, and
+* the result then has `checked: false` (TYPE.GRADUAL).
+*
+* @param machine - The world and the code of the evaluators, with their type rules.
+* @param doc - The document.
+* @param context - The context. Its roots are members of the root types.
+* @param options - The options of `check`, with the root types, and `guards`.
+* @returns The agreement, or the first place that breaks it.
+*/
+function agreeTypes(machine, doc, context = makeContext(), options = {}) {
+	const typing = typeCheck(machine, doc, options);
+	if (typing.issues.length > 0) return {
+		ok: true,
+		checked: false,
+		values: 0
+	};
+	const keyOf = (path) => JSON.stringify(path.map(String));
+	const places = new Map(typing.places.map((item) => [keyOf(item.place), item]));
+	const domains = machine.domains;
+	const guards = options.guards === true ? boundariesOf(typing, domains) : void 0;
+	const stack = [evaluate(machine, doc, context, {
+		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...guards === void 0 ? {} : { guards }
+	}).trace];
+	const nodes = [];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		nodes.push(node);
+		stack.push(...node.children);
+	}
+	for (const node of nodes) {
+		const place = places.get(keyOf(node.path));
+		if (place?.expected === void 0 || !node.result.ok || isPrecise(place.type, domains)) continue;
+		if (!member(node.result.value, place.expected, domains)) return {
+			ok: true,
+			checked: false,
+			values: 0
+		};
+	}
+	let values = 0;
+	for (const node of nodes.reverse()) {
+		const place = places.get(keyOf(node.path));
+		if (place === void 0) continue;
+		const at = node.path.map(String);
+		if (!node.result.ok) {
+			const parts = node.children.map((child) => places.get(keyOf(child.path)));
+			const decided = node.children.every((child) => child.result.ok) && parts.every((part) => part?.expected !== void 0 && isPrecise(part.type, domains));
+			const code = TYPE_ERRORS[node.answer.evaluator ?? ""];
+			if (decided && node.result.error.code === code) return {
+				ok: false,
+				clause: "error",
+				place: at,
+				reason: `The document gives ${code}, but it checks with no issue.`
+			};
+			continue;
+		}
+		const value = node.result.value;
+		values += 1;
+		if (!member(value, place.type, domains)) return {
+			ok: false,
+			clause: "value",
+			place: at,
+			reason: `The value ${valueText$1(value)} is not a member of ${typeText(place.type)}.`
+		};
+		if (place.expected !== void 0 && !member(value, place.expected, domains)) return {
+			ok: false,
+			clause: "argument",
+			place: at,
+			reason: `The value ${valueText$1(value)} is not a member of the needed type ${typeText(place.expected)}.`
+		};
+	}
+	return {
+		ok: true,
+		checked: true,
+		values
+	};
+}
 // src/codec-laws.ts
 /** The order of the laws in the list of findings. */
 const ORDER$1 = [
@@ -15022,6 +15482,13 @@ function compileConstructs(given, ops) {
 		constructKinds
 	};
 }
+/** This function examines the field `domain` of a call form (D141). A form `literal` of `ext.domain` needs a name, and each other form refuses it. */
+function compileDomain(given, args) {
+	const writes = args === "literal" && given.kind === "ext.domain";
+	if (writes && (typeof given.domain !== "string" || given.domain === "")) throw new TypeError(`The call form "${given.name}" of ext.domain needs the name of its domain.`);
+	if (!writes && given.domain !== void 0) throw new TypeError(`The call form "${given.name}" takes no domain: only a form literal of ext.domain has one.`);
+	return given.domain;
+}
 /** This function examines the field `wrap` of a call form (K159). A name that is not a field of the form throws. */
 function compileWrap(given, args) {
 	const wrap = given.wrap;
@@ -15033,6 +15500,16 @@ function compileWrap(given, args) {
 	return new Set(wrap);
 }
 /** This function gives the types of the data envelopes of a profile (K159), or `undefined` without them. */
+/** This function examines the field `data` of a call form (D177). Each name is a field of the form, and no name is in `wrap`. */
+function compileData(given, wrap) {
+	const data = given.data ?? [];
+	if (data.length > 0 && given.fields === void 0) throw new TypeError(`The call form "${given.name}" takes data only with fields.`);
+	for (const name of data) {
+		if (given.fields?.includes(name) !== true) throw new TypeError(`The call form "${given.name}" has no field ${name} for its data.`);
+		if (wrap === true || wrap !== false && wrap.has(name)) throw new TypeError(`The call form "${given.name}" has the field ${name} in wrap and in data.`);
+	}
+	return new Set(data);
+}
 function compileEnvelopes(given) {
 	if (given === void 0) return void 0;
 	const out = {};
@@ -15069,17 +15546,22 @@ function compileProfile(profile) {
 		if (!FORM_ARGS.includes(args)) throw new TypeError(`The call form "${given.name}" has the unknown arguments ${String(args)}.`);
 		if (args === "fields" !== (given.fields !== void 0) && args !== "named") throw new TypeError(`The call form "${given.name}" with the arguments ${args} ${args === "fields" ? "needs" : "takes no"} fields.`);
 		if (given.min !== void 0 && (args === "named" || args === "literal")) throw new TypeError(`The call form "${given.name}" with the arguments ${args} takes no min.`);
+		const wrap = compileWrap(given, args);
 		const form = {
 			name: given.name,
 			type,
 			args,
 			fields: given.fields,
 			min: given.min ?? given.fields?.length ?? 0,
-			wrap: compileWrap(given, args)
+			wrap,
+			domain: compileDomain(given, args),
+			data: compileData(given, wrap)
 		};
 		forms.set(form.name, form);
 		addTo(formsByKind, key, form);
 	}
+	const brackets = [...forms.values()].some((form) => form.data.size > 0);
+	for (const symbol of brackets ? [...ops.prefixSymbols, ...ops.binarySymbols] : []) if (/^[[\]{}]/.test(symbol)) throw new TypeError(`The operator "${symbol}" reads the text of a field of data.`);
 	const compiled = {
 		...ops,
 		numbers: literals.numbers ?? true,
@@ -15111,7 +15593,8 @@ function compileProfile(profile) {
 			...ops.opWords,
 			...roots
 		]),
-		maxDepth: profile.maxDepth ?? 256
+		maxDepth: profile.maxDepth ?? 256,
+		brackets
 	};
 	compiledProfiles.set(profile, compiled);
 	return compiled;
@@ -15570,7 +16053,7 @@ var Parser = class {
 	}
 	/** This method stops at a token where a group or a list must end. A list can also continue with its separator. */
 	noEnd(close, list) {
-		const closer = close === ")" ? "parenthesis" : "brace";
+		const closer = closerName(close);
 		const before = list ? `"${this.syn.separator}" or a ` : "";
 		return this.stop(`A ${before}closing ${closer} is missing.`, this.pos, this.tokenLength());
 	}
@@ -15595,16 +16078,31 @@ var Parser = class {
 				this.pos += 1;
 				return args;
 			}
-			if (this.pos >= this.text.length) this.stop(`A closing ${close === ")" ? "parenthesis" : "brace"} is missing.`, open, 1);
+			if (this.pos >= this.text.length) this.stop(`A closing ${closerName(close)} is missing.`, open, 1);
 			this.noEnd(close, true);
 		}
 	}
 	/**
-	* This method reads the entries `key: expr` into a record: the arguments of a form `named` (SYNTAX.RECORD), or the
-	* entries between braces without a form (SYNTAX.RECORD-TEXT).
+	* This method reads the argument of a field of data (D177): a list between brackets, a record between braces, or a
+	* document. A literal in it stays its data.
+	*/
+	data() {
+		this.skip();
+		const start = this.pos;
+		const c = this.text[start];
+		if (c !== "[" && c !== "{") return this.bound();
+		this.depth += 1;
+		if (this.depth > this.syn.maxDepth) this.stop(`The text is deeper than ${String(this.syn.maxDepth)} levels.`, start, 0);
+		const value = c === "[" ? this.argumentsOf(() => this.data(), "]") : this.entries(void 0, true);
+		this.depth -= 1;
+		return value;
+	}
+	/**
+	* This method reads the entries `key: expr` into a record. The record is the arguments of a form `named`
+	* (SYNTAX.RECORD), or the entries between braces (SYNTAX.RECORD-TEXT). It is also a record of data (D177).
 	*/
-	entries(form) {
-		const owner = form === void 0 ? "record" : `form ${form.name}`;
+	entries(form, data = false) {
+		const owner = data ? "record of data" : form === void 0 ? "record" : `form ${form.name}`;
 		const value = {};
 		const entry = () => {
 			this.skip();
@@ -15614,9 +16112,10 @@ var Parser = class {
 			this.skip();
 			if (key === void 0 || this.text[this.pos] !== ":") this.stop(`Each ${form === void 0 ? "entry" : "argument"} of the ${owner} is a key, a ":" and a document.`, at, Math.max(end - at, this.tokenLength()));
 			if (form?.fields !== void 0 && !form.fields.includes(key)) this.stop(`The form ${form.name} has no field ${key}.`, at, end - at);
+			if (data && key === "type") this.stop("A record of data has no key type, because the key type makes a document.", at, end - at);
 			if (Object.hasOwn(value, key)) this.stop(`The ${owner} has the field ${key} two times.`, at, end - at);
 			this.pos += 1;
-			const arg = this.bound();
+			const arg = data || form?.data.has(key) === true ? this.data() : this.bound();
 			setOwn$1(value, key, form !== void 0 && wraps(form, key) ? envelop(this.syn, arg) : arg);
 		};
 		this.argumentsOf(entry, form === void 0 ? "}" : ")");
@@ -15625,11 +16124,19 @@ var Parser = class {
 	call(name, start, nameLength) {
 		const form = this.syn.forms.get(name);
 		if (form?.args === "named") return opDoc(form, this.entries(form));
-		const args = this.argumentsOf(() => this.bound());
+		let index = 0;
+		const args = this.argumentsOf(() => {
+			const key = form?.fields?.[index];
+			index += 1;
+			return key !== void 0 && form?.data.has(key) === true ? this.data() : this.bound();
+		});
 		if (form?.args === "literal") {
 			const [only] = args;
 			if (args.length !== 1 || !isScalar(only)) this.stop(`The form ${name} takes one literal that JSON writes.`, start, this.pos - start);
-			return opDoc(form, only);
+			return opDoc(form, form.domain === void 0 ? only : {
+				domain: form.domain,
+				data: only
+			});
 		}
 		if (form !== void 0) {
 			const most = form.fields?.length ?? Number.POSITIVE_INFINITY;
@@ -15655,15 +16162,20 @@ var Parser = class {
 /** The end of a recovery. The class `Recovery` throws it, and its method `run` catches it. */
 var End = class {};
 function hasBraces(syn) {
-	return syn.constructs.record !== void 0 || syn.constructs.let !== void 0;
+	return syn.constructs.record !== void 0 || syn.constructs.let !== void 0 || syn.brackets;
+}
+/** This function gives the name of a closer in a message. */
+function closerName(close) {
+	return close === ")" ? "parenthesis" : close === "]" ? "bracket" : "brace";
 }
 /** This function gives the closer of an opening bracket of a profile, or `undefined` for each other character. */
 function closerOf(syn, c) {
 	if (c === "(") return ")";
+	if (c === "[" && syn.brackets) return "]";
 	return c === "{" && hasBraces(syn) ? "}" : void 0;
 }
 function isCloser(syn, c) {
-	return c === ")" || c === "}" && hasBraces(syn);
+	return c === ")" || c === "]" && syn.brackets || c === "}" && hasBraces(syn);
 }
 /** This function gives the position after a quoted text at `at`, or after one other character. An open quote gives `Infinity`. */
 function pastToken(syn, text, at) {
@@ -15906,6 +16418,7 @@ function refShape(syn, value) {
 }
 function callName(syn, keys) {
 	if (keys.length === 0 || !keys.every((key) => typeof key === "string" && NAME.test(key))) return void 0;
+	if (keys.length > 1 && !syn.fields) return void 0;
 	const name = keys.join(".");
 	if (syn.forms.has(name) || syn.opWords.has(keys[0])) return void 0;
 	return syn.ops === true || syn.ops.has(name) ? name : void 0;
@@ -15928,10 +16441,16 @@ function wrappedShape(syn, doc) {
 	const literal = literalShape(syn, doc.value);
 	return literal.tag === "text" ? literal : void 0;
 }
+/** This function tells if a value of `ext.domain` is a record with this domain and its data, and no other key. */
+function holdsDomain(value, domain) {
+	return isRecord(value) && value["domain"] === domain && Object.hasOwn(value, "data") && Object.keys(value).length === 2;
+}
 function formShape(syn, form, value) {
 	if (form.args === "literal") {
-		if (!isScalar(value)) return void 0;
-		const literal = literalShape(syn, value);
+		if (form.domain !== void 0 && !holdsDomain(value, form.domain)) return void 0;
+		const data = form.domain === void 0 ? value : value["data"];
+		if (!isScalar(data)) return void 0;
+		const literal = literalShape(syn, data);
 		return literal.tag === "text" ? {
 			tag: "text",
 			text: `${form.name}(${literal.text})`
@@ -15947,7 +16466,8 @@ function formShape(syn, form, value) {
 			args: keys.map((key) => [
 				key,
 				value[key],
-				wraps(form, key)
+				wraps(form, key),
+				form.data.has(key)
 			]),
 			named: true
 		};
@@ -15974,7 +16494,8 @@ function formShape(syn, form, value) {
 		args: present.map((key) => [
 			key,
 			value[key],
-			wraps(form, key)
+			wraps(form, key),
+			form.data.has(key)
 		])
 	};
 }
@@ -16110,6 +16631,18 @@ function bracesText(syn, record, path, sub) {
 	if (!texts.ok) return texts;
 	return ok(`{${texts.value.map((text, index) => `${keyText(keys[index])}: ${text}`).join(`${syn.separator} `)}}`);
 }
+/**
+* This function writes the argument of a field of data (D177): a list between brackets, or a record between braces.
+* The function `sub` writes a literal and a document. A record that is an envelope is a document.
+*/
+function dataText(syn, value, path, sub) {
+	const each = (child, at) => dataText(syn, child, at, sub);
+	if (Array.isArray(value)) {
+		const texts = partTexts(value.map((item, index) => [index, item]), path, each);
+		return texts.ok ? ok(`[${texts.value.join(`${syn.separator} `)}]`) : texts;
+	}
+	return isRecord(value) && !isEnvelope(value) && !Object.hasOwn(value, "type") ? bracesText(syn, value, path, each) : sub(value, path);
+}
 /** This function writes a construct form (K145). */
 function constructText(syn, shape, sub) {
 	if (shape.tag === "record") return bracesText(syn, shape.entries, [], sub);
@@ -16152,8 +16685,8 @@ function printNode(syn, doc, sub) {
 		return ok(texts.join("."));
 	}
 	const texts = [];
-	for (const [key, arg, wrapped] of shape.args) {
-		const result = sub(arg, [key], wrapped);
+	for (const [key, arg, wrapped, data] of shape.args) {
+		const result = data === true ? dataText(syn, arg, [key], sub) : sub(arg, [key], wrapped);
 		if (!result.ok) return result;
 		texts.push(shape.named === true ? `${keyText(String(key))}: ${result.value}` : result.value);
 	}
@@ -16214,6 +16747,287 @@ function syntaxFormat(profile) {
 		evaluators: { "syntax.format": code }
 	};
 }
+/** This function tells how a document breaks `parse(print(doc))`. It gives `undefined` when the document comes back. */
+function lawBreak(profile, doc) {
+	const printed = print(profile, doc);
+	if (!printed.ok) return {
+		text: void 0,
+		why: printed.error.reason
+	};
+	const text = printed.value;
+	const back = parse(profile, text);
+	if (back.ok) return docEquals(back.doc, doc) ? void 0 : {
+		text,
+		why: `The text ${text} reads as ${JSON.stringify(back.doc)}.`
+	};
+	return {
+		text,
+		why: `The text ${text} gives the issue: ${back.issues[0]?.message ?? ""}`
+	};
+}
+/** This function gives the index of the first pattern that `parse` uses at the start of a text, or `-1`. */
+function patternAt(syn, text) {
+	return syn.patterns.findIndex(({ sticky }) => {
+		sticky.lastIndex = 0;
+		const match = sticky.exec(text)?.[0];
+		return match !== void 0 && match !== "" && !/[A-Za-z0-9_$(]/.test(text[match.length] ?? "");
+	});
+}
+/** This function gives each small document of an operator with `term` in one term. A `flat` operator also has three terms. */
+function operatorDocs(op, term, leaf) {
+	if (op.fixity !== "infix") return [opDoc(op, [term])];
+	const pairs = [[term, leaf], [leaf, term]];
+	return (op.assoc === "flat" ? [
+		...pairs,
+		[
+			term,
+			leaf,
+			leaf
+		],
+		[
+			leaf,
+			term,
+			leaf
+		]
+	] : pairs).map((terms) => opDoc(op, terms));
+}
+/** This function gives the longer symbol that reads two postfix operators without a space, or `undefined`. */
+function gluedSymbol(syn, outer, inner) {
+	if (outer.word || inner.word || outer.fixity !== "postfix" || inner.fixity !== "postfix") return void 0;
+	const glued = inner.symbol + outer.symbol;
+	const read = syn.binarySymbols.find((symbol) => glued.startsWith(symbol));
+	return read === inner.symbol ? void 0 : read;
+}
+function checkOperators({ profile, syn, leaf, keeps }) {
+	const ops = (profile.operators ?? []).map((given) => (given.fixity === "prefix" ? syn.prefix : syn.binary).get(given.symbol));
+	const sound = ops.filter((op, index) => operatorDocs(op, leaf, leaf).every((doc) => keeps("operator", ["operators", index], `The operator ${op.symbol} does not come back.`, doc)));
+	for (const outer of sound) {
+		const place = ["operators", ops.indexOf(outer)];
+		for (const inner of sound) {
+			const glued = gluedSymbol(syn, outer, inner);
+			const code = glued === void 0 ? "grouping" : "longest-match";
+			const rule = glued === void 0 ? `The operator ${outer.symbol} with ${inner.symbol} in a term loses the tree.` : `The symbol ${glued} reads the postfix operators ${inner.symbol} and ${outer.symbol}.`;
+			for (const term of operatorDocs(inner, leaf, leaf)) for (const doc of operatorDocs(outer, term, leaf)) keeps(code, place, rule, doc);
+		}
+	}
+}
+function checkLiterals({ profile, syn, report }) {
+	for (const [word, value] of syn.words) {
+		const back = parse(profile, word);
+		if (!back.ok || !docEquals(back.doc, envelop(syn, literalDoc(value)))) report("word", [
+			"literals",
+			"words",
+			word
+		], word, `The word ${word} does not read as its value.`);
+	}
+	for (const value of [
+		0,
+		-1,
+		"a"
+	]) {
+		const shape = literalShape(syn, value);
+		if (shape.tag === "text" && patternAt(syn, shape.text) >= 0) report("pattern", [], shape.text, `The literal ${shape.text} reads as a reference.`);
+	}
+}
+function checkRoots({ profile, syn, keeps }) {
+	(profile.refs?.roots ?? DEFAULT_ROOTS).forEach((root, index) => {
+		for (const path of syn.fields ? [[root], [root, "x"]] : [[root]]) keeps("root", [
+			"refs",
+			"roots",
+			index
+		], `The root ${root} does not come back.`, {
+			type: "ref",
+			value: path
+		}, path.join("."));
+	});
+}
+/** This function gives a value that a call form writes: the fewest arguments, and at least one. */
+function formValue(given, leaf) {
+	const args = given.args ?? (given.fields === void 0 ? "list" : "fields");
+	const least = Math.max(given.min ?? given.fields?.length ?? 0, 1);
+	if (args === "literal") return 1;
+	if (args === "list") return Array.from({ length: least }, () => leaf);
+	const keys = (given.fields ?? ["x"]).slice(0, args === "named" ? 1 : least);
+	return Object.fromEntries(keys.map((key) => [key, leaf]));
+}
+function checkCalls({ profile, syn, leaf, keeps }) {
+	const calls = profile.calls ?? {};
+	(calls.forms ?? []).forEach((form, index) => {
+		keeps("form", [
+			"calls",
+			"forms",
+			index
+		], `The form ${form.name} does not come back.`, {
+			type: typeOfKind(form.kind).type,
+			value: formValue(form, leaf)
+		});
+	});
+	if (syn.ops === true && syn.fields) keeps("call", ["calls", "ops"], "A call name with a dot does not come back.", {
+		type: [
+			"ops",
+			"m",
+			"p"
+		],
+		value: [leaf]
+	});
+	if (typeof calls.ops === "boolean" || calls.ops === void 0) return;
+	calls.ops.forEach((name, index) => {
+		keeps("call", [
+			"calls",
+			"ops",
+			index
+		], `The call ${name} does not come back.`, {
+			type: ["ops", ...name.split(".")],
+			value: [leaf]
+		});
+	});
+}
+/** This function writes two terms with the separator. It blames the separator only when a neutral separator keeps the document. */
+function checkSeparator({ profile, syn, leaf, report }) {
+	if (syn.ops !== true && syn.ops.size === 0 && syn.forms.size === 0 && syn.constructKinds.size === 0) return;
+	const open = {
+		...profile,
+		calls: {
+			...profile.calls,
+			ops: true
+		}
+	};
+	const neutral = {
+		...profile,
+		calls: {
+			...open.calls,
+			separator: "
"
+		}
+	};
+	const postfix = [...syn.binary.values()].filter((op) => op.fixity === "postfix").map((op) => opDoc(op, [leaf]));
+	const docs = [
+		leaf,
+		{
+			type: "ref",
+			value: [syn.bare, "b c"]
+		},
+		"a",
+		1,
+		...postfix
+	].map((term) => ({
+		type: ["ops", "probe__"],
+		value: [term, leaf]
+	}));
+	const entries = {
+		x: leaf,
+		y: leaf
+	};
+	const { record, let: bind } = syn.constructs;
+	if (record !== void 0) docs.push({
+		type: record,
+		value: entries
+	});
+	if (bind !== void 0) docs.push({
+		type: bind,
+		value: {
+			bind: entries,
+			body: leaf
+		}
+	});
+	for (const doc of docs) {
+		const broken = lawBreak(neutral, doc) === void 0 ? lawBreak(open, doc) : void 0;
+		if (broken !== void 0) report("separator", ["calls", "separator"], "", `The separator "${syn.separator}" does not end an argument. ${broken.why}`);
+	}
+}
+function checkConstructs({ syn, leaf, keeps }) {
+	const entries = { x: leaf };
+	const values = {
+		record: entries,
+		let: {
+			bind: entries,
+			body: leaf
+		},
+		fn: {
+			params: ["x"],
+			body: leaf
+		},
+		call: {
+			fn: leaf,
+			args: [leaf]
+		}
+	};
+	for (const name of CONSTRUCTS$1) {
+		const type = syn.constructs[name];
+		if (type !== void 0) keeps("construct", ["constructs", name], `The form ${name} does not come back.`, {
+			type,
+			value: values[name]
+		});
+	}
+}
+/**
+* This function finds the faults of a syntax profile before a host uses it (SYNTAX.PROFILE-CHECK, D140). A fault is a
+* document of an entry that breaks `parse(print(doc))`, or a text of an entry that reads another way. The function
+* writes and reads one small document for each entry, for each pair of operators and for each root. Thus an empty list
+* tells that these small documents come back. It does not prove the law for each document. `parse` and `print` do not
+* call this function, thus it adds no cost to them.
+*
+* @param profile - The syntax profile.
+* @returns At most one finding for each code and place, in the order of the operators, the literals, the references, the calls and the constructs.
+* @throws An error of a `read` or a `write` function of a pattern.
+*/
+function checkSyntax(profile) {
+	const open = {
+		...profile,
+		maxDepth: 256
+	};
+	let syn;
+	try {
+		syn = compileProfile(open);
+	} catch (error) {
+		if (error instanceof TypeError) return [{
+			code: "invalid",
+			place: [],
+			reason: error.message
+		}];
+		throw error;
+	}
+	const found = /* @__PURE__ */ new Map();
+	const report = (code, place, text, reason) => {
+		const index = patternAt(syn, text);
+		const finding = index < 0 ? {
+			code,
+			place,
+			reason
+		} : {
+			code: "pattern",
+			place: [
+				"refs",
+				"patterns",
+				index
+			],
+			reason: `The pattern reads the start of the text ${text}. ${reason}`
+		};
+		const key = JSON.stringify([finding.code, finding.place]);
+		if (!found.has(key)) found.set(key, finding);
+	};
+	const keeps = (code, place, rule, doc, start = "") => {
+		const broken = lawBreak(open, doc);
+		if (broken !== void 0) report(code, place, broken.text ?? start, `${rule} ${broken.why}`);
+		return broken === void 0;
+	};
+	const check = {
+		profile: open,
+		syn,
+		leaf: {
+			type: "ref",
+			value: [syn.bare, "a"]
+		},
+		report,
+		keeps
+	};
+	checkOperators(check);
+	checkLiterals(check);
+	checkRoots(check);
+	checkCalls(check);
+	checkSeparator(check);
+	checkConstructs(check);
+	return [...found.values()];
+}
 // src/generate.ts
 /**
 * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
@@ -17324,7 +18138,8 @@ function instanceOf(env, under, doc, split, sample) {
 			const ctx = shot.context;
 			const parts = split.parts.map((slot, index) => ({
 				...handleOf(slot),
-				evaluate: (given) => shot.steps(index, "evaluate", given ?? ctx)
+				evaluate: (given) => shot.steps(index, "evaluate", given ?? ctx),
+				handled: () => shot.steps(index, "evaluate", ctx)
 			}));
 			const input = {
 				...base,
@@ -18746,6 +19561,7 @@ function schedule(machine, options = {}) {
 	let keptAt = -1;
 	const keptNodes = [];
 	let keptMet = false;
+	let keptFrom = 0;
 	let count = 0;
 	let ahead = 0;
 	let wanted;
@@ -18816,7 +19632,10 @@ function schedule(machine, options = {}) {
 		const reader = stack[stack.length - 1];
 		const known = epoch.values.get(id);
 		if (known !== void 0) {
-			if (reader !== void 0 && onOpen.has(id)) lower(reader, order.get(id));
+			if (reader !== void 0 && onOpen.has(id)) {
+				if (keptAt >= 0 && order.get(id) < keptFrom) keptMet = true;
+				else lower(reader, order.get(id));
+			}
 			return known;
 		}
 		if (busy.has(id)) {
@@ -19020,9 +19839,11 @@ function schedule(machine, options = {}) {
 		keeping(read) {
 			const outer = keptAt;
 			const outerMet = keptMet;
+			const outerFrom = keptFrom;
 			const from = keptNodes.length;
 			keptAt = stack.length;
 			keptMet = false;
+			keptFrom = count;
 			try {
 				return read();
 			} finally {
@@ -19033,6 +19854,7 @@ function schedule(machine, options = {}) {
 				}
 				keptAt = outer;
 				keptMet = outerMet;
+				keptFrom = outerFrom;
 			}
 		}
 	});
@@ -20016,6 +20838,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, GENERATION_LIMIT, Held, JOURNAL, MAX_SYNTAX_ISSUES, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, GENERATION_LIMIT, Held, JOURNAL, MAX_SYNTAX_ISSUES, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, agreeTypes, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, boundariesOf, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkSyntax, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, ifRunner, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapDocs, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partGrants, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map