@mark1russell7/coeval 0.24.0 → 0.25.0

package/build/index.js

@@ -1353,6 +1353,61 @@ function narrowAt(type, path, at, narrowed, domains) {
 		...form.closed ? { closed: true } : {}
 	};
 }
+/** This function gives the type of a value that is a member of both types. The result is the narrower known type. */
+function meetOf(type, proved, domains) {
+	if (isUnknown(proved, domains)) return type;
+	const form = formOf(type, domains);
+	if (form.t === "one") return { one: form.values.filter((value) => member(value, proved, domains)) };
+	return !isUnknown(type, domains) && isPrecise(type, domains) && fits(type, proved, domains) ? type : proved;
+}
+/** This function gives the type of a value of the first type that is not a member of the second type. */
+function withoutOf(type, removed, domains) {
+	if (isUnknown(removed, domains)) return type;
+	const form = formOf(type, domains);
+	if (form.t === "one") return { one: form.values.filter((value) => !member(value, removed, domains)) };
+	if (form.t === "union") {
+		const members = form.members.map((each) => withoutOf(each, removed, domains)).filter((each) => each !== "never");
+		return members.length === 0 ? "never" : members.length === 1 ? members[0] : { union: members };
+	}
+	return isPrecise(type, domains) && fits(type, removed, domains) ? "never" : type;
+}
+/**
+* This function gives a type with one proof at a path (STATIC.OCCURRENCE). A path that leaves the records of the type
+* gives the type back. A fact about a field also tells if the field exists. A value of a type without `undefined`
+* exists. An optional field without a remaining type does not.
+*
+* @param type - The type of the value at the first `at` keys of the path.
+* @param proof - The proof.
+* @param at - The number of keys of the path that the type already holds.
+* @param domains - The domains of the machine.
+* @returns The narrowed type.
+*/
+function narrowType(type, proof, at, domains) {
+	if (at === proof.path.length) {
+		if (proof.fact === "is") return meetOf(type, proof.type, domains);
+		return proof.fact === "not" ? withoutOf(type, proof.type, domains) : type;
+	}
+	const form = formOf(type, domains);
+	const key = proof.path[at];
+	if (form.t !== "record" || !Object.hasOwn(form.fields, key)) return type;
+	const before = form.fields[key];
+	const optional = new Set(form.optional);
+	let after = narrowType(before, proof, at + 1, domains);
+	if (at + 1 === proof.path.length && optional.has(key)) {
+		if (proof.fact === "present" || proof.fact === "is" && !member(void 0, proof.type, domains)) optional.delete(key);
+		else if (proof.fact === "absent" || after === "never") after = void 0;
+	}
+	const fields = {};
+	for (const name of Object.keys(form.fields)) if (name !== key) setOwn$6(fields, name, form.fields[name]);
+	if (after !== void 0) setOwn$6(fields, key, after);
+	else if (form.closed) optional.delete(key);
+	else setOwn$6(fields, key, "never");
+	return {
+		record: fields,
+		...optional.size === 0 ? {} : { optional: [...optional] },
+		...form.closed ? { closed: true } : {}
+	};
+}
 /**
 * This function is the split rule of `fits` (TYPE.FITS-FINITE, D84, TYPE.FITS-PATH, D89). A record type fits when each
 * record of its split fits. A split takes the first field in the order of `splitsOf`. Each member of the field gives a
@@ -1568,7 +1623,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 +1645,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") {
@@ -1882,6 +1937,12 @@ var MergeError = class extends Error {
 	}
 };
 const NONE$2 = /* @__PURE__ */ new Set();
+/** The verbs that the kernel reads. Thus no language owns them (COMPOSE.PIRACY). */
+const KERNEL_VERBS = /* @__PURE__ */ new Set([
+	"eval",
+	"deref",
+	"step"
+]);
 function keyOf(path) {
 	return JSON.stringify(path.map(String));
 }
@@ -2072,16 +2133,123 @@ function mergeEntry(m, earlier, later, path, part, replaces) {
 	m.clash(path, part, a === b ? `Two parts give two different ${a === "an alias" ? "aliases" : "kinds"}.` : `One part gives ${a}, and the other part gives ${b}.`);
 	return earlier;
 }
-function worldOf(draft) {
+function worldDraft() {
+	return {
+		kinds: {},
+		defaults: {},
+		owners: /* @__PURE__ */ new Map(),
+		entries: []
+	};
+}
+/**
+* This function gives a copy of a table with a change to the kind at a path, as `replaces` names the path. It gives
+* `undefined` when no kind is at the path. An alias is not a kind.
+*/
+function changeKind(table, path, change) {
+	const [first, key, ...rest] = path;
+	if (String(first) === "fallback" && key === void 0) return table.fallback === void 0 ? void 0 : {
+		...table,
+		fallback: change(table.fallback)
+	};
+	if (String(first) !== "kinds" || key === void 0) return void 0;
+	const entry = own$2(table.kinds, String(key));
+	const next = rest.length === 0 ? isKind(entry) ? change(entry) : void 0 : isNamespace(entry) ? changeKind(entry, rest, change) : void 0;
+	if (next === void 0) return void 0;
+	const kinds = { ...table.kinds };
+	setOwn$5(kinds, String(key), next);
+	return {
+		...table,
+		kinds
+	};
+}
+/**
+* This function adds the entries of `extends` to the kinds of a draft. A later part can give the kind, thus this step
+* reads the whole draft. Without `m`, it reports no conflict: a function part sees the entries of the parts before it.
+*/
+function addVerbs(draft, m) {
+	let table = draft.fallback === void 0 ? { kinds: draft.kinds } : {
+		kinds: draft.kinds,
+		fallback: draft.fallback
+	};
+	for (const entry of draft.entries) {
+		if (!entry.allowed && !entry.replaced) {
+			m?.clash(entry.path, entry.part, "A part adds a verb that it does not own to a kind that it does not give.");
+			continue;
+		}
+		const next = changeKind(table, entry.kind, (kind) => {
+			const verbs = { ...kind.verbs };
+			const earlier = own$2(verbs, entry.verb);
+			if (earlier === void 0) m?.give(entry.path, entry.part);
+			else if (entry.replaced) m?.replace(entry.path, entry.part);
+			else if (earlier !== entry.code) m?.clash(entry.path, entry.part, "Two parts give two different evaluators for this verb of this kind.");
+			if (earlier === void 0 || entry.replaced) setOwn$5(verbs, entry.verb, entry.code);
+			return {
+				...kind,
+				verbs
+			};
+		});
+		if (next !== void 0) table = next;
+		else if (!entry.replaced) m?.clash(entry.path, entry.part, "A part adds a verb to a path without a kind.");
+	}
+	return table;
+}
+function worldOf(draft, m) {
+	const table = addVerbs(draft, m);
 	const world = {
-		kinds: { ...draft.kinds },
+		kinds: { ...table.kinds },
 		defaults: { ...draft.defaults }
 	};
-	return draft.fallback === void 0 ? world : {
+	return table.fallback === void 0 ? world : {
 		...world,
-		fallback: draft.fallback
+		fallback: table.fallback
 	};
 }
+/** This function records the verbs that a part owns, and the entries that it adds to kinds. */
+function mergeVerbs(m, draft, part, index, replaces, base) {
+	const owned = part.verbs ?? [];
+	for (const verb of owned) {
+		const path = [
+			...base,
+			"verbs",
+			verb
+		];
+		const owner = draft.owners.get(verb);
+		if (replaces.has(keyOf(path))) {
+			draft.owners.set(verb, part);
+			m.replace(path, index);
+		} else if (KERNEL_VERBS.has(verb)) m.clash(path, index, "The kernel owns this verb.");
+		else if (owner === void 0) {
+			draft.owners.set(verb, part);
+			m.give(path, index);
+		} else if (!same(owner, part)) m.clash(path, index, "Two parts own this verb.");
+	}
+	const table = part.fallback === void 0 ? { kinds: part.kinds ?? {} } : {
+		kinds: part.kinds ?? {},
+		fallback: part.fallback
+	};
+	for (const { kind, verbs } of part.extends ?? []) {
+		const gives = changeKind(table, kind, (found) => found) !== void 0;
+		for (const verb of Object.keys(verbs)) {
+			const code = verbs[verb];
+			if (code === void 0) continue;
+			const path = [
+				...base,
+				...kind,
+				"verbs",
+				verb
+			];
+			draft.entries.push({
+				kind,
+				verb,
+				code,
+				path,
+				part: index,
+				allowed: gives || owned.includes(verb),
+				replaced: replaces.has(keyOf(path))
+			});
+		}
+	}
+}
 function mergeWorldInto(m, draft, part, index, replaces, base) {
 	if (part === void 0) return;
 	if (part.kinds !== void 0) mergeEntries(m, draft.kinds, part.kinds, [...base, "kinds"], index, replaces);
@@ -2093,6 +2261,7 @@ function mergeWorldInto(m, draft, part, index, replaces, base) {
 	], index, replaces, Object.is, "Two parts give two different defaults for this verb.");
 	const fallback = mergeFallback(m, draft.fallback, part.fallback, [...base, "fallback"], index, replaces);
 	if (fallback !== void 0) draft.fallback = fallback;
+	mergeVerbs(m, draft, part, index, replaces, base);
 }
 /**
 * This function merges worlds into one world, in the order of the parts. It does not change a part.
@@ -2102,6 +2271,8 @@ function mergeWorldInto(m, draft, part, index, replaces, base) {
 * - The defaults merge verb by verb, and the world keeps one fallback.
 * - Each other pair of entries at one path is a conflict, unless the later part names the path in `replaces`.
 *   Then the later entry wins, with no merge below it.
+* - The entries of `extends` join their kinds after each part, thus the order of the parts does not change them. A
+*   verb that a part does not own on a kind that it does not give is a conflict (COMPOSE.PIRACY).
 *
 * A part can be a function of the merge of the parts before it (`prev`, as an overlay of Nix). Thus a part can read
 * the entry that it replaces.
@@ -2112,16 +2283,14 @@ function mergeWorldInto(m, draft, part, index, replaces, base) {
 */
 function mergeWorlds(...parts) {
 	const m = new Merger();
-	const draft = {
-		kinds: {},
-		defaults: {}
-	};
+	const draft = worldDraft();
 	parts.forEach((input, index) => {
 		const part = typeof input === "function" ? input(worldOf(draft)) : input;
 		mergeWorldInto(m, draft, part, index, new Set((part.replaces ?? []).map(keyOf)), []);
 	});
+	const world = worldOf(draft, m);
 	if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-	return worldOf(draft);
+	return world;
 }
 /** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
 const TABLES = /* @__PURE__ */ new Set([
@@ -2174,12 +2343,12 @@ function composeFacts(hooks, replaced) {
 		}
 	};
 }
-function machineOf(draft) {
+function machineOf(draft, m) {
 	const known = composeKnown(draft.hooks, draft.replaced);
 	const facts = composeFacts(draft.factHooks, draft.replaced);
 	return {
 		...draft.rest,
-		world: worldOf(draft.world),
+		world: worldOf(draft.world, m),
 		evaluators: { ...draft.evaluators },
 		...draft.runners === void 0 ? {} : { runners: { ...draft.runners } },
 		...draft.derefs === void 0 ? {} : { derefs: { ...draft.derefs } },
@@ -2253,10 +2422,7 @@ function checkHidden(m, draft) {
 function mergeMachines(...parts) {
 	const m = new Merger();
 	const draft = {
-		world: {
-			kinds: {},
-			defaults: {}
-		},
+		world: worldDraft(),
 		evaluators: {},
 		hooks: [],
 		factHooks: [],
@@ -2297,8 +2463,9 @@ function mergeMachines(...parts) {
 		}
 	});
 	checkHidden(m, draft);
+	const machine = machineOf(draft, m);
 	if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-	return machineOf(draft);
+	return machine;
 }
 /** This function removes the entry at a path from a table of entries. It gives the same table when no entry is there. */
 function removeEntry(entries, path) {
@@ -4812,7 +4979,8 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		} 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;
@@ -4821,7 +4989,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;
@@ -5217,6 +5386,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 {
@@ -5417,6 +5609,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,
@@ -5424,7 +5617,8 @@ function prepare(machine, doc, options = {}) {
 		verb,
 		noAnswer,
 		fold,
-		fixed
+		fixed,
+		guards
 	};
 	let root;
 	try {
@@ -5537,7 +5731,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));
@@ -5558,6 +5753,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);
@@ -5928,7 +6124,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.
@@ -6068,6 +6265,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"
@@ -6135,11 +6344,17 @@ const STD_EVALUATORS = {
 		const [a, b] = values;
 		return ok((a ?? 0) > (b ?? 0));
 	},
-	"ref.resolve": ({ data, resolve }) => {
-		if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
-		const found = resolve(data);
-		return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
-	},
+	"ref.resolve": { compile: ({ data, machine }) => {
+		if (!Array.isArray(data) || data.length === 0) {
+			const bad = fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+			return () => bad;
+		}
+		const path = compilePath(machine, data);
+		return (ctx, rt) => {
+			const found = resolveCompiled(rt, ctx, path);
+			return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+		};
+	} },
 	"tree.node": (input) => treeNode(input, void 0)
 };
 /** The brand of a node of the decorated tree. Its value is the state that the kit reads. */
@@ -6524,6 +6739,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);
@@ -6938,7 +7154,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,
@@ -7270,6 +7486,26 @@ 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.
 */
@@ -7337,15 +7573,7 @@ const STD_RUNNERS = {
 			}
 		});
 	},
-	"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.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);
@@ -7768,6 +7996,31 @@ 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 result of a test that proves nothing. */
+const NO_PROOFS$1 = {
+	yes: [],
+	no: []
+};
 /** The roots that can change, as a rule gives them in `PartType.roots`. */
 const CHANGING = [
 	"self",
@@ -7787,11 +8040,15 @@ 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`. */
-function orderOf(node, nodes) {
+/** This function gives the order of the parts of a document. The part `first` of the rule comes first, or else the parts that give the names of a rule `keysAt`. */
+function orderOf(node, nodes, first) {
+	if (first !== void 0) {
+		const isFirst = (index) => String(nodes[index].visit.slot[0]) === first;
+		return [...node.children.filter(isFirst), ...node.children.filter((index) => !isFirst(index))];
+	}
 	const sources = (node.visit.kind?.scope ?? []).flatMap((rule) => "keysAt" in rule.names ? [rule.names.keysAt] : []);
 	if (sources.length === 0 || node.children.length < 2) return node.children;
 	const gives = (index) => {
@@ -7815,7 +8072,7 @@ function message(error) {
 * @param rootTypes - The types of the roots and of the names of the host.
 * @returns The type of the root, the type issues in the order of the document, and the type of each document.
 */
-function typePass(machine, nodes, verb, expect, rootTypes = {}) {
+function typePass(machine, nodes, verb, expect, rootTypes = {}, hasEffect = () => false) {
 	if (nodes.length === 0) return {
 		type: "unknown",
 		issues: [],
@@ -7827,6 +8084,29 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 	const types = new Array(nodes.length);
 	const needed = new Array(nodes.length);
 	const seen = /* @__PURE__ */ new Set();
+	const inputs = new Array(nodes.length);
+	let changes;
+	const rootsChange = () => changes ??= nodes.some(hasEffect);
+	const narrowed = (names, roots, proofs) => {
+		let nextNames = names;
+		let nextRoots = roots;
+		for (const proof of proofs) {
+			const head = proof.path[0];
+			if (head === "names") {
+				const name = proof.path[1];
+				if (name === void 0) continue;
+				if (nextNames === names) nextNames = new Map(names);
+				nextNames.set(name, narrowType(nextNames.get(name) ?? "unknown", proof, 2, domains));
+			} else if ((head === "self" || head === "world" || head === "event") && !rootsChange()) nextRoots = {
+				...nextRoots,
+				[head]: narrowType(nextRoots[head], proof, 1, domains)
+			};
+		}
+		return {
+			names: nextNames,
+			roots: nextRoots
+		};
+	};
 	const issueAt = (index, problem) => {
 		const visit = nodes[index].visit;
 		const issue = {
@@ -7864,19 +8144,30 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 			typeOf: (path) => typed.get(pathKey(path)) ?? "unknown",
 			nameType: (name) => names.get(name),
 			rootType: (root) => root === "caps" ? CAPS_TYPE : root === "self" || root === "world" || root === "event" ? roots[root] : "unknown",
-			contract: (type, what) => contract(index, type, what)
+			contract: (type, what) => contract(index, type, what),
+			readOf: (path) => {
+				const key = pathKey(path);
+				const part = node.children.find((child) => pathKey(nodes[child].visit.slot) === key);
+				const read = part === void 0 ? void 0 : ruleOf(machine, nodes[part].evaluator)?.reads;
+				return read === void 0 || nodes[part].marked ? void 0 : read(inputs[part]);
+			},
+			provenBy: (path) => frame.proven?.get(pathKey(path)) ?? NO_PROOFS$1
 		};
-		return {
+		inputs[index] = input;
+		const rule = node.marked ? void 0 : ruleOf(machine, node.evaluator);
+		const frame = {
 			index,
-			rule: node.marked ? void 0 : ruleOf(machine, node.evaluator),
+			rule,
 			input,
-			order: orderOf(node, nodes),
+			order: orderOf(node, nodes, rule?.first),
 			next: 0,
 			typed,
 			needs,
 			names,
-			roots
+			roots,
+			proven: void 0
 		};
+		return frame;
 	};
 	const ruleFailed = (frame, error) => {
 		issueAt(frame.index, { reason: `The type rule of ${nodes[frame.index].evaluator ?? "the evaluator"} fails: ${message(error)}` });
@@ -7924,12 +8215,22 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 			if (contracts && node.expect !== void 0) need(contract(child, node.expect, `expected type of the ${what}`), what);
 			if (part.expect !== void 0) need(part.expect, part.what ?? what);
 			let names = frame.names;
+			let kept = frame.roots;
+			if (part.narrow !== void 0 && part.narrow.length > 0) {
+				const after = narrowed(names, kept, part.narrow);
+				names = after.names;
+				kept = after.roots;
+				if (part.keep === true) {
+					frame.names = names;
+					frame.roots = kept;
+				}
+			}
 			if (node.bound.length > 0) {
 				const copy = new Map(names);
 				for (const name of node.bound) copy.set(name, part.names !== void 0 && Object.hasOwn(part.names, name) ? part.names[name] : "unknown");
 				names = copy;
 			}
-			let roots = frame.rule === void 0 ? UNKNOWN_ROOTS : frame.roots;
+			let roots = frame.rule === void 0 ? UNKNOWN_ROOTS : kept;
 			const changes = part.roots;
 			if (typeof changes === "object" && changes !== null) {
 				const copy = { ...roots };
@@ -7964,13 +8265,23 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 		}
 		types[frame.index] = type;
 		needed[frame.index] = frame.needs.length === 0 ? void 0 : frame.needs[frame.needs.length - 1].type;
-		stack[stack.length - 1]?.typed.set(pathKey(node.visit.slot), type);
+		const parent = stack[stack.length - 1];
+		if (parent === void 0) continue;
+		const key = pathKey(node.visit.slot);
+		parent.typed.set(key, type);
+		if (parent.rule?.usesProofs === true && frame.rule?.proves !== void 0) try {
+			(parent.proven ??= /* @__PURE__ */ new Map()).set(key, frame.rule.proves(frame.input));
+		} catch (error) {
+			ruleFailed(frame, error);
+		}
 	}
 	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,
@@ -9482,11 +9793,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 = partGrants(kind.caps, slot.path, doc.value);
+			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 : {
@@ -9504,8 +9817,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), ...grants],
-				handled: grants.length === 0 ? item.handled : [...item.handled ?? [], ...grants],
+				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
 			});
@@ -9595,6 +9908,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.
@@ -9737,7 +10072,8 @@ function check(machine, doc, options = {}) {
 function typeCheck(machine, doc, options = {}) {
 	const nodes = [];
 	const issues = checkAll(machine, doc, options, nodes);
-	const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
+	const verb = options.verb ?? "eval";
+	const pass = typePass(machine, nodes, verb, options.expect, options.rootTypes, (node) => declaredEffects(node.visit, verb, machine, node.evaluator).length > 0);
 	return {
 		type: pass.type,
 		issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues],
@@ -10742,6 +11078,13 @@ function decodeValue(machine, doc) {
 	return prepare(machine, doc, { declaredType: "lit" }).evaluate(makeContext());
 }
 // src/formula.ts
+/** The most proofs that one test keeps. A proof only adds knowledge, thus the check can leave one out. */
+const MAX_PROOFS = 32;
+/** The result of a test that proves nothing. */
+const NO_PROOFS = {
+	yes: [],
+	no: []
+};
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED = /* @__PURE__ */ Symbol("skipped");
 /** The value of a name whose binding failed. A reference to the name gives the error. */
@@ -11142,6 +11485,11 @@ function formulaTypes(profile) {
 					type: sig.to,
 					what: `result of a signature of ops.${name}`
 				});
+				if (sig.proves !== void 0) out.push({
+					at: [...at, "proves"],
+					type: sig.proves,
+					what: `proved type of a signature of ops.${name}`
+				});
 				const earlier = list.slice(0, index).findIndex((other) => isSignature(other) && sameParams(other, sig));
 				if (earlier >= 0) out.push({
 					at,
@@ -11152,7 +11500,30 @@ function formulaTypes(profile) {
 		return out;
 	};
 	const logic = (word) => ({
-		part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
+		usesProofs: true,
+		part: (input, path) => {
+			const index = Number(path[0]);
+			const part = truthPart(input, `term ${index + 1} of ${word}`);
+			if (index === 0) return part;
+			const before = input.provenBy([index - 1]);
+			return {
+				...part,
+				narrow: word === "and" ? before.yes : before.no,
+				keep: true
+			};
+		},
+		proves: (input) => {
+			const each = input.paths.map((path) => input.provenBy(path));
+			const all = (side) => each.flatMap((proven) => proven[side]).slice(0, MAX_PROOFS);
+			const one = each.length === 1 ? each[0] : void 0;
+			return word === "and" ? {
+				yes: all("yes"),
+				no: one?.no ?? []
+			} : {
+				yes: one?.yes ?? [],
+				no: all("no")
+			};
+		},
 		synth: (input) => {
 			if (!logicValue) return "bool";
 			if (input.paths.length === 0) return { one: [word === "and"] };
@@ -11161,39 +11532,47 @@ 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,
+			reads: (input) => {
+				const path = input.doc.value;
+				if (input.address || !Array.isArray(path) || path.length === 0) return void 0;
+				return path.every((step) => typeof step === "string") ? path : void 0;
+			},
+			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);
@@ -11303,11 +11682,16 @@ function formulaTypes(profile) {
 				type: truth,
 				what: "truth type of the profile"
 			}] : [],
+			first: "test",
+			usesProofs: true,
 			part: (input, path) => {
 				if (path[0] === "test") return truthPart(input, "test of if");
-				return isUnknown(input.expected, input.machine.domains) ? {} : {
+				const proven = input.provenBy(["test"]);
+				const narrow = path[0] === "then" ? proven.yes : proven.no;
+				return isUnknown(input.expected, input.machine.domains) ? { narrow } : {
 					expect: input.expected,
-					what: `${String(path[0])} branch of if`
+					what: `${String(path[0])} branch of if`,
+					narrow
 				};
 			},
 			synth: (input) => {
@@ -11320,6 +11704,41 @@ function formulaTypes(profile) {
 		"formula.or": logic("or"),
 		"formula.op": {
 			declared: sigsDeclared,
+			proves: (input) => {
+				const sigs = signatures(input)?.sigs;
+				const sig = sigs?.length === 1 ? sigs[0] : void 0;
+				if (sig === void 0 || sig.proves === void 0 && sig.present !== true || input.paths.length === 0) return NO_PROOFS;
+				const path = input.readOf(input.paths[0]);
+				if (path === void 0) return NO_PROOFS;
+				const yes = [];
+				const no = [];
+				if (sig.proves !== void 0 && typeIssues(input.contract(sig.proves, `proved type of ops.${nameOf(input)}`), input.machine.domains).length === 0) {
+					yes.push({
+						path,
+						fact: "is",
+						type: sig.proves
+					});
+					no.push({
+						path,
+						fact: "not",
+						type: sig.proves
+					});
+				}
+				if (sig.present === true) {
+					yes.push({
+						path,
+						fact: "present"
+					});
+					no.push({
+						path,
+						fact: "absent"
+					});
+				}
+				return {
+					yes,
+					no
+				};
+			},
 			part: (input, path) => {
 				const read = signatures(input);
 				if (read === void 0 || read.sigs.length !== 1) return {};
@@ -13107,10 +13526,23 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	}
 };
 /**
+* The definition of the standard evaluator `ref.resolve` (REF.RESOLVE, D133). It resolves the steps of the path at each
+* evaluation. The plan compiles the same path one time.
+*/
+const refDefinition = ({ data, resolve: walk }) => {
+	if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+	const found = walk(data);
+	return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+};
+/**
 * The definitions of the reference for the evaluators of the standard machine that need their own reading. The
-* reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node`.
+* reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node` and
+* `ref.resolve`. A host that wraps `ref.resolve` wraps this function, because the standard evaluator is compiled.
 */
-const STD_DEFINITIONS = { evaluators: { "tree.node": treeDefinition } };
+const STD_DEFINITIONS = { evaluators: {
+	"tree.node": treeDefinition,
+	"ref.resolve": refDefinition
+} };
 const CLOSURE$1 = /* @__PURE__ */ Symbol.for("coeval.closure");
 /** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
 function setField$1(target, key, value) {
@@ -14702,6 +15134,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 {
@@ -14857,6 +15297,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 = [
@@ -15280,6 +15810,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;
@@ -15291,6 +15828,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 = {};
@@ -15327,17 +15874,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,
@@ -15369,7 +15921,8 @@ function compileProfile(profile) {
 			...ops.opWords,
 			...roots
 		]),
-		maxDepth: profile.maxDepth ?? 256
+		maxDepth: profile.maxDepth ?? 256,
+		brackets
 	};
 	compiledProfiles.set(profile, compiled);
 	return compiled;
@@ -15828,7 +16381,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());
 	}
@@ -15853,16 +16406,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.
 	*/
-	entries(form) {
-		const owner = form === void 0 ? "record" : `form ${form.name}`;
+	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, data = false) {
+		const owner = data ? "record of data" : form === void 0 ? "record" : `form ${form.name}`;
 		const value = {};
 		const entry = () => {
 			this.skip();
@@ -15872,9 +16440,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 ? "}" : ")");
@@ -15883,11 +16452,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;
@@ -15913,15 +16490,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) {
@@ -16164,6 +16746,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;
@@ -16186,10 +16769,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})`
@@ -16205,7 +16794,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
 		};
@@ -16232,7 +16822,8 @@ function formShape(syn, form, value) {
 		args: present.map((key) => [
 			key,
 			value[key],
-			wraps(form, key)
+			wraps(form, key),
+			form.data.has(key)
 		])
 	};
 }
@@ -16368,6 +16959,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);
@@ -16410,8 +17013,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);
 	}
@@ -19286,6 +19889,7 @@ function schedule(machine, options = {}) {
 	let keptAt = -1;
 	const keptNodes = [];
 	let keptMet = false;
+	let keptFrom = 0;
 	let count = 0;
 	let ahead = 0;
 	let wanted;
@@ -19356,7 +19960,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)) {
@@ -19560,9 +20167,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 {
@@ -19573,6 +20182,7 @@ function schedule(machine, options = {}) {
 				}
 				keptAt = outer;
 				keptMet = outerMet;
+				keptFrom = outerFrom;
 			}
 		}
 	});
@@ -20556,6 +21166,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, 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, 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, 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 };
+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