@mark1russell7/coeval 0.15.0 → 0.17.0

package/build/index.js

@@ -577,14 +577,17 @@ function looksLikeKind(value) {
 const STD_DOMAINS = {
 	null: {
 		is: (value) => value === null,
+		values: [null],
 		summary: "The value null."
 	},
 	undefined: {
 		is: (value) => value === void 0,
+		values: [void 0],
 		summary: "The value undefined. A document holds it as the extension ext.undefined."
 	},
 	bool: {
 		is: (value) => typeof value === "boolean",
+		values: [true, false],
 		summary: "A truth value: true or false."
 	},
 	number: {
@@ -598,6 +601,12 @@ const STD_DOMAINS = {
 };
 /** The deepest term that a value type can have. A deeper term reads as `unknown`, thus a check stays total. */
 const MAX_TYPE_DEPTH = 256;
+/** The most values that the finite rule of `fits` reads for one type (TYPE.FITS-FINITE). A type with more values is not finite for the rule. */
+const MAX_FINITE_VALUES = 64;
+/** The most domains of covers that the cover rule of `fits` tests for one type (TYPE.FITS-COVER). A larger test gives `false`. */
+const MAX_COVER_STEPS = 64;
+/** The most records that one split of `fits` builds, with each split inside its work (TYPE.FITS-PATH, D89). A larger split gives `false`. */
+const MAX_SPLIT_RECORDS = 64;
 /** The keys that each term permits beside its own key. */
 const TERM_KEYS = {
 	list: ["list"],
@@ -620,7 +629,7 @@ function domainOf(name, domains) {
 	return typeof found === "object" && found !== null && typeof found.is === "function" ? found : void 0;
 }
 /** This function gives the term key of a record, when the record has exactly one term key and no other key. */
-function termOf$1(term) {
+function termOf$2(term) {
 	const keys = Object.keys(term);
 	const own = keys.filter((key) => TERMS.includes(key));
 	if (own.length !== 1) return void 0;
@@ -638,7 +647,7 @@ function formOf(type, domains) {
 		};
 	}
 	if (!isRecord(type)) return TOP;
-	const term = termOf$1(type);
+	const term = termOf$2(type);
 	if (term === "list") return {
 		t: "list",
 		item: type["list"]
@@ -745,39 +754,358 @@ function member(value, type, domains) {
 	return memberAt(value, type, domains, 0);
 }
 /** This function tells if the record type `a` fits the record type `b`: width, closed records and optional fields. */
-function recordFits(a, b, domains, depth, gradual) {
+function recordFits(a, b, domains, depth, gradual, budget) {
 	if (b.closed && (!a.closed || Object.keys(a.fields).some((key) => !Object.hasOwn(b.fields, key)))) return false;
 	for (const key of Object.keys(b.fields)) {
 		const want = b.fields[key];
 		const needed = !b.optional.has(key);
 		if (Object.hasOwn(a.fields, key)) {
 			if (needed && a.optional.has(key)) return false;
-			if (!fitsAt(a.fields[key], want, domains, depth, gradual)) return false;
+			if (!fitsAt(a.fields[key], want, domains, depth, gradual, true, budget)) return false;
 		} else if (needed) return false;
 		else if (!a.closed && formOf(want, domains).t !== "top") return false;
 	}
 	return true;
 }
+/** This function adds a value to a list of distinct values, by `docEquals`. */
+function addValue(out, value) {
+	if (!out.some((item) => docEquals(item, value))) out.push(value);
+}
+/**
+* This function gives the values of a base type with a finite list. It reads the list of the first domain of the line
+* with at most 64 values, and it keeps only the members of the type. Thus the list of a parent serves each domain under it.
+*/
+function baseValues(name, domains) {
+	const domain = domainOf(name, domains);
+	if (domain === void 0) return void 0;
+	const line = Array.isArray(domain.values) || !Array.isArray(domain.under) ? [name] : lineOf(name, domains);
+	for (const each of line) {
+		const values = domainOf(each, domains)?.values;
+		if (!Array.isArray(values) || values.length > MAX_FINITE_VALUES) continue;
+		const out = [];
+		for (let index = 0; index < values.length; index += 1) if (inDomain(values[index], name, domains)) addValue(out, values[index]);
+		return out;
+	}
+}
+/** This function gives a copy of a record with one more field. */
+function withField(record, key, value) {
+	const out = {};
+	for (const name of Object.keys(record)) setOwn$6(out, name, record[name]);
+	setOwn$6(out, key, value);
+	return out;
+}
+/**
+* This function gives the members of a record type, when they are few. A record with a needed field without members
+* has no members. Only a closed record with a finite list for each field has a finite list.
+*/
+function recordValues(form, domains, depth) {
+	let out = [{}];
+	let finite = form.closed;
+	for (const key of Object.keys(form.fields)) {
+		const values = valuesOf$1(form.fields[key], domains, depth);
+		const optional = form.optional.has(key);
+		if (values === void 0) {
+			finite = false;
+			continue;
+		}
+		if (values.length === 0 && !optional) return [];
+		if (!finite) continue;
+		if (out.length * (values.length + (optional ? 1 : 0)) > MAX_FINITE_VALUES) {
+			finite = false;
+			continue;
+		}
+		out = out.flatMap((record) => [...optional ? [record] : [], ...values.map((value) => withField(record, key, value))]);
+	}
+	return finite ? out : void 0;
+}
+/**
+* This function gives a list of the members of a type, when the type has at most 64 members (TYPE.FITS-FINITE). Each
+* other type gives `undefined`. Such a type is `unknown`, a base type without a finite list, or a function type. A
+* list that can hold an item and an open record with members are also such types.
+*/
+function valuesOf$1(type, domains, depth) {
+	if (depth > MAX_TYPE_DEPTH) return void 0;
+	const form = formOf(type, domains);
+	const next = depth + 1;
+	switch (form.t) {
+		case "bottom": return [];
+		case "base": return baseValues(form.name, domains);
+		case "list": return valuesOf$1(form.item, domains, next)?.length === 0 ? [[]] : void 0;
+		case "record": return recordValues(form, domains, next);
+		case "one":
+		case "union": {
+			const out = [];
+			const items = form.t === "one" ? form.values : form.members;
+			for (const item of items) {
+				const values = form.t === "one" ? [item] : valuesOf$1(item, domains, next);
+				if (values === void 0) return void 0;
+				for (const value of values) addValue(out, value);
+				if (out.length > MAX_FINITE_VALUES) return void 0;
+			}
+			return out;
+		}
+		default: return;
+	}
+}
+/** This function gives the members of a type at one depth, for `membersOf`. */
+function membersAt(type, domains, samples, depth) {
+	const finite = valuesOf$1(type, domains, depth);
+	if (finite !== void 0) return finite;
+	const form = formOf(type, domains);
+	if (form.t !== "union" || depth > MAX_TYPE_DEPTH) return samples.filter((sample) => member(sample, type, domains));
+	const out = [];
+	for (const item of form.members) for (const value of membersAt(item, domains, samples, depth + 1)) addValue(out, value);
+	return out;
+}
+/**
+* This function gives members of a type for a test of a declaration (D86). A type with at most 64 members gives each
+* member, from the lists `values` of its domains (TYPE.FITS-FINITE). A union gives the members of each of its types.
+* Each other type gives the samples that are its members. The kernel does not export the function.
+*
+* @param type - The type.
+* @param domains - The domains of the machine.
+* @param samples - The values to test when the type has no full list of members.
+* @returns Distinct members of the type.
+*/
+function membersOf(type, domains, samples) {
+	return membersAt(type, domains, samples, 0);
+}
+/** This function holds the rules of the shapes of `fits`: base types, lists, records and functions. */
+function shapeFits(a, b, domains, next, gradual, budget) {
+	if (a.t === "base") return b.t === "base" && lineOf(a.name, domains).has(b.name);
+	if (a.t === "list") return b.t === "list" && fitsAt(a.item, b.item, domains, next, gradual, true, budget);
+	if (a.t === "record") return b.t === "record" && recordFits(a, b, domains, next, gradual, budget);
+	if (a.t !== "fn" || b.t !== "fn" || a.params.length > b.params.length) return false;
+	return a.params.every((param, index) => fitsAt(b.params[index], param, domains, next, gradual, true, budget)) && fitsAt(a.to, b.to, domains, next, gradual, true, budget);
+}
 /**
 * This function is the relation `fits` at one depth of two types. The order of its tests is the order of the rules of
 * `fits`. Without `gradual`, `unknown` is only the top: it fits only `unknown`. The join uses this strict form.
+*
+* When the rules of the shapes refuse a type with few members, the finite rule tests each member (TYPE.FITS-FINITE).
+* The cover rule and the split rule come after it. Without `finite`, the call skips these three rules. The members of
+* a union in `expected` get such calls, because the call for the union tests `found` against the full union.
+*
+* The budget is the budget of the outer split, when the call is part of the work of a split (TYPE.FITS-PATH, D89).
 */
-function fitsAt(found, expected, domains, depth, gradual = true) {
+function fitsAt(found, expected, domains, depth, gradual = true, finite = true, budget) {
 	if (depth > MAX_TYPE_DEPTH) return true;
 	const a = formOf(found, domains);
 	const b = formOf(expected, domains);
 	const next = depth + 1;
 	if (b.t === "top" || a.t === "bottom") return true;
 	if (a.t === "top") return gradual;
-	if (a.t === "union") return a.members.every((item) => fitsAt(item, expected, domains, next, gradual));
+	if (a.t === "union") return a.members.every((item) => fitsAt(item, expected, domains, next, gradual, true, budget));
 	if (a.t === "one") return a.values.every((item) => memberAt(item, expected, domains, next));
-	if (b.t === "bottom") return false;
-	if (b.t === "union") return b.members.some((item) => fitsAt(found, item, domains, next, gradual));
-	if (a.t === "base") return b.t === "base" && lineOf(a.name, domains).has(b.name);
-	if (a.t === "list") return b.t === "list" && fitsAt(a.item, b.item, domains, next, gradual);
-	if (a.t === "record") return b.t === "record" && recordFits(a, b, domains, next, gradual);
-	if (b.t !== "fn" || a.params.length > b.params.length) return false;
-	return a.params.every((param, index) => fitsAt(b.params[index], param, domains, next, gradual)) && fitsAt(a.to, b.to, domains, next, gradual);
+	if (b.t === "union" ? b.members.some((item) => fitsAt(found, item, domains, next, gradual, false, budget)) : b.t !== "bottom" && shapeFits(a, b, domains, next, gradual, budget)) return true;
+	if (!finite || a.t === "fn") return false;
+	const values = valuesOf$1(found, domains, next);
+	if (values !== void 0) return values.every((value) => memberAt(value, expected, domains, next));
+	if (a.t === "base") return (b.t === "union" || b.t === "one") && lineCovered(a.name, expected, domains, depth, gradual, void 0);
+	return a.t === "record" && (b.t === "union" || b.t === "one" && a.closed) && splitFits(found, a, expected, domains, depth, gradual, budget);
+}
+/**
+* This function is the cover rule of `fits` (TYPE.FITS-COVER, D85). A base type fits when a domain of its line has a
+* cover, and each domain of the cover fits `expected`. The function makes the state at the first domain with covers.
+*/
+function lineCovered(name, expected, domains, depth, gradual, state) {
+	let now = state;
+	for (const each of lineOf(name, domains)) {
+		if (!Array.isArray(domainOf(each, domains)?.covers)) continue;
+		now ??= {
+			held: /* @__PURE__ */ new Map(),
+			left: MAX_COVER_STEPS
+		};
+		if (covered(each, expected, domains, depth, gradual, now)) return true;
+	}
+	return false;
+}
+/**
+* This function tells if a cover of one domain holds the domain in `expected`. A cover that is empty, or that names
+* the domain or a name that is not under it, does not count. Each domain of a cover costs one step, and the rule
+* stops after 64 steps.
+*/
+function covered(name, expected, domains, depth, gradual, state) {
+	const known = state.held.get(name);
+	if (known !== void 0) return known;
+	state.held.set(name, false);
+	const covers = domainOf(name, domains)?.covers;
+	if (!Array.isArray(covers)) return false;
+	for (const cover of covers) {
+		if (!Array.isArray(cover) || cover.length === 0) continue;
+		let held = true;
+		for (const part of cover) {
+			state.left -= 1;
+			if (state.left < 0) return false;
+			if (typeof part !== "string" || part === name || !lineOf(part, domains).has(name) || !partFits(part, expected, domains, depth, gradual, state)) {
+				held = false;
+				break;
+			}
+		}
+		if (held) {
+			state.held.set(name, true);
+			return true;
+		}
+	}
+	return false;
+}
+/** This function tells if a domain of a cover fits `expected`. It tries the rules of the shapes, the finite rule and its own covers. */
+function partFits(part, expected, domains, depth, gradual, state) {
+	if (fitsAt(part, expected, domains, depth, gradual, false)) return true;
+	const values = valuesOf$1(part, domains, depth + 1);
+	if (values !== void 0) return values.every((value) => memberAt(value, expected, domains, depth + 1));
+	return lineCovered(part, expected, domains, depth, gradual, state);
+}
+/**
+* This function gives the fields that the split rule can split, in the order of the split (TYPE.FITS-PATH, D89). The
+* fields of the record come first, in the order of the keys. Then the paths of the next depth follow, and so on. A path
+* goes into a field only when the field is a record without a finite list. A field with a finite list of two or more
+* cases is a split. An optional field also has the absent case.
+*
+* The type splits follow each value split, in the same order (D90). A base type with a valid cover in its line splits
+* into the domains of the cover. A union without a finite list splits into its members. The prefix is the path of `a`.
+*/
+function splitsOf(a, domains, depth, prefix = []) {
+	const out = [];
+	const later = [];
+	let level = [{
+		path: prefix,
+		form: a
+	}];
+	for (let at = depth + 1; level.length > 0 && at <= MAX_TYPE_DEPTH; at += 1) {
+		const deeper = [];
+		for (const { path, form } of level) for (const key of Object.keys(form.fields)) {
+			const values = valuesOf$1(form.fields[key], domains, at);
+			const optional = form.optional.has(key);
+			if (values !== void 0) {
+				if (values.length + (optional ? 1 : 0) > 1) out.push({
+					path: [...path, key],
+					values,
+					optional
+				});
+				continue;
+			}
+			const inner = formOf(form.fields[key], domains);
+			if (inner.t === "record") deeper.push({
+				path: [...path, key],
+				form: inner
+			});
+			else if (inner.t === "union") later.push({
+				path: [...path, key],
+				types: inner.members,
+				optional
+			});
+			else if (inner.t === "base") {
+				const cover = coverOf(inner.name, domains, false);
+				if (cover !== void 0) later.push({
+					path: [...path, key],
+					types: cover,
+					optional
+				});
+			}
+		}
+		level = deeper;
+	}
+	return later.length === 0 ? out : [...out, ...later];
+}
+/** This function tells if a cover of a domain is valid by the line rule of D85. Such a cover is not empty, and each name in it is a domain under the domain. */
+function validCover(name, cover, domains) {
+	return Array.isArray(cover) && cover.length > 0 && cover.every((part) => typeof part === "string" && part !== name && lineOf(part, domains).has(name));
+}
+/**
+* This function gives the cover of a base type for a type split (D90). The cover is the first valid cover of the first
+* domain in the line with a valid cover. With `own`, only the domain of the type itself counts. Each other type gives
+* `undefined`.
+*/
+function coverOf(name, domains, own) {
+	for (const each of own ? [name] : lineOf(name, domains)) {
+		const covers = domainOf(each, domains)?.covers;
+		if (!Array.isArray(covers)) continue;
+		for (const cover of covers) if (validCover(each, cover, domains)) return cover;
+	}
+}
+/**
+* This function gives the splits of a case of a type split, at the path of the case (D90). A case with a finite list
+* splits by its members. A base type splits by a cover of its own domain, because the covers of its parents hold it
+* already. A union splits by its members, and a record splits by the paths into its fields.
+*/
+function againOf(type, path, domains, depth) {
+	const at = depth + path.length;
+	const values = valuesOf$1(type, domains, at);
+	if (values !== void 0) return values.length > 1 ? [{
+		path,
+		values,
+		optional: false
+	}] : [];
+	const form = formOf(type, domains);
+	if (form.t === "record") return splitsOf(form, domains, at, path);
+	if (form.t === "union") return [{
+		path,
+		types: form.members,
+		optional: false
+	}];
+	const cover = form.t === "base" ? coverOf(form.name, domains, true) : void 0;
+	return cover === void 0 ? [] : [{
+		path,
+		types: cover,
+		optional: false
+	}];
+}
+/**
+* This function gives a copy of a record type with one field narrowed at a path. A case type replaces the field. The
+* absent case removes the field of a closed record, and it gives an optional field of type `never` in an open record.
+*/
+function narrowAt(type, path, at, narrowed, domains) {
+	const form = formOf(type, domains);
+	const key = path[at];
+	if (form.t !== "record" || key === void 0) return type;
+	const last = at + 1 === path.length;
+	const fields = {};
+	for (const name of Object.keys(form.fields)) if (name !== key) setOwn$6(fields, name, form.fields[name]);
+	else if (!last) setOwn$6(fields, name, narrowAt(form.fields[name], path, at + 1, narrowed, domains));
+	else if (narrowed !== void 0) setOwn$6(fields, name, narrowed);
+	else if (!form.closed) setOwn$6(fields, name, "never");
+	const optional = [...form.optional].filter((name) => !last || name !== key || narrowed === void 0 && !form.closed);
+	return {
+		record: fields,
+		...optional.length === 0 ? {} : { 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
+* record with the field narrowed to that member. An optional field also gives a record without the field. A type split
+* narrows the field to each case type instead (TYPE.FITS-SPLIT-TYPE, D90).
+*
+* A record of the split that does not fit splits the next such field. A record of a type split first splits its case
+* again, at the same path. One budget of 64 records serves the outer split and each split inside its work, at each
+* depth. Thus nested splits do not multiply the work.
+*/
+function splitFits(found, a, expected, domains, depth, gradual, budget) {
+	const splits = splitsOf(a, domains, depth);
+	if (splits.length === 0) return false;
+	return casesFit(found, a.closed, splits, 0, expected, domains, depth, gradual, budget ?? { left: MAX_SPLIT_RECORDS });
+}
+/** This function tells if each record of the split of one field fits `expected`. It splits the next field for a record that does not fit. */
+function casesFit(type, closed, splits, index, expected, domains, depth, gradual, budget) {
+	const split = splits[index];
+	if (split === void 0) return false;
+	const cases = (split.values?.map((value) => ({ one: [value] })) ?? split.types ?? []).map((each) => narrowAt(type, split.path, 0, each, domains));
+	if (split.optional) cases.push(narrowAt(type, split.path, 0, void 0, domains));
+	for (const [at, record] of cases.entries()) {
+		budget.left -= 1;
+		if (budget.left < 0) return false;
+		if (fitsAt(record, expected, domains, depth, gradual, false, budget)) continue;
+		const values = closed ? valuesOf$1(record, domains, depth + 1) : void 0;
+		if (values !== void 0) {
+			if (values.every((value) => memberAt(value, expected, domains, depth + 1))) continue;
+			return false;
+		}
+		const again = split.types !== void 0 && at < split.types.length ? againOf(split.types[at], split.path, domains, depth) : [];
+		if (!casesFit(record, closed, again.length === 0 ? splits : [...again, ...splits.slice(index + 1)], again.length === 0 ? index + 1 : 0, expected, domains, depth, gradual, budget)) return false;
+	}
+	return true;
 }
 /**
 * This function tells if each value of the type `found` can be where the type `expected` must be (TYPE.FITS). Each
@@ -794,9 +1122,33 @@ function fitsAt(found, expected, domains, depth, gradual = true) {
 *   field is `unknown`.
 * - A function fits when it has the same or fewer parameters, each expected parameter fits its parameter, and its
 *   result fits.
-*
-* The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types. It is not
-* complete. For example, `bool` does not fit `{ "one": [true, false] }`. The function does not throw.
+* - The finite rule comes after these rules (TYPE.FITS-FINITE). A type with at most 64 members fits when each member
+*   is a member of `expected`. Thus `bool` fits `{ "one": [true, false] }`.
+* - A base type has few members when its domain or a parent declares `values`, as `null`, `undefined` and `bool` do.
+*   A union, a `one`, a closed record of such types and a list of `never` also have few members.
+* - The cover rule comes next (TYPE.FITS-COVER, D85). A base type fits a union or a `one` when each domain of a cover
+*   fits. The cover is in `covers` of a domain of its line. Each domain of a cover is under the covered
+*   domain. Thus a cover of `number` by `neg` and `nonneg` gives `number` a fit against `neg | nonneg`.
+* - The split rule comes last (D84). An open record, or a closed record with more than 64 members, splits a field with
+*   few members over a union. A closed record also splits over a `one`. Each record of the split narrows the field to
+*   one member, and each record must fit.
+*   Thus `{ "record": { "a": "bool" } }` fits a union of a record for each value of `a`.
+* - A split also narrows a field of a record in a field, by its path (TYPE.FITS-PATH, D89). The fields of the record
+*   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
+*   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
+* - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
+*   its line splits into the domains of the first such cover. A field of a union without a finite list splits into its
+*   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only a
+*   cover of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+*
+* The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
+* (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
+* or a false cover makes the relation unsound for that domain.
+*
+* The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. A
+* type split uses one cover of a field, not each cover of its line. A domain without `values` gets no finite rule, and
+* neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
+* covers. The function does not throw.
 *
 * @param found - The type that a part has.
 * @param expected - The type that the position needs.
@@ -807,7 +1159,7 @@ function fits(found, expected, domains) {
 	return fitsAt(found, expected, domains, 0);
 }
 /** This function sets an own field of a new record. Only the key `__proto__` needs `defineProperty`. */
-function setOwn$5(target, key, value) {
+function setOwn$6(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -826,10 +1178,10 @@ function joinRecords(a, b, domains, depth) {
 		const inA = Object.hasOwn(a.fields, key);
 		const inB = Object.hasOwn(b.fields, key);
 		if (inA && inB) {
-			setOwn$5(fields, key, joinAt(a.fields[key], b.fields[key], domains, depth));
+			setOwn$6(fields, key, joinAt(a.fields[key], b.fields[key], domains, depth));
 			if (a.optional.has(key) || b.optional.has(key)) optional.push(key);
 		} else if (closed) {
-			setOwn$5(fields, key, inA ? a.fields[key] : b.fields[key]);
+			setOwn$6(fields, key, inA ? a.fields[key] : b.fields[key]);
 			optional.push(key);
 		}
 	}
@@ -932,7 +1284,7 @@ function valueText$1(value) {
 function textAt(type, depth, wrap) {
 	if (depth > MAX_TYPE_DEPTH) return "unknown";
 	if (typeof type === "string") return type;
-	const term = isRecord(type) ? termOf$1(type) : void 0;
+	const term = isRecord(type) ? termOf$2(type) : void 0;
 	if (!isRecord(type) || term === void 0) return "unknown";
 	const next = depth + 1;
 	const group = (items) => items.length === 0 ? "never" : items.length > 1 && wrap ? `(${items.join(" | ")})` : items.join(" | ");
@@ -1155,7 +1507,7 @@ function typeIssues(type, domains) {
 			if (here !== "unknown" && here !== "never" && domainOf(here, domains) === void 0) issue(`The machine has no domain ${here}.`);
 			continue;
 		}
-		const term = isRecord(here) ? termOf$1(here) : void 0;
+		const term = isRecord(here) ? termOf$2(here) : void 0;
 		if (!isRecord(here) || term === void 0) {
 			issue(`A value type is a text, or a record with one of the keys ${TERMS.join(", ")} and the keys that go with it.`);
 			continue;
@@ -1233,7 +1585,7 @@ function keyOf(path) {
 	return JSON.stringify(path.map(String));
 }
 /** This function sets an own data property. An assignment to the key `__proto__` changes the prototype. */
-function setOwn$4(target, key, value) {
+function setOwn$5(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -1250,7 +1602,7 @@ function defined(value) {
 	if (Array.isArray(value)) return value.map(defined);
 	if (!isRecord(value)) return value;
 	const out = {};
-	for (const key of Object.keys(value)) if (value[key] !== void 0) setOwn$4(out, key, defined(value[key]));
+	for (const key of Object.keys(value)) if (value[key] !== void 0) setOwn$5(out, key, defined(value[key]));
 	return out;
 }
 /** Two values are the same when they are equal by `docEquals`. A function and a host value are equal only to themselves. */
@@ -1259,23 +1611,38 @@ function same(a, b) {
 }
 /**
 * Two domains are the same when they are one object. They are also the same when they have the same test `is`,
-* parents, summary and steps. Thus two languages that give one test under one name give one domain.
+* parents, summary, steps, codec, list of values and covers. Thus two languages that give one test under one name give one
+* domain. Two codecs are the same when they have the same functions `encode` and `decode` (D80).
 */
 function sameDomain(a, b) {
-	return a === b || a.is === b.is && same(a.under ?? [], b.under ?? []) && a.summary === b.summary && same(a.steps ?? {}, b.steps ?? {});
+	if (a === b) return true;
+	const fields = {
+		is: a.is === b.is,
+		under: same(a.under ?? [], b.under ?? []),
+		summary: a.summary === b.summary,
+		steps: same(a.steps ?? {}, b.steps ?? {}),
+		codec: same(a.codec ?? null, b.codec ?? null),
+		values: same(a.values ?? null, b.values ?? null),
+		covers: same(a.covers ?? [], b.covers ?? [])
+	};
+	return Object.values(fields).every(Boolean);
 }
 /**
-* This function makes a part of a merge that adds parents or steps to a domain of an earlier part (TYPE.PARENTS). An
-* example is a domain of another language. The part reads the domain from the merge before it (`prev`). It gives a
-* copy with the same test and summary, and it names `["domains", name]` in `replaces` (D17). A domain of the kernel
-* that the earlier parts do not name comes from `STD_DOMAINS`.
+* This function makes a part of a merge that adds parents, steps or covers to a domain of an earlier part
+* (TYPE.PARENTS). An example is a domain of another language. The part reads the domain from the merge before it
+* (`prev`). It gives a copy with the same test, summary, codec and list of values, and it names `["domains", name]`
+* in `replaces` (D17).
+* A domain of the kernel that the earlier parts do not name comes from `STD_DOMAINS`.
+*
+* An extension does not change the codec. Thus each member keeps its document (D80).
 *
 * A new parent adds its test to the domain (TYPE.MEMBER). Thus `fits` stays sound, but a value that fails the test of
 * the parent is no longer a member. The language that adds the parent keeps the signatures of the other language
-* true. A name without a domain gives an empty part, and `typeIssues` reports each use of that name.
+* true. A new parent of a domain in a cover of another domain can make that cover false (D85). A name without a
+* domain gives an empty part, and `typeIssues` reports each use of that name.
 *
 * @param name - The name of the domain.
-* @param more - The parents and the steps to add.
+* @param more - The parents, the steps and the covers to add.
 * @returns The part, as a function of the merge before it.
 */
 function extendDomain(name, more) {
@@ -1288,14 +1655,21 @@ function extendDomain(name, more) {
 			...found.steps,
 			...more.steps
 		};
-		const domain = {
+		const covers = [...found.covers ?? []];
+		for (const cover of more.covers ?? []) if (!covers.some((each) => same(each, cover))) covers.push([...cover]);
+		const fields = {
 			is: found.is,
-			...under.length === 0 ? {} : { under },
-			...found.summary === void 0 ? {} : { summary: found.summary },
-			...Object.keys(steps).length === 0 ? {} : { steps }
+			under: under.length === 0 ? void 0 : under,
+			summary: found.summary,
+			steps: Object.keys(steps).length === 0 ? void 0 : steps,
+			codec: found.codec,
+			values: found.values,
+			covers: covers.length === 0 ? void 0 : covers
 		};
+		const domain = {};
+		for (const [key, value] of Object.entries(fields)) if (value !== void 0) domain[key] = value;
 		const domains = {};
-		setOwn$4(domains, name, domain);
+		setOwn$5(domains, name, domain);
 		return {
 			domains,
 			replaces: [["domains", name]]
@@ -1345,10 +1719,10 @@ function mergeLeaf(m, table, key, later, path, part, replaces, equal, reason) {
 	if (later === void 0) return;
 	const earlier = own$2(table, key);
 	if (earlier === void 0) {
-		setOwn$4(table, key, later);
+		setOwn$5(table, key, later);
 		m.give(path, part);
 	} else if (replaces.has(keyOf(path))) {
-		setOwn$4(table, key, later);
+		setOwn$5(table, key, later);
 		m.replace(path, part);
 	} else if (!equal(earlier, later)) m.clash(path, part, reason);
 }
@@ -1369,9 +1743,9 @@ function mergeEntries(m, into, from, path, part, replaces) {
 		const at = [...path, key];
 		const earlier = own$2(into, key);
 		if (earlier === void 0) {
-			setOwn$4(into, key, later);
+			setOwn$5(into, key, later);
 			m.give(at, part);
-		} else setOwn$4(into, key, mergeEntry(m, earlier, later, at, part, replaces));
+		} else setOwn$5(into, key, mergeEntry(m, earlier, later, at, part, replaces));
 	}
 }
 /** This function merges two entries at one path. Two namespaces merge key by key, and their fallbacks merge too. */
@@ -1524,8 +1898,8 @@ function mergeCode(m, draft, part, index, replaces) {
 		const runnerPath = ["runners", name];
 		if (replaces.has(keyOf(evaluatorPath)) || replaces.has(keyOf(runnerPath))) {
 			if (evaluator === void 0) delete draft.evaluators[name];
-			else setOwn$4(draft.evaluators, name, evaluator);
-			if (runner !== void 0) setOwn$4(draft.runners ??= {}, name, runner);
+			else setOwn$5(draft.evaluators, name, evaluator);
+			if (runner !== void 0) setOwn$5(draft.runners ??= {}, name, runner);
 			else if (draft.runners !== void 0) delete draft.runners[name];
 			m.replace(evaluatorPath, index);
 			m.replace(runnerPath, index);
@@ -1648,7 +2022,7 @@ function removeEntry(entries, path) {
 	}
 	const out = { ...entries };
 	if (next === void 0) delete out[key];
-	else setOwn$4(out, key, next);
+	else setOwn$5(out, key, next);
 	return out;
 }
 /**
@@ -2043,11 +2417,12 @@ function derefStep(nav, thing, key) {
 		const derefs = nav.derefs;
 		const answer = derefs === void 0 ? void 0 : answerOf(nav.world, ownEntries(envelope), kindFor(nav.world, envelope.type), "deref", (name) => codeIn(derefs, name));
 		if (answer !== void 0) {
-			const reached = derefs[answer.name]?.(envelope, key);
-			return reached === void 0 ? void 0 : {
+			const code = derefs[answer.name];
+			const reached = code?.(envelope, key);
+			return reached !== void 0 || code?.has?.(envelope, key) === true ? {
 				thing: reached,
 				by: answer.rung
-			};
+			} : void 0;
 		}
 		const reached = plainStep(envelope.value, key);
 		return reached === NOTHING ? void 0 : {
@@ -2285,6 +2660,25 @@ function resolve(nav, ctx, path, options = {}) {
 	}
 	return resolveFully$1(nav, ctx, path, options.hops === false ? void 0 : [], void 0);
 }
+/** The functions of the last navigator that gave a walker its input. A walk with the same navigator makes no new functions. */
+let lastSteps;
+/**
+* This function gives the functions `deref` and `has` of the input of a walker. They depend only on the navigator,
+* thus the function keeps the functions of the last navigator (K170).
+*/
+function walkSteps(nav) {
+	if (lastSteps !== void 0 && lastSteps.nav === nav) return lastSteps;
+	const adopt = nav.adopt;
+	lastSteps = {
+		nav,
+		deref: adopt === void 0 ? (thing, key) => derefStep(nav, thing, key)?.thing : (thing, key) => {
+			const reached = derefStep(nav, thing, key);
+			return reached === void 0 ? void 0 : adopt(reached.thing);
+		},
+		has: (thing, key) => derefStep(nav, thing, key) !== void 0
+	};
+	return lastSteps;
+}
 /**
 * This function resolves a path with the full algorithm of `resolve`.
 *
@@ -2379,14 +2773,24 @@ function resolveFully$1(nav, ctx, path, hops, known) {
 				const walker = given === void 0 ? walkerOf(nav, step) : given ?? void 0;
 				if (walker === void 0) return failed("#STEP?", "A step is a key, or a document of a kind with the verb step.");
 				const envelope = step;
-				const result = walker({
+				const { deref, has } = walkSteps(nav);
+				const result = walker(hops === void 0 ? {
 					data: envelope.value,
 					here,
 					context: ctx,
-					deref: (thing, key) => {
-						const reached = derefStep(nav, thing, key);
-						return reached === void 0 ? void 0 : adopt(reached.thing);
-					}
+					deref,
+					has
+				} : {
+					data: envelope.value,
+					here,
+					context: ctx,
+					deref,
+					has,
+					visit: (key, thing) => hops.push({
+						step: key,
+						thing,
+						by: "step"
+					})
 				});
 				if (!result.ok) return failed(result.code ?? "#N/A", result.reason);
 				here = adopt(result.thing);
@@ -2468,7 +2872,7 @@ var Bad = class {
 	}
 };
 /** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
-function setOwn$3(target, key, value) {
+function setOwn$4(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -2482,7 +2886,7 @@ function hasSlots(template) {
 	return template.t !== "data";
 }
 /** This function gives the shape of a part with the default type `of` and the value type `expect` of its container. */
-function termOf(of, expect) {
+function termOf$1(of, expect) {
 	return {
 		shape: "term",
 		...of === void 0 ? {} : { of },
@@ -2591,7 +2995,7 @@ function splitParts(shape, value) {
 				const twice = list.findIndex((child, index) => list.slice(0, index).some((before) => docEquals(before, child)));
 				if (twice !== -1) throw new Bad("The items of the list must be different.", [...path, twice]);
 			}
-			const each = spec.item ?? termOf(spec.of, spec.expect);
+			const each = spec.item ?? termOf$1(spec.of, spec.expect);
 			const items = list.map((child, index) => walk(each, child, [...path, index]));
 			return isData(each) ? {
 				t: "data",
@@ -2603,14 +3007,14 @@ function splitParts(shape, value) {
 		}
 		if (!isRecord(item)) throw new Bad("The value must be a record.", path);
 		if (spec.shape === "map") {
-			const each = spec.item ?? termOf(spec.of, spec.expect);
+			const each = spec.item ?? termOf$1(spec.of, spec.expect);
 			return {
 				t: "record",
 				fields: Object.keys(item).map((key) => [key, walk(each, item[key], [...path, key])])
 			};
 		}
 		for (const name of spec.required ?? []) if (!Object.hasOwn(item, name)) throw new Bad(`The field ${name} is missing.`, path);
-		const named = Array.isArray(spec.fields) ? Object.fromEntries(spec.fields.map((name) => [name, termOf(spec.of, spec.expect)])) : spec.fields;
+		const named = Array.isArray(spec.fields) ? Object.fromEntries(spec.fields.map((name) => [name, termOf$1(spec.of, spec.expect)])) : spec.fields;
 		const fields = [];
 		for (const key of Object.keys(item)) {
 			if (spec.closed === true && !Object.hasOwn(named, key)) throw new Bad(`The field ${key} is not a field of this kind.`, [...path, key]);
@@ -2640,7 +3044,7 @@ function splitParts(shape, value) {
 		const out = {};
 		for (const [key, child] of node.fields) {
 			const kept = strip(child);
-			if (kept !== void 0) setOwn$3(out, key, kept);
+			if (kept !== void 0) setOwn$4(out, key, kept);
 		}
 		return out;
 	};
@@ -2649,7 +3053,7 @@ function splitParts(shape, value) {
 		if (node.t === "slot") return handles[node.index];
 		if (node.t === "list") return node.items.map((child) => fillWith(child, handles));
 		const out = {};
-		for (const [key, child] of node.fields) setOwn$3(out, key, fillWith(child, handles));
+		for (const [key, child] of node.fields) setOwn$4(out, key, fillWith(child, handles));
 		return out;
 	};
 	return {
@@ -2907,10 +3311,19 @@ const GRANT = /* @__PURE__ */ Symbol("coeval.grant");
 /**
 * The key of the epoch of a grant (CAP.NARROW-KEPT). The epoch is the list of capabilities that the host gave the root
 * of the evaluation of the grant. A spread of a context keeps its epoch, as it keeps its grant. An
-* effect and a resolution read a context of another epoch as a context without a grant.
+* effect and a resolution read a context of another epoch as a context without a grant. The root has no field of
+* the epoch, because its grant is the list of the host (`epochOf`).
 */
 const EPOCH = /* @__PURE__ */ Symbol("coeval.epoch");
 /**
+* This function gives the epoch of the grant of a context (CAP.NARROW-KEPT). A context without the field of the epoch
+* has the epoch of its grant. Only a root has no field, thus its grant is the list of the host. The root then has
+* one field fewer, and each evaluation makes it faster (K154).
+*/
+function epochOf(ctx) {
+	return ctx[EPOCH] ?? ctx[GRANT];
+}
+/**
 * This function gives the capabilities that a context and its grant both permit, the meet `intersectCaps` (CAP.MEET).
 * A context whose grant is its own list gives that list after one comparison. A context without a grant gives none.
 */
@@ -2930,10 +3343,36 @@ function granted(ctx) {
 	return {
 		...ctx,
 		caps,
-		[GRANT]: caps
+		[GRANT]: caps,
+		[EPOCH]: epochOf(ctx)
 	};
 }
 /**
+* This function tells if a list of capabilities is equal to the epoch of the evaluation (CAP.EPOCH-EQUAL). An equal list
+* has the same length, and at each index the same text or the same keys in the same order. The runtime uses it only
+* when the two lists are not the same object. Thus a host that gives a new copy of its list for each evaluation keeps
+* the grant of a kept context.
+*/
+function sameCaps(caps, epoch) {
+	if (caps === void 0 || caps.length !== epoch.length) return false;
+	for (let index = 0; index < caps.length; index += 1) {
+		const a = caps[index];
+		const b = epoch[index];
+		if (a === b) continue;
+		if (typeof a === "string" || typeof b === "string" || a.length !== b.length) return false;
+		for (let key = 0; key < a.length; key += 1) if (!Object.is(a[key], b[key])) return false;
+	}
+	return true;
+}
+/**
+* This function tells if a context has the epoch of the evaluation: the same list, or an equal list (CAP.NARROW-KEPT,
+* CAP.EPOCH-EQUAL). The comparison of the entries happens only when the two lists are not the same object.
+*/
+function inEpoch(ctx, epoch) {
+	const own = epochOf(ctx);
+	return own === epoch || sameCaps(own, epoch);
+}
+/**
 * This function gives a context of another epoch the epoch of the evaluation, without capabilities (CAP.NARROW-KEPT).
 * Thus the context reads as a context without a grant. The kernel cannot know the document of the context in this
 * evaluation.
@@ -2951,16 +3390,26 @@ function ungranted(ctx, epoch) {
 * The context has the meet of its list and its grant, and a context without a grant has none. Thus a read of the root
 * `caps` and a walker of a step document get the capabilities of the document from a widened context.
 * A context that the code narrowed keeps its own list. A context whose list does not change stays the same object.
-* A context of another epoch has no capabilities (CAP.NARROW-KEPT).
+*
+* A context of another epoch has no capabilities (CAP.NARROW-KEPT). An equal list of the host is the same epoch
+* (CAP.EPOCH-EQUAL). The first test answers for a context of the epoch whose grant is its list, for example the root.
+* The other contexts go to `readableOther`, thus the hot part of the function stays small (K154).
 */
 function readable(ctx, epoch) {
-	if (ctx[EPOCH] !== epoch) return ctx.caps.length === 0 ? ctx : ungranted(ctx, epoch);
+	const grant = ctx[GRANT];
+	if (grant === ctx.caps && (ctx[EPOCH] ?? grant) === epoch) return ctx;
+	return readableOther(ctx, epoch);
+}
+/** This function gives the result of `readable` for each other context: a context of another epoch or a narrowed context. */
+function readableOther(ctx, epoch) {
+	if (!inEpoch(ctx, epoch)) return ctx.caps.length === 0 ? ctx : ungranted(ctx, epoch);
 	const caps = grantedCaps(ctx);
 	if (caps === ctx.caps || caps.length === 0 && ctx.caps.length === 0) return ctx;
 	return {
 		...ctx,
 		caps,
-		[GRANT]: caps
+		[GRANT]: caps,
+		[EPOCH]: epochOf(ctx)
 	};
 }
 /**
@@ -2970,8 +3419,8 @@ function readable(ctx, epoch) {
 */
 function handed(parent, next) {
 	const ctx = narrow(parent, next);
-	const epoch = parent[EPOCH];
-	if (ctx[GRANT] === ctx.caps && ctx[EPOCH] === epoch) return ctx;
+	const epoch = epochOf(parent);
+	if (ctx[GRANT] === ctx.caps && epochOf(ctx) === epoch) return ctx;
 	return {
 		...ctx,
 		[GRANT]: ctx.caps,
@@ -2979,7 +3428,7 @@ function handed(parent, next) {
 	};
 }
 /** The text that names a resolution in the error of an exception of the host. */
-const READ_FAILED = "the resolution of a path";
+const READ_FAILED$1 = "the resolution of a path";
 /**
 * This function gives what a resolution reached as a result: the thing, or the error with its code and its reason.
 * The record of a read and `verifyReads` share it.
@@ -3008,7 +3457,7 @@ function readAgain(nav, ctx, path, hops) {
 			hops: found.hops
 		} : { reached: reachedOf(found) };
 	} catch (error) {
-		return { reached: thrown(error, READ_FAILED) };
+		return { reached: thrown(error, READ_FAILED$1) };
 	}
 }
 /**
@@ -3084,25 +3533,85 @@ const WITHOUT_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
 const WITH_HOPS = /* @__PURE__ */ Object.freeze({ hops: true });
 /**
 * This function gives the path of a kept read (READS.CLOSURE). The evaluation did not ask for the read. Thus the read
-* does not step into a host thing, and the path ends at the first host thing. The host gives a new thing for a new state.
+* does not step into a host thing with `deref`. A host thing with `known` answers a step without new work
+* (SCHED.CLOSURE). Each other host thing ends the path, and a host thing that does not know the step ends it too.
 * A reference in the data reads the context of its reader, thus the function then gives `undefined`.
 *
 * @param nav - The world and the code of the evaluators.
 * @param root - The context at the root of the evaluation.
 * @param path - The root and the keys of the static read.
-* @returns The path of the kept read, or `undefined` for a reference on the way.
+* @returns The path of the kept read with what it reached after a step of `known`, or `undefined` for a reference on the way.
 */
 function keptPath(nav, root, path) {
 	const adopt = nav.adopt ?? ((value) => value);
 	let here = adopt(root[path[0]]);
+	let known = false;
+	const end = (index) => {
+		const kept = index >= path.length ? path : path.slice(0, index);
+		return known ? {
+			path: kept,
+			reached: ok(here)
+		} : { path: kept };
+	};
 	for (let index = 1;; index += 1) {
-		if (isHostThing(here)) return index === path.length ? path : path.slice(0, index);
+		if (isHostThing(here)) {
+			if (index >= path.length || here.known === void 0) return end(index);
+			let step;
+			try {
+				step = here.known(path[index]);
+			} catch (error) {
+				return {
+					path: path.slice(0, index + 1),
+					reached: thrown(error, READ_FAILED$1)
+				};
+			}
+			if (step === void 0) return end(index);
+			known = true;
+			here = adopt(step.thing);
+			continue;
+		}
 		if (nav.plain !== true && isRef(here)) return void 0;
-		if (index >= path.length) return path;
+		if (index >= path.length) return end(index);
+		const reached = derefStep(nav, here, path[index]);
+		if (reached === void 0) return known ? end(index) : { path };
+		here = adopt(reached.thing);
+	}
+}
+/**
+* This function resolves the path of a kept read again, for `verifyReads` (SCHED.CLOSURE). It walks the path as
+* `keptPath` did. A host thing with `known` answers its step. A path without such a step resolves with `readAgain`.
+*
+* @param nav - The world and the code of the evaluators.
+* @param ctx - The new context.
+* @param path - The path of the kept read.
+* @returns What the path reaches, or `undefined` when a host does not know a step yet. Then the read changed.
+*/
+function keptAgain(nav, ctx, path) {
+	const adopt = nav.adopt ?? ((value) => value);
+	let here = adopt(ctx[path[0]]);
+	let known = false;
+	const other = () => known ? void 0 : readAgain(nav, ctx, path, false).reached;
+	for (let index = 1; index < path.length; index += 1) {
+		if (isHostThing(here)) {
+			if (here.known === void 0) return other();
+			let step;
+			try {
+				step = here.known(path[index]);
+			} catch (error) {
+				return thrown(error, READ_FAILED$1);
+			}
+			if (step === void 0) return void 0;
+			known = true;
+			here = adopt(step.thing);
+			continue;
+		}
+		if (nav.plain !== true && isRef(here)) return other();
 		const reached = derefStep(nav, here, path[index]);
-		if (reached === void 0) return path;
+		if (reached === void 0) return other();
 		here = adopt(reached.thing);
 	}
+	if (!known) return other();
+	return nav.plain !== true && isRef(here) ? void 0 : ok(here);
 }
 /** This function makes the record of the reads of an evaluation, when the host gives a list. */
 function readingOf(list, root) {
@@ -3184,7 +3693,7 @@ var Session = class {
 		} catch (error) {
 			reading.list.push({
 				path,
-				reached: thrown(error, READ_FAILED),
+				reached: thrown(error, READ_FAILED$1),
 				free
 			});
 			throw error;
@@ -3233,8 +3742,9 @@ var Session = class {
 			return true;
 		}
 		if (root === "self" && reading.self) return true;
-		const path = keptPath(this.machine, reading.root, read.exact ? exact : [root]);
-		if (path === void 0) return false;
+		const walk = keptPath(this.machine, reading.root, read.exact ? exact : [root]);
+		if (walk === void 0) return false;
+		const path = walk.path;
 		const paths = reading.paths ??= /* @__PURE__ */ new Set();
 		const text = JSON.stringify(path);
 		if (paths.has(text) || paths.has(JSON.stringify([root]))) return true;
@@ -3242,7 +3752,7 @@ var Session = class {
 		if (path.length === 1 && root === "self") reading.self = true;
 		reading.list.push({
 			path,
-			reached: readAgain(this.machine, reading.root, path, false).reached,
+			reached: walk.reached ?? readAgain(this.machine, reading.root, path, false).reached,
 			free: true,
 			kept: true
 		});
@@ -3271,10 +3781,10 @@ var Session = class {
 	* This function checks the capability of an effect, and records the effect with its address (RUN.ADDRESS). The
 	* context keeps only the capabilities of its grant, thus compiled code cannot widen the context of its own effect
 	* (CAP.NARROW-CODE). A context of another epoch has no capabilities, thus code cannot keep a context for a later
-	* evaluation with fewer capabilities (CAP.NARROW-KEPT).
+	* evaluation with fewer capabilities (CAP.NARROW-KEPT). An equal list of the host is the same epoch (CAP.EPOCH-EQUAL).
 	*/
 	record(given, kind, payload, place) {
-		const ctx = given[EPOCH] === this.epoch ? granted(given) : ungranted(given, this.epoch);
+		const ctx = inEpoch(given, this.epoch) ? granted(given) : ungranted(given, this.epoch);
 		const keys = typeof kind === "string" ? kind.split(".") : kind;
 		const text = keys.join(".");
 		if (!this.permitted(ctx, keys)) return fail("#CAP!", `The context has no capability for the effect ${text}.`, { place });
@@ -3357,6 +3867,7 @@ var Session = class {
 		let failed = false;
 		const active = [];
 		let next = 0;
+		let before = 0;
 		const settle = (index, result) => {
 			results[index] = result;
 			if (failFast && !result.ok) failed = true;
@@ -3420,10 +3931,11 @@ var Session = class {
 		};
 		start();
 		while (active.length > 0 && !failed) {
-			const chosen = journal?.next?.(address, active.map((item) => item.index));
+			const chosen = journal?.next?.(address, active.map((item) => item.index), before);
 			const pick = chosen === void 0 ? void 0 : active.find((item) => item.index === chosen);
 			const settled = yield pick === void 0 ? Promise.race(active.map((item) => item.pending)) : pick.pending;
 			journal?.settled?.(address, settled.item.index);
+			before += 1;
 			active.splice(active.indexOf(settled.item), 1);
 			advance(settled.item.index, settled.item.steps, settled);
 			start();
@@ -3734,7 +4246,10 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	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;
-	return free.length === 0 ? folded(c, done) : {
+	if (free.length === 0) return folded(c, done, void 0);
+	const fixed = c.fixed;
+	if (fixed !== void 0 && free.every((each) => Object.hasOwn(fixed, each))) return folded(c, done, free);
+	return {
 		code: done.code,
 		run: done.run,
 		free
@@ -3814,6 +4329,21 @@ var Probe = class {
 		};
 		this.root = root;
 	}
+	/** The context of a part that folds with fixed names: the context of the probe, with the fixed names (PLAN.FIXED). */
+	withFixed;
+	/**
+	* This function gives the context of a part that folds with fixed names. Its root `names` holds only the fixed
+	* names, thus the probe resolves each fixed name and refuses each other name.
+	*
+	* @param fixed - The fixed names and their values.
+	* @returns The context.
+	*/
+	fixedRoot(fixed) {
+		return this.withFixed ??= {
+			...this.root,
+			names: fixed
+		};
+	}
 	resolve(ctx, path) {
 		const name = path[1];
 		if (path[0] === "names" && isKey(name) && Object.hasOwn(ctx.names, String(name))) {
@@ -3872,13 +4402,14 @@ function trap(refuse, copies) {
 * one deeply frozen copy, and the code gives that copy at each evaluation (PLAN.SHARED). A fold that the probe cancels
 * gives the code without free names, thus no parent tries the fold again.
 */
-function folded(c, done) {
+function folded(c, done, fixed) {
 	const probe = c.probe ??= new Probe(c.machine);
 	probe.refused = false;
 	probe.reads = 0;
 	let constant;
 	try {
-		const result = done.code(probe.root, probe);
+		const root = fixed === void 0 ? probe.root : probe.fixedRoot(c.fixed);
+		const result = done.code(root, probe);
 		if (!probe.refused && (result.ok || result.error.code !== "#DEPTH!")) constant = sharedCopy(result);
 	} catch {
 		constant = void 0;
@@ -3888,18 +4419,100 @@ function folded(c, done) {
 		run: done.run
 	};
 	const value = constant;
+	const original = done.code;
+	if (fixed !== void 0) return {
+		code: fixedCode(fixed, c.fixed, value, original),
+		run: void 0,
+		free: fixed
+	};
 	if (probe.reads === 0) return {
 		code: () => value,
 		run: void 0,
 		free: CLOSED
 	};
-	const original = done.code;
 	return {
 		code: (ctx, rt) => rt instanceof Session && !rt.traced && !rt.recording ? value : original(ctx, rt),
 		run: void 0,
 		free: CLOSED
 	};
 }
+/**
+* This function gives the code of a part that folded with fixed names (PLAN.FIXED, D60). The code gives the folded
+* value when the context has the fixed value of each name, by an own-key test and `Object.is`. A fixed value is
+* deeply frozen, thus the same object gives the same result. Each other context, a list of reads and another runtime
+* get the code without the fold. The probe of a parent fold gets the folded value, and it counts a read.
+*/
+function fixedCode(names, fixed, value, original) {
+	if (names.length === 1) {
+		const name = names[0];
+		const want = fixed[name];
+		return (ctx, rt) => {
+			const given = ctx.names;
+			return Object.hasOwn(given, name) && Object.is(given[name], want) && folds(rt) ? value : original(ctx, rt);
+		};
+	}
+	const wants = names.map((name) => fixed[name]);
+	return (ctx, rt) => {
+		const given = ctx.names;
+		for (let index = 0; index < names.length; index += 1) {
+			const name = names[index];
+			if (!Object.hasOwn(given, name) || !Object.is(given[name], wants[index])) return original(ctx, rt);
+		}
+		return folds(rt) ? value : original(ctx, rt);
+	};
+}
+/**
+* This function tells if the code of a part with fixed names can give its folded value in a runtime. The probe of a
+* fold counts the read of the part, as the code without the fold reads the names.
+*/
+function folds(rt) {
+	if (rt instanceof Session) return !rt.recording;
+	if (!(rt instanceof Probe)) return false;
+	rt.reads += 1;
+	return true;
+}
+/**
+* This function gives the fixed names of the options of `prepare` (PLAN.FIXED). A name fixes only when its value is
+* deeply frozen plain data. Then no change in place can make the folded value stale.
+*
+* @returns A record without a prototype, or `undefined` when no name fixes.
+*/
+function fixedNamesOf(given) {
+	if (given === void 0) return void 0;
+	let out;
+	for (const name of Object.keys(given)) {
+		const value = given[name];
+		if (!frozenPlain(value)) continue;
+		out ??= Object.create(null);
+		Object.defineProperty(out, name, {
+			value,
+			enumerable: true
+		});
+	}
+	return out;
+}
+/** This function tells if a value is plain data, as `sharedCopy` reads it, and if each of its objects is frozen. */
+function frozenPlain(value) {
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (here) => {
+		if (typeof here === "function") return false;
+		if (typeof here !== "object" || here === null || SHARED.has(here) || seen.has(here)) return true;
+		if (!Object.isFrozen(here)) return false;
+		seen.add(here);
+		const proto = Object.getPrototypeOf(here);
+		if (Array.isArray(here) ? proto !== Array.prototype : proto !== Object.prototype && proto !== null) return false;
+		for (const key of Reflect.ownKeys(here)) {
+			const field = Object.getOwnPropertyDescriptor(here, key);
+			if (typeof key !== "string" || field === void 0 || !("value" in field) || !walk(field.value)) return false;
+		}
+		return true;
+	};
+	try {
+		return walk(value);
+	} catch {
+		return false;
+	}
+}
 /** The objects that a fold made. Each one is deeply frozen, thus a later fold uses it again and does not copy it. */
 const SHARED = /* @__PURE__ */ new WeakSet();
 /** The mark of a value that is not plain data. */
@@ -3907,7 +4520,11 @@ const NOT_PLAIN = /* @__PURE__ */ Symbol("not plain");
 /**
 * This function gives a deeply frozen copy of plain data, or `undefined` for other values. Plain data is a primitive or
 * an array without holes and extra keys. It is also a record of enumerable data fields with the prototype of an object
-* or no prototype. The copy keeps cycles and shared objects. The objects of the host do not change.
+* or no prototype. The copy keeps cycles and shared objects. The objects of the host do not change. The tier `fixed`
+* of `agree` uses it. The package does not export it.
+*
+* @param value - The value.
+* @returns The frozen copy, or `undefined`.
 */
 function sharedCopy(value) {
 	try {
@@ -4007,7 +4624,8 @@ function gated(rules, part) {
 		return {
 			...ctx,
 			caps,
-			[GRANT]: caps
+			[GRANT]: caps,
+			[EPOCH]: epochOf(ctx)
 		};
 	};
 	return {
@@ -4046,6 +4664,30 @@ function runOf(code) {
 function fillOf(split, doc) {
 	return (items) => split.parts.length === 0 ? doc.value : split.fill(items);
 }
+/**
+* The key of the runtime on the input of an evaluator. Only the kernel reads it. The node of a tree evaluates its
+* equations in the evaluation of this runtime, thus their reads go in its list (READS.EQUATION). A copy of the input
+* with a spread keeps the key.
+*/
+const RUNTIME = /* @__PURE__ */ Symbol("coeval.runtime");
+/**
+* This function evaluates a plan inside the evaluation of another runtime, for example an equation of a tree inside
+* the evaluation of its tree (READS.EQUATION). The plan gets its own runtime, as in `plan.evaluate`. The reads of the
+* plan go in the record of the reads of `outer`. The context at the root of `outer` tells which reads are free
+* (READS.FREE). Without such a record, the function gives `plan.evaluate(context)`.
+*
+* @param plan - The plan.
+* @param context - The context of the plan.
+* @param outer - The runtime of the evaluation around the plan, or `undefined`.
+* @returns The result.
+*/
+function evaluateWithin(plan, context, outer) {
+	const reading = outer instanceof Session ? outer.reading : void 0;
+	if (reading === void 0 || !(plan instanceof CompiledPlan)) return plan.evaluate(context);
+	const machine = plan.machine;
+	const ctx = rootContext(machine, context);
+	return plan.code(ctx, new Session(machine, ctx.caps, false, plan.traced, void 0, void 0, void 0, reading));
+}
 function interpret(fn, input, fill) {
 	const { kind, typePath, doc, data, place, machine } = input;
 	const address = input.address === true ? { address: true } : {};
@@ -4072,7 +4714,8 @@ function interpret(fn, input, fill) {
 			...address,
 			resolve: (path, options) => rt.resolve(ctx, path, options),
 			effect: (effectKind, payload) => rt.effect(ctx, effectKind, payload, place),
-			fill: refill
+			fill: refill,
+			[RUNTIME]: rt
 		});
 	};
 }
@@ -4108,18 +4751,27 @@ function interpretRun(fn, input, fill) {
 /**
 * This function gives the context at the root of an evaluation. It is the context of the host, with the world of
 * the machine when the context has none. The host gives the capabilities, thus the root has the grant of each one
-* (CAP.NARROW-CODE). The list of the host is also the epoch of the grant (CAP.NARROW-KEPT). An evaluation and
-* `verifyReads` share it.
+* (CAP.NARROW-CODE). The list of the host is also the epoch of the grant (CAP.NARROW-KEPT). The root has no field of
+* the epoch, thus it has the shape of a context before K120 (K154). An evaluation and `verifyReads` share it.
+*
+* The function reads the epoch of the context one time, and one test keeps a context that is already a root (K169).
 *
 * @param machine - The machine.
 * @param ctx - The context of the host.
 * @returns The context at the root.
 */
 function rootContext(machine, ctx) {
-	if (ctx.world !== null && ctx[GRANT] === ctx.caps && ctx[EPOCH] === ctx.caps) return ctx;
+	const epoch = ctx[EPOCH];
+	if (ctx.world !== null && ctx[GRANT] === ctx.caps && (epoch === void 0 || epoch === ctx.caps)) return ctx;
+	const world = ctx.world === null ? worldThing(machine.world) : ctx.world;
+	if (epoch === void 0) return {
+		...ctx,
+		world,
+		[GRANT]: ctx.caps
+	};
 	return {
 		...ctx,
-		world: ctx.world === null ? worldThing(machine.world) : ctx.world,
+		world,
 		[GRANT]: ctx.caps,
 		[EPOCH]: ctx.caps
 	};
@@ -4145,13 +4797,16 @@ function prepare(machine, doc, options = {}) {
 		steps: []
 	};
 	const traced = options.trace === true;
+	const fold = !traced && options.fold !== false;
+	const fixed = fold ? fixedNamesOf(options.fixed?.names) : void 0;
 	const c = {
 		machine,
 		traced,
 		maxDepth: machine.maxDepth ?? 1e3,
 		verb,
 		noAnswer,
-		fold: !traced && options.fold !== false
+		fold,
+		fixed
 	};
 	let root;
 	try {
@@ -4556,48 +5211,200 @@ const STD_WORLD = {
 	},
 	defaults: { view: "view.card" }
 };
-function isNumber(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-/** This function evaluates each part, collects the errors, and gives the values when no part failed. */
-function allValues(results) {
-	const errors = results.filter((result) => !result.ok);
-	const first = errors[0];
-	if (first !== void 0 && errors.length === 1) return { error: first };
-	if (errors.length > 1) return { error: fail("#ARGS", `${errors.length} parts failed.`) };
-	return { values: results.map((result) => result.ok ? result.value : null) };
-}
-function numbers(values, kind) {
-	const bad = values.findIndex((value) => !isNumber(value));
-	if (bad !== -1) return fail("#VALUE!", `Part ${bad} of ${kind} is not a number.`);
-	return values.filter(isNumber);
-}
-function dataOf(type) {
-	return ({ data }) => typeof data === type && (type !== "number" || isNumber(data)) ? ok(data) : fail("#VALUE!", `The value must be a ${type === "string" ? "text" : type}.`);
-}
-/** The code of the evaluators of the standard world, by name. */
-const STD_EVALUATORS = {
-	"data.number": /* @__PURE__ */ dataOf("number"),
-	"data.text": /* @__PURE__ */ dataOf("string"),
-	"data.bool": /* @__PURE__ */ dataOf("boolean"),
-	"math.add": ({ parts }) => {
-		const all = allValues(parts.map((part) => part.evaluate()));
-		if ("error" in all) return all.error;
-		const values = numbers(all.values, "add");
-		return Array.isArray(values) ? ok(values.reduce((sum, value) => sum + value, 0)) : values;
-	},
-	"math.multiply": ({ parts }) => {
-		const all = allValues(parts.map((part) => part.evaluate()));
-		if ("error" in all) return all.error;
-		const values = numbers(all.values, "multiply");
-		return Array.isArray(values) ? ok(values.reduce((product, value) => product * value, 1)) : values;
-	},
-	"math.greater": ({ parts }) => {
-		if (parts.length !== 2) return fail("#VALUE!", "greater needs exactly two parts.");
-		const all = allValues(parts.map((part) => part.evaluate()));
-		if ("error" in all) return all.error;
-		const values = numbers(all.values, "greater");
-		if (!Array.isArray(values)) return values;
+/**
+* The text syntax of the standard world (K162, D64). The syntax kit (D41) reads it, thus a host of `STD_WORLD` does
+* not write its own profile. The operators `>`, `+` and `*` make `greater`, `add` and `multiply`. A call form makes
+* each other kind, and `ref` uses the reference syntax of the kit.
+*
+* 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).
+*
+* A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
+* the formula kit.
+*/
+const WORLD_SYNTAX = /* @__PURE__ */ Object.freeze({
+	operators: [
+		{
+			symbol: ">",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "greater"
+		},
+		{
+			symbol: "+",
+			fixity: "infix",
+			prec: 5,
+			assoc: "flat",
+			kind: "add"
+		},
+		{
+			symbol: "*",
+			fixity: "infix",
+			prec: 6,
+			assoc: "flat",
+			kind: "multiply"
+		}
+	],
+	calls: {
+		ops: [],
+		forms: [
+			{
+				name: "if",
+				kind: "if",
+				fields: [
+					"test",
+					"then",
+					"else"
+				],
+				min: 2,
+				wrap: true
+			},
+			{
+				name: "list",
+				kind: "list",
+				wrap: true
+			},
+			{
+				name: "seq",
+				kind: "seq",
+				wrap: true
+			},
+			{
+				name: "pure",
+				kind: "pure",
+				min: 1,
+				wrap: true
+			},
+			{
+				name: "log",
+				kind: "log",
+				min: 1
+			},
+			{
+				name: "write",
+				kind: "write",
+				fields: ["key", "value"],
+				wrap: ["value"]
+			},
+			{
+				name: "math.sum",
+				kind: "math.sum"
+			},
+			{
+				name: "math.product",
+				kind: "math.product"
+			},
+			{
+				name: "number",
+				kind: "number",
+				args: "literal"
+			},
+			{
+				name: "text",
+				kind: "text",
+				args: "literal"
+			},
+			{
+				name: "bool",
+				kind: "bool",
+				args: "literal"
+			},
+			{
+				name: "panel",
+				kind: "panel",
+				args: "named",
+				fields: [
+					"width",
+					"height",
+					"children"
+				]
+			},
+			{
+				name: "box",
+				kind: "box",
+				args: "named",
+				fields: [
+					"width",
+					"height",
+					"children"
+				]
+			},
+			{
+				name: "nearest",
+				kind: "nearest",
+				args: "named",
+				fields: [
+					"type",
+					"follow",
+					"self"
+				]
+			},
+			{
+				name: "add",
+				kind: "add"
+			},
+			{
+				name: "multiply",
+				kind: "multiply"
+			},
+			{
+				name: "greater",
+				kind: "greater"
+			}
+		]
+	},
+	literals: { envelopes: {
+		number: "number",
+		text: "text",
+		bool: "bool"
+	} },
+	header: { bind: "=" }
+});
+function isNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/** This function evaluates each part, collects the errors, and gives the values when no part failed. */
+function allValues(results) {
+	const errors = results.filter((result) => !result.ok);
+	const first = errors[0];
+	if (first !== void 0 && errors.length === 1) return { error: first };
+	if (errors.length > 1) return { error: fail("#ARGS", `${errors.length} parts failed.`) };
+	return { values: results.map((result) => result.ok ? result.value : null) };
+}
+function numbers(values, kind) {
+	const bad = values.findIndex((value) => !isNumber(value));
+	if (bad !== -1) return fail("#VALUE!", `Part ${bad} of ${kind} is not a number.`);
+	return values.filter(isNumber);
+}
+function dataOf(type) {
+	return ({ data }) => typeof data === type && (type !== "number" || isNumber(data)) ? ok(data) : fail("#VALUE!", `The value must be a ${type === "string" ? "text" : type}.`);
+}
+/** The code of the evaluators of the standard world, by name. */
+const STD_EVALUATORS = {
+	"data.number": /* @__PURE__ */ dataOf("number"),
+	"data.text": /* @__PURE__ */ dataOf("string"),
+	"data.bool": /* @__PURE__ */ dataOf("boolean"),
+	"math.add": ({ parts }) => {
+		const all = allValues(parts.map((part) => part.evaluate()));
+		if ("error" in all) return all.error;
+		const values = numbers(all.values, "add");
+		return Array.isArray(values) ? ok(values.reduce((sum, value) => sum + value, 0)) : values;
+	},
+	"math.multiply": ({ parts }) => {
+		const all = allValues(parts.map((part) => part.evaluate()));
+		if ("error" in all) return all.error;
+		const values = numbers(all.values, "multiply");
+		return Array.isArray(values) ? ok(values.reduce((product, value) => product * value, 1)) : values;
+	},
+	"math.greater": ({ parts }) => {
+		if (parts.length !== 2) return fail("#VALUE!", "greater needs exactly two parts.");
+		const all = allValues(parts.map((part) => part.evaluate()));
+		if ("error" in all) return all.error;
+		const values = numbers(all.values, "greater");
+		if (!Array.isArray(values)) return values;
 		const [a, b] = values;
 		return ok((a ?? 0) > (b ?? 0));
 	},
@@ -4734,6 +5541,7 @@ function plainOf(value, path) {
 */
 function treeThing(input, build, outer) {
 	const { parts, context, kind: type, place, machine } = input;
+	const runtime = input[RUNTIME];
 	const { tree, of } = contractOf$1(machine, input.typePath);
 	const above = stateOf(outer);
 	const up = above !== void 0 && above.build === build ? above : void 0;
@@ -4835,12 +5643,12 @@ function treeThing(input, build, outer) {
 		read,
 		equation(term, names) {
 			if (machine === void 0) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
-			return equationPlan(machine, of, term).evaluate({
+			return evaluateWithin(equationPlan(machine, of, term), {
 				...context,
 				names,
 				caps: NO_CAPS$1,
 				self: node
-			});
+			}, runtime);
 		},
 		childNames(child) {
 			const children = read("children");
@@ -4930,6 +5738,17 @@ function treeThing(input, build, outer) {
 function attributeTrace(node, attribute) {
 	return stateOf(node)?.trace(attribute);
 }
+/**
+* This function gives the place of a node of the decorated tree: the keys from the root document to the document of
+* the node (HOP.PLACE). A view puts each hop of a resolution on its node with it. The node keeps its place already,
+* thus the function adds no record.
+*
+* @param thing - A thing, for example the thing of a hop.
+* @returns The keys of the place, or `undefined` for a thing that is not a node of the decorated tree.
+*/
+function placeOf(thing) {
+	return stateOf(thing)?.place;
+}
 /** The path of the root `self`. A node of the tree resolves it, thus the list of reads holds the read (C4). */
 const SELF_PATH = /* @__PURE__ */ Object.freeze(["self"]);
 /** The options of the resolution of `self`: the node needs no hops. */
@@ -4958,21 +5777,24 @@ function hostType(node, wanted) {
 /**
 * This function makes a walker `nearest`. The walker follows a key (the default is `parent`) until the node that it
 * reaches has the wanted type. With `self: true`, the node where the walk starts is the first candidate. A node
-* without that key ends the walk with an error.
+* without that key ends the walk with an error. With `eachStep`, a resolution with hops gets a hop for each node on the way.
 *
-* @param options - The test of a type and the most hops.
+* @param options - The test of a type, the most hops and the record of each step.
 * @returns The walker.
 */
 function nearestWalker(options = {}) {
 	const matches = options.matches ?? hostType;
 	const maxHops = options.maxHops ?? 256;
-	return ({ data, here, deref }) => {
+	const eachStep = options.eachStep === true;
+	return ({ data, here, deref, visit }) => {
 		const follow = isRecord(data) && typeof field(data, "follow") === "string" ? String(field(data, "follow")) : "parent";
 		const wanted = isRecord(data) ? field(data, "type") : void 0;
 		const fromSelf = isRecord(data) && field(data, "self") === true;
+		const record = eachStep ? visit : void 0;
 		let at = here;
 		for (let hops = 0; hops < maxHops; hops += 1) {
-			if (hops > 0 || !fromSelf) at = at === void 0 || at === null ? void 0 : deref(at, follow);
+			const stepped = hops > 0 || !fromSelf;
+			if (stepped) at = at === void 0 || at === null ? void 0 : deref(at, follow);
 			if (at === void 0 || at === null) return {
 				ok: false,
 				reason: `No node of the type ${String(wanted)} is on the way.`
@@ -4981,6 +5803,7 @@ function nearestWalker(options = {}) {
 				ok: true,
 				thing: at
 			};
+			if (stepped) record?.(follow, at);
 		}
 		return {
 			ok: false,
@@ -6115,7 +6938,7 @@ const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
 const FOLD_NAMES = /* @__PURE__ */ Object.freeze(["acc", "item"]);
 /**
 * This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
-* `equations`, a `unit` and a `default` see no names.
+* `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
 */
 function equationsOf(kind) {
 	const tree = kind.tree;
@@ -6437,9 +7260,11 @@ function partLazy(above, parent, slot) {
 *
 * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
 *   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
-*   declares `reads` adds a read of each of its roots at each document of the kind.
+*   declares `reads` adds a read of each of its roots at each document of the kind. The first document of a tree
+*   kind also gets the lazy reads of the equations of its kind (FACTS.EQUATIONS). A read from `self` or from a name
+*   of a rung is not one of them, because it is not free (READS.EQUATION).
 * - `side` and `effects`: from the contract of each kind.
-* - `pure`: each kind declares `pure`, and the document has no effect and is not volatile.
+* - `pure`: each kind declares `pure`, also in an equation, and the document has no effect and is not volatile.
 * - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
 *
 * The hook `facts` of the machine answers for a name that a fallback kind covers, for example an operation. Its
@@ -6463,7 +7288,6 @@ function partLazy(above, parent, slot) {
 function factsOf(machine, doc, options = {}) {
 	const world = machine.world;
 	const hook = machine.facts;
-	const verb = options.verb ?? "eval";
 	const reads = [];
 	const effects = [];
 	const above = /* @__PURE__ */ new Map();
@@ -6471,98 +7295,124 @@ function factsOf(machine, doc, options = {}) {
 	let pure = true;
 	let volatile = false;
 	let size = 0;
+	let seen;
 	const note = (isPure, isVolatile) => {
 		if (isPure !== true) pure = false;
 		if (isVolatile === true) volatile = true;
 	};
-	walk(world, doc, (v) => {
-		size += 1;
-		const up = v.parent === void 0 ? void 0 : above.get(v.parent);
-		const lazy = up !== void 0 && v.parent !== void 0 && (up.lazy || partLazy(up, v.parent, v.slot));
-		const kind = v.kind;
-		if (kind === void 0) {
-			pure = false;
-			above.set(v, {
-				lazy,
-				rules: void 0
-			});
-			return;
-		}
-		const code = codeOf(world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
-		const answer = code.name === void 0 ? void 0 : hook?.(v.typePath ?? [], code.name);
-		let roots;
-		if (code.described) {
-			note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
-			above.set(v, {
-				lazy,
-				rules: answer?.lazy ?? kind.lazy
-			});
-			roots = answer?.reads ?? kind.reads;
-		} else {
-			note(answer?.pure, answer?.volatile);
-			above.set(v, {
-				lazy,
-				rules: answer?.lazy ?? EACH$1
-			});
-			roots = answer?.reads;
-		}
-		for (const root of roots ?? NONE) {
-			const read = {
-				root,
-				keys: NONE,
-				exact: true,
-				lazy,
-				address: false,
-				path: [root],
-				place: tight(v.place),
-				at: tight(v.at)
-			};
-			reads.push(read);
-			if (options.volatile?.(read) === true) volatile = true;
-		}
-		if (kind.side === "run") side = "run";
-		for (const keys of declaredEffects(v)) {
-			const text = keys.join(".");
-			if (!effects.includes(text)) effects.push(text);
-		}
-		if (!isRef(v.doc)) return void 0;
-		const path = v.doc.value;
-		const root = path[0];
-		if (typeof root !== "string" || !ROOTS.includes(root)) return void 0;
-		let exact = true;
-		const keys = [];
-		for (let index = 1; index < path.length; index += 1) {
-			const step = path[index];
-			if (exact && isKey(step)) {
-				keys.push(step);
-				continue;
-			}
-			exact = false;
-			const found = isEnvelope(step) ? lookupKind(world, step.type) : void 0;
-			if (found?.ok !== true) {
-				pure = false;
-				continue;
-			}
-			const walker = codeOf(world, step.own, found.kind, "step", "step");
-			const stepAnswer = walker.name === void 0 ? void 0 : hook?.(found.path, walker.name);
-			if (walker.described) note(stepAnswer?.pure ?? found.kind.pure, stepAnswer?.volatile ?? found.kind.volatile);
-			else note(stepAnswer?.pure, stepAnswer?.volatile);
-		}
-		const first = path[1];
-		if (root === "names" && isKey(first) && v.names.has(String(first))) return void 0;
-		const read = {
-			root,
-			keys: tight(keys),
-			exact,
-			lazy,
-			address: v.address === true,
-			path,
-			place: tight(v.place),
-			at: tight(v.at)
-		};
+	const add = (read) => {
 		reads.push(read);
 		if (options.volatile?.(read) === true) volatile = true;
-	}, options.declaredType === void 0 ? {} : { declaredType: options.declaredType });
+	};
+	/**
+	* This function walks a document. Without `node`, it walks the document of the facts. With `node`, it walks an
+	* equation of a tree kind, and each read gets the place of that node: the first document of the kind.
+	*/
+	const scan = (term, walkOptions, verb, node) => {
+		walk(world, term, (v) => {
+			if (node === void 0) size += 1;
+			const up = v.parent === void 0 ? void 0 : above.get(v.parent);
+			const lazy = node !== void 0 || up !== void 0 && v.parent !== void 0 && (up.lazy || partLazy(up, v.parent, v.slot));
+			const place = node ?? v;
+			const kind = v.kind;
+			if (kind === void 0) {
+				pure = false;
+				above.set(v, {
+					lazy,
+					rules: void 0
+				});
+				return;
+			}
+			const code = codeOf(world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
+			const answer = code.name === void 0 ? void 0 : hook?.(v.typePath ?? [], code.name);
+			let roots;
+			if (code.described) {
+				note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
+				above.set(v, {
+					lazy,
+					rules: answer?.lazy ?? kind.lazy
+				});
+				roots = answer?.reads ?? kind.reads;
+			} else {
+				note(answer?.pure, answer?.volatile);
+				above.set(v, {
+					lazy,
+					rules: answer?.lazy ?? EACH$1
+				});
+				roots = answer?.reads;
+			}
+			for (const root of roots ?? NONE) {
+				if (node !== void 0 && root === "self") continue;
+				add({
+					root,
+					keys: NONE,
+					exact: true,
+					lazy,
+					address: false,
+					path: [root],
+					place: tight(place.place),
+					at: tight(place.at)
+				});
+			}
+			if (kind.side === "run") {
+				if (node === void 0) side = "run";
+				else pure = false;
+			}
+			for (const keys of declaredEffects(v)) {
+				if (node !== void 0) {
+					pure = false;
+					continue;
+				}
+				const text = keys.join(".");
+				if (!effects.includes(text)) effects.push(text);
+			}
+			if (kind.tree !== void 0 && !(seen ??= /* @__PURE__ */ new Set()).has(kind)) {
+				seen.add(kind);
+				const of = equationType(kind);
+				for (const { term: equation, names } of equationsOf(kind)) scan(equation, of === void 0 ? { names } : {
+					names,
+					declaredType: of
+				}, "eval", place);
+			}
+			if (!isRef(v.doc)) return void 0;
+			const path = v.doc.value;
+			const root = path[0];
+			if (typeof root !== "string" || !ROOTS.includes(root)) return void 0;
+			if (node !== void 0 && root === "self") return void 0;
+			let exact = true;
+			const keys = [];
+			for (let index = 1; index < path.length; index += 1) {
+				const step = path[index];
+				if (exact && isKey(step)) {
+					keys.push(step);
+					continue;
+				}
+				exact = false;
+				const found = isEnvelope(step) ? lookupKind(world, step.type) : void 0;
+				if (found?.ok !== true) {
+					pure = false;
+					continue;
+				}
+				const walker = codeOf(world, step.own, found.kind, "step", "step");
+				const stepAnswer = walker.name === void 0 ? void 0 : hook?.(found.path, walker.name);
+				if (walker.described) note(stepAnswer?.pure ?? found.kind.pure, stepAnswer?.volatile ?? found.kind.volatile);
+				else note(stepAnswer?.pure, stepAnswer?.volatile);
+			}
+			const first = path[1];
+			if (root === "names" && isKey(first) && v.names.has(String(first))) return void 0;
+			add({
+				root,
+				keys: tight(keys),
+				exact,
+				lazy,
+				address: v.address === true,
+				path,
+				place: tight(place.place),
+				at: tight(place.at)
+			});
+		}, walkOptions);
+	};
+	scan(doc, options.declaredType === void 0 ? {} : { declaredType: options.declaredType }, options.verb ?? "eval", void 0);
 	return {
 		reads: tight(reads),
 		side,
@@ -6701,7 +7551,7 @@ function domainTypeOf(data, domains) {
 	return domain !== void 0 && codecOf(domain) !== void 0 ? data["domain"] : "unknown";
 }
 /** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
-function setOwn$2(target, key, value) {
+function setOwn$3(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -6776,7 +7626,7 @@ function encodeTerm(value, encoder) {
 	else {
 		const fields = {};
 		const record = value;
-		for (const key of Object.keys(record)) setOwn$2(fields, key, encodeTerm(record[key], encoder));
+		for (const key of Object.keys(record)) setOwn$3(fields, key, encodeTerm(record[key], encoder));
 		out = {
 			type: "record",
 			value: fields
@@ -6872,7 +7722,7 @@ function strictTruthy(value) {
 * This function sets an own data property. Only the key `__proto__` needs `defineProperty`: an assignment to it
 * changes the prototype. An assignment is faster for each other key of a new plain object.
 */
-function setOwn$1(target, key, value) {
+function setOwn$2(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -7086,11 +7936,28 @@ function paramsOf(value) {
 }
 /**
 * This function makes the type rules of the formula kit for one profile (TYPE.SYNTH, D25). Each evaluator of the kit
-* holds its rule. The rules read the rules of the profile that change a type: `truthy`, `logic`, `otherwise`, `omit`
-* and `sigs`.
+* holds its rule. The rules read the rules of the profile that change a type: `truthy`, `truthType`, `logic`,
+* `otherwise`, `omit` and `sigs`.
 */
 function formulaTypes(profile) {
-	const truth = profile.truthy === void 0 ? "bool" : void 0;
+	const declared = profile.truthy !== void 0 && profile.truthType !== void 0;
+	const truth = profile.truthy === void 0 ? "bool" : profile.truthType;
+	/**
+	* The need of a test or a term. The check examines a declared type of a truth as a contract, one time. A declared
+	* type with a problem needs nothing, thus one problem gives one issue.
+	*/
+	const truthPart = (input, what) => {
+		if (truth === void 0) return {};
+		if (!declared) return {
+			expect: truth,
+			what
+		};
+		const type = input.contract(truth, "truth type of the profile");
+		return typeIssues(type, input.machine.domains).length > 0 ? {} : {
+			expect: type,
+			what
+		};
+	};
 	const logicValue = profile.logic === "value";
 	const otherwise = Object.hasOwn(profile, "otherwise") ? valueType(profile.otherwise) : "null";
 	const lookup = (name) => {
@@ -7126,10 +7993,7 @@ function formulaTypes(profile) {
 		};
 	};
 	const logic = (word) => ({
-		part: (_input, path) => truth === void 0 ? {} : {
-			expect: truth,
-			what: `term ${Number(path[0]) + 1} of ${word}`
-		},
+		part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
 		synth: (input) => {
 			if (!logicValue) return "bool";
 			if (input.paths.length === 0) return { one: [word === "and"] };
@@ -7178,7 +8042,7 @@ function formulaTypes(profile) {
 			},
 			synth: (input) => {
 				const fields = {};
-				for (const path of input.paths) setOwn$1(fields, String(path[0]), input.typeOf(path));
+				for (const path of input.paths) setOwn$2(fields, String(path[0]), input.typeOf(path));
 				const keys = Object.keys(fields);
 				return {
 					record: fields,
@@ -7201,7 +8065,7 @@ function formulaTypes(profile) {
 			part: (input, path) => {
 				if (path[0] !== "body") return {};
 				const names = {};
-				for (const each of input.paths) if (each[0] === "bind" && each.length === 2) setOwn$1(names, String(each[1]), input.typeOf(each));
+				for (const each of input.paths) if (each[0] === "bind" && each.length === 2) setOwn$2(names, String(each[1]), input.typeOf(each));
 				return {
 					names,
 					...isUnknown(input.expected, input.machine.domains) ? {} : {
@@ -7217,7 +8081,7 @@ function formulaTypes(profile) {
 				if (path[0] !== "body") return {};
 				const want = fnOf(input.expected, input.machine.domains);
 				const names = {};
-				paramsOf(input.doc.value).forEach((name, index) => setOwn$1(names, name, want?.params[index] ?? "unknown"));
+				paramsOf(input.doc.value).forEach((name, index) => setOwn$2(names, name, want?.params[index] ?? "unknown"));
 				return {
 					names,
 					...want === void 0 || isUnknown(want.to, input.machine.domains) ? {} : {
@@ -7273,10 +8137,7 @@ function formulaTypes(profile) {
 		} },
 		"formula.if": {
 			part: (input, path) => {
-				if (path[0] === "test") return truth === void 0 ? {} : {
-					expect: truth,
-					what: "test of if"
-				};
+				if (path[0] === "test") return truthPart(input, "test of if");
 				return isUnknown(input.expected, input.machine.domains) ? {} : {
 					expect: input.expected,
 					what: `${String(path[0])} branch of if`
@@ -7350,18 +8211,44 @@ function formulaTypes(profile) {
 function formulaEvaluators(profile = {}) {
 	return { ...kitOf(profile).evaluators };
 }
+/** The evaluators of the kit that read the truth of a value. */
+const TRUTH_READERS = [
+	"formula.if",
+	"formula.and",
+	"formula.or"
+];
+/** The declared truth of each evaluator of the kit that reads a truth, for `conforms` (D86). */
+const truthByCode = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives the declared truth of the profile of an evaluator of the kit (D86). Only `formula.if`,
+* `formula.and` and `formula.or` of a profile with an own `truthy` and a `truthType` have one. The kernel does not
+* export the function.
+*
+* @param code - The evaluator or the runner.
+* @returns The declared truth, or `undefined`.
+*/
+function declaredTruthOf(code) {
+	return (typeof code === "object" || typeof code === "function") && code !== null ? truthByCode.get(code) : void 0;
+}
 /** This function makes new evaluators of the formula kit for the fields of one profile. */
 function makeEvaluators(profile) {
 	const evaluators = formulaCode(profile);
 	const types = formulaTypes(profile);
+	const { truthy, truthType } = profile;
+	const truth = truthy === void 0 || truthType === void 0 ? void 0 : {
+		truthy,
+		truthType
+	};
 	const out = {};
 	for (const name of Object.keys(evaluators)) {
 		const evaluator = evaluators[name];
 		const type = Object.hasOwn(types, name) ? types[name] : void 0;
-		out[name] = Object.freeze(type === void 0 ? evaluator : {
+		const made = Object.freeze(type === void 0 ? evaluator : {
 			compile: evaluator.compile,
 			type
 		});
+		if (truth !== void 0 && TRUTH_READERS.includes(name)) truthByCode.set(made, truth);
+		out[name] = made;
 	}
 	return Object.freeze(out);
 }
@@ -7371,6 +8258,7 @@ const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
 	"lazy",
 	"ext",
 	"truthy",
+	"truthType",
 	"otherwise",
 	"logic",
 	"omit",
@@ -7555,7 +8443,7 @@ function formulaCode(profile) {
 					if (!Array.isArray(values)) return values;
 					const out = {};
 					keys.forEach((key, index) => {
-						if (values[index] !== SKIPPED) setOwn$1(out, key, values[index]);
+						if (values[index] !== SKIPPED) setOwn$2(out, key, values[index]);
 					});
 					return ok(out);
 				};
@@ -7568,7 +8456,7 @@ function formulaCode(profile) {
 						if (omit !== void 0 && omit(result.error)) continue;
 						return result;
 					}
-					setOwn$1(out, keys[index], result.value);
+					setOwn$2(out, keys[index], result.value);
 				}
 				return ok(out);
 			};
@@ -7585,7 +8473,7 @@ function formulaCode(profile) {
 				const names = { ...ctx.names };
 				for (const [name, part] of bindings) {
 					const result = part.code(ctx, rt);
-					setOwn$1(names, name, result.ok ? result.value : new Held(result.error));
+					setOwn$2(names, name, result.ok ? result.value : new Held(result.error));
 				}
 				return body.code({
 					...ctx,
@@ -7616,7 +8504,7 @@ function formulaCode(profile) {
 				rt.keepsContext?.(ctx, reads);
 				const closure = (...args) => {
 					const scope = { ...ctx.names };
-					names.forEach((name, index) => setOwn$1(scope, name, args[index]));
+					names.forEach((name, index) => setOwn$2(scope, name, args[index]));
 					const result = body.code({
 						...ctx,
 						names: scope
@@ -7889,7 +8777,8 @@ function formulaMachine(profile = {}, more = {}) {
 /**
 * The standard syntax of the formula kit. It gives the site and the playground a text form. The operators are
 * `or`, `and`, `not`, the comparisons, `+ - * / %`, a minus sign and `^`, from the loosest to the tightest. A call
-* `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs.
+* `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs. The
+* text `total = 2 + 3` gives the document the header name `total` (D62).
 */
 const STD_SYNTAX = /* @__PURE__ */ Object.freeze({
 	operators: [
@@ -8019,7 +8908,8 @@ const STD_SYNTAX = /* @__PURE__ */ Object.freeze({
 	}, {
 		name: "list",
 		kind: "list"
-	}] }
+	}] },
+	header: { bind: "=" }
 });
 const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const NAME_AT = /[A-Za-z_][A-Za-z0-9_]*/y;
@@ -8037,6 +8927,12 @@ const DEFAULT_ROOTS = [
 	"event",
 	"caps"
 ];
+const FORM_ARGS = [
+	"list",
+	"fields",
+	"named",
+	"literal"
+];
 const compiledProfiles = /* @__PURE__ */ new WeakMap();
 function typeOfKind(kind) {
 	const keys = kind.split(".");
@@ -8092,6 +8988,37 @@ function compileOps(profile, separator) {
 		opWords
 	};
 }
+/** This function examines the bind symbol of a header. A text with the symbol after a name was not valid before. */
+function compileBind(bind, separator, binary) {
+	if (bind === void 0) return void 0;
+	if (!SYMBOL.test(bind) || bind.includes(separator)) throw new TypeError(`The bind symbol "${bind}" is not a group of symbols.`);
+	for (const symbol of binary.keys()) if (bind.startsWith(symbol)) throw new TypeError(`The bind symbol "${bind}" starts with the operator "${symbol}".`);
+	return bind;
+}
+/** 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;
+	if (wrap === void 0 || wrap === false) return false;
+	if (args === "literal") throw new TypeError(`The call form "${given.name}" with the arguments literal takes no wrap.`);
+	if (wrap === true) return true;
+	if (args === "list") throw new TypeError(`The call form "${given.name}" with the arguments list takes only the wrap true.`);
+	for (const name of wrap) if (given.fields !== void 0 && !given.fields.includes(name)) throw new TypeError(`The call form "${given.name}" has no field ${name} for its wrap.`);
+	return new Set(wrap);
+}
+/** This function gives the types of the data envelopes of a profile (K159), or `undefined` without them. */
+function compileEnvelopes(given) {
+	if (given === void 0) return void 0;
+	const out = {};
+	for (const key of [
+		"number",
+		"text",
+		"bool"
+	]) {
+		const kind = given[key];
+		if (kind !== void 0) out[key] = typeOfKind(kind);
+	}
+	return out;
+}
 function compileProfile(profile) {
 	const cached = compiledProfiles.get(profile);
 	if (cached !== void 0) return cached;
@@ -8106,13 +9033,22 @@ function compileProfile(profile) {
 	const forms = /* @__PURE__ */ new Map();
 	const formsByKind = /* @__PURE__ */ new Map();
 	for (const given of calls.forms ?? []) {
-		if (!NAME.test(given.name)) throw new TypeError(`The call form "${given.name}" is not a plain name.`);
+		const keys = given.name.split(".");
+		if (!keys.every((key) => NAME.test(key))) throw new TypeError(`The call form "${given.name}" is not a plain name or a path of plain names.`);
+		if (keys.length > 1 && refs.fields === false) throw new TypeError(`The call form "${given.name}" has dots, but the syntax has no field steps.`);
+		if (keys.length > 1 && ops.opWords.has(keys[0])) throw new TypeError(`The call form "${given.name}" starts with the word operator "${keys[0]}".`);
 		const { type, key } = typeOfKind(given.kind);
+		const args = given.args ?? (given.fields === void 0 ? "list" : "fields");
+		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 form = {
 			name: given.name,
 			type,
+			args,
 			fields: given.fields,
-			min: given.min ?? given.fields?.length ?? 0
+			min: given.min ?? given.fields?.length ?? 0,
+			wrap: compileWrap(given, args)
 		};
 		forms.set(form.name, form);
 		addTo(formsByKind, key, form);
@@ -8124,6 +9060,7 @@ function compileProfile(profile) {
 		quote: strings === void 0 ? void 0 : strings.quote ?? "\"",
 		doubled: strings !== void 0 && strings.escape === "double",
 		words,
+		envelopes: compileEnvelopes(literals.envelopes),
 		bare: refs.bare ?? "names",
 		roots,
 		fields: refs.fields ?? true,
@@ -8140,6 +9077,7 @@ function compileProfile(profile) {
 		forms,
 		formsByKind,
 		separator,
+		bind: compileBind(profile.header?.bind, separator, ops.binary),
 		reserved: /* @__PURE__ */ new Set([
 			...words.keys(),
 			...ops.opWords,
@@ -8166,6 +9104,37 @@ function opDoc(op, value) {
 		value
 	};
 }
+/** This function gives the kind of the data envelope of a literal (K159), or `undefined` when the literal has none. */
+function envelopeOf(syn, value) {
+	const kinds = syn.envelopes;
+	if (kinds === void 0 || !isScalar(value)) return void 0;
+	return typeof value === "string" ? kinds.text : typeof value === "number" ? kinds.number : typeof value === "boolean" ? kinds.bool : void 0;
+}
+/** This function gives a literal in a place that takes a document its data envelope (K159). Each other document stays. */
+function envelop(syn, doc) {
+	const kind = isEnvelope(doc) ? void 0 : envelopeOf(syn, doc);
+	return kind === void 0 ? doc : {
+		type: kind.type,
+		value: doc
+	};
+}
+/** This function tells if an argument of a form takes a document (K159). */
+function wraps(form, key) {
+	return form.wrap === true || form.wrap !== false && form.wrap.has(String(key));
+}
+/** This function tells if a value is a literal that JSON writes exactly: a text, a finite number, a truth value or `null`. */
+function isScalar(value) {
+	return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0);
+}
+function setOwn$1(target, key, value) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else target[key] = value;
+}
 const ESCAPES = {
 	"\"": "\"",
 	"'": "'",
@@ -8189,10 +9158,10 @@ var Parser = class {
 	parse() {
 		this.skip();
 		if (this.pos >= this.text.length) this.stop("The text is empty.", 0, 0);
-		const doc = this.expr(0);
+		const doc = this.bound();
 		this.skip();
 		if (this.pos < this.text.length) this.stop("The text continues after the expression.", this.pos, this.tokenLength());
-		return doc;
+		return envelop(this.syn, doc);
 	}
 	position() {
 		return this.pos;
@@ -8214,6 +9183,60 @@ var Parser = class {
 	tokenLength() {
 		return (this.at(NAME_AT) ?? this.at(DIGITS_AT) ?? "x").length;
 	}
+	/**
+	* This method reads an expression that can have a header name: `name = expr` (D62). The bind symbol of the profile
+	* follows the name. A longer operator that starts with the symbol wins, for example `==` over `=`.
+	*/
+	bound() {
+		const name = this.bindingName();
+		if (name === void 0) return this.expr(0);
+		this.skip();
+		const start = this.pos;
+		const doc = this.expr(0);
+		if (isEnvelope(doc)) {
+			if (doc.name !== void 0) this.stop(`The document already has the name ${doc.name}.`, start, this.pos - start);
+			return {
+				...doc,
+				name
+			};
+		}
+		const kind = envelopeOf(this.syn, doc);
+		return kind === void 0 ? {
+			type: "lit",
+			value: doc,
+			name
+		} : {
+			type: kind.type,
+			value: doc,
+			name
+		};
+	}
+	/** This method reads a name and the bind symbol after it. Without them, it gives `undefined` and keeps the position. */
+	bindingName() {
+		const bind = this.syn.bind;
+		if (bind === void 0) return void 0;
+		this.skip();
+		const back = this.pos;
+		let name;
+		if (this.text[this.pos] === "`") try {
+			name = this.quoted();
+		} catch (error) {
+			if (!(error instanceof Stop)) throw error;
+		}
+		else {
+			name = this.at(NAME_AT);
+			if (name !== void 0) this.pos += name.length;
+		}
+		if (name !== void 0) {
+			this.skip();
+			const longer = this.syn.binarySymbols.some((symbol) => symbol.length > bind.length && symbol.startsWith(bind) && this.text.startsWith(symbol, this.pos));
+			if (this.text.startsWith(bind, this.pos) && !longer) {
+				this.pos += bind.length;
+				return name;
+			}
+		}
+		this.pos = back;
+	}
 	/** This method reads an expression by precedence climbing. It stops at an operator below `min`. */
 	expr(min) {
 		const start = this.pos;
@@ -8346,7 +9369,7 @@ var Parser = class {
 	group() {
 		const open = this.pos;
 		this.pos += 1;
-		const inner = this.expr(0);
+		const inner = this.bound();
 		this.skip();
 		if (this.text[this.pos] !== ")") {
 			if (this.pos >= this.text.length) this.stop("A closing parenthesis is missing.", open, 1);
@@ -8396,6 +9419,11 @@ var Parser = class {
 			}
 			this.pos += 1;
 			this.skip();
+			if (this.text[this.pos] === "(") {
+				path.push(this.group());
+				allPlain = false;
+				continue;
+			}
 			if (this.text[this.pos] === "`") {
 				path.push(this.quoted());
 				allPlain = false;
@@ -8411,7 +9439,7 @@ var Parser = class {
 		const back = this.pos;
 		this.skip();
 		if (this.text[this.pos] === "(") {
-			if (!allPlain) this.stop("The name of a call is a plain name.", start, back - start);
+			if (!allPlain) this.stop("Each key of the name of a call is a plain name.", start, back - start);
 			return this.call(path.join("."), start, back - start);
 		}
 		this.pos = back;
@@ -8421,14 +9449,18 @@ var Parser = class {
 			value: plain && this.syn.roots.has(first) ? path : [this.syn.bare, ...path]
 		};
 	}
-	call(name, start, nameLength) {
+	/** This method reads the arguments of a call in parentheses. `item` reads one argument. */
+	argumentsOf(item) {
 		const open = this.pos;
 		const args = [];
 		this.pos += 1;
 		this.skip();
-		if (this.text[this.pos] === ")") this.pos += 1;
-		else for (;;) {
-			args.push(this.expr(0));
+		if (this.text[this.pos] === ")") {
+			this.pos += 1;
+			return args;
+		}
+		for (;;) {
+			args.push(item());
 			this.skip();
 			if (this.text.startsWith(this.syn.separator, this.pos)) {
 				this.pos += this.syn.separator.length;
@@ -8436,22 +9468,55 @@ var Parser = class {
 			}
 			if (this.text[this.pos] === ")") {
 				this.pos += 1;
-				break;
+				return args;
 			}
 			if (this.pos >= this.text.length) this.stop("A closing parenthesis is missing.", open, 1);
 			this.stop(`A "${this.syn.separator}" or a closing parenthesis is missing.`, this.pos, this.tokenLength());
 		}
+	}
+	/** This method reads the arguments `key: expr` of a form `named` into a record (SYNTAX.RECORD). */
+	namedArguments(form) {
+		const value = {};
+		this.argumentsOf(() => {
+			this.skip();
+			const at = this.pos;
+			let key;
+			if (this.text[at] === "`") key = this.quoted();
+			else {
+				key = this.at(NAME_AT);
+				if (key !== void 0) this.pos += key.length;
+			}
+			const end = this.pos;
+			this.skip();
+			if (key === void 0 || this.text[this.pos] !== ":") this.stop(`Each argument of the form ${form.name} 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 (Object.hasOwn(value, key)) this.stop(`The form ${form.name} has the field ${key} two times.`, at, end - at);
+			this.pos += 1;
+			const arg = this.bound();
+			setOwn$1(value, key, wraps(form, key) ? envelop(this.syn, arg) : arg);
+		});
+		return opDoc(form, value);
+	}
+	call(name, start, nameLength) {
 		const form = this.syn.forms.get(name);
+		if (form?.args === "named") return this.namedArguments(form);
+		const args = this.argumentsOf(() => 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);
+		}
 		if (form !== void 0) {
 			const most = form.fields?.length ?? Number.POSITIVE_INFINITY;
 			if (args.length < form.min || args.length > most) {
 				const range = most === form.min ? String(most) : most === Number.POSITIVE_INFINITY ? `${String(form.min)} or more` : `${String(form.min)} to ${String(most)}`;
 				this.stop(`The form ${name} takes ${range} arguments.`, start, this.pos - start);
 			}
-			if (form.fields === void 0) return opDoc(form, args);
+			if (form.fields === void 0) return opDoc(form, form.wrap === true ? args.map((arg) => envelop(this.syn, arg)) : args);
 			const value = {};
 			args.forEach((arg, index) => {
-				value[form.fields?.[index]] = arg;
+				const key = form.fields?.[index];
+				value[key] = wraps(form, key) ? envelop(this.syn, arg) : arg;
 			});
 			return opDoc(form, value);
 		}
@@ -8530,8 +9595,10 @@ function literalShape(syn, value) {
 function plainSegment(syn, name) {
 	return NAME.test(name) && !syn.reserved.has(name) && !syn.patterns.some((p) => p.whole.test(name));
 }
-function laterSegment(step) {
+/** This function gives the text of a later step of a path, or the step and its index when the step is a document. */
+function laterSegment(step, index) {
 	if (typeof step === "string") return NAME.test(step) ? step : quoteName(step);
+	if (isEnvelope(step)) return [index, step];
 	return typeof step === "number" && Number.isSafeInteger(step) && step >= 0 ? String(step) : void 0;
 }
 function refShape(syn, value) {
@@ -8545,18 +9612,23 @@ function refShape(syn, value) {
 	}
 	const [root, ...rest] = value;
 	if ((rest.length > 1 || root !== syn.bare && rest.length > 0) && !syn.fields) return none("This syntax has no field steps.");
-	const later = rest.slice(1).map(laterSegment);
 	let first;
-	let tail = later;
-	if (root === syn.bare && typeof rest[0] === "string") first = plainSegment(syn, rest[0]) ? rest[0] : quoteName(rest[0]);
-	else if (typeof root === "string" && syn.roots.has(root) && !syn.patterns.some((p) => p.whole.test(root))) {
+	let tail = [];
+	if (root === syn.bare && typeof rest[0] === "string") {
+		first = plainSegment(syn, rest[0]) ? rest[0] : quoteName(rest[0]);
+		tail = rest.slice(1).map((step, index) => laterSegment(step, index + 2));
+	} else if (typeof root === "string" && syn.roots.has(root) && !syn.patterns.some((p) => p.whole.test(root))) {
 		first = root;
-		tail = rest.map(laterSegment);
+		tail = rest.map((step, index) => laterSegment(step, index + 1));
 	}
 	if (first === void 0 || tail.includes(void 0)) return none("This syntax has no text for the path of the reference.");
-	return {
+	const segments = [first, ...tail];
+	return segments.every((segment) => typeof segment === "string") ? {
 		tag: "text",
-		text: [first, ...tail].join(".")
+		text: segments.join(".")
+	} : {
+		tag: "path",
+		segments
 	};
 }
 function callName(syn, keys) {
@@ -8565,13 +9637,58 @@ function callName(syn, keys) {
 	if (syn.forms.has(name) || syn.opWords.has(keys[0])) return void 0;
 	return syn.ops === true || syn.ops.has(name) ? name : void 0;
 }
-function formShape(form, value) {
-	if (form.fields === void 0) {
-		if (!Array.isArray(value) || value.length < form.min) return void 0;
-		return {
+const WRAPPED = "This syntax reads a literal in this place as its data envelope, thus a bare literal has no text here.";
+/**
+* This function gives the text of a document in a place that takes a document (K159). A data envelope of a literal
+* is the bare literal. A literal without its envelope has no text, because `parse` gives it the envelope. The
+* function gives `undefined` for each other document.
+*/
+function wrappedShape(syn, doc) {
+	if (syn.envelopes === void 0) return void 0;
+	if (!isEnvelope(doc)) return envelopeOf(syn, doc) === void 0 ? void 0 : none(WRAPPED);
+	if (doc.name !== void 0 || doc.own !== void 0 || !Object.hasOwn(doc, "value")) return void 0;
+	const path = typePath(doc.type);
+	if (path === void 0) return void 0;
+	const key = JSON.stringify(path);
+	if (key === JSON.stringify(["lit"])) return envelopeOf(syn, doc.value) === void 0 ? void 0 : none(WRAPPED);
+	if (envelopeOf(syn, doc.value)?.key !== key) return void 0;
+	const literal = literalShape(syn, doc.value);
+	return literal.tag === "text" ? literal : void 0;
+}
+function formShape(syn, form, value) {
+	if (form.args === "literal") {
+		if (!isScalar(value)) return void 0;
+		const literal = literalShape(syn, value);
+		return literal.tag === "text" ? {
+			tag: "text",
+			text: `${form.name}(${literal.text})`
+		} : void 0;
+	}
+	if (form.args === "named") {
+		if (!isRecord(value)) return void 0;
+		const keys = Object.keys(value);
+		if (form.fields !== void 0 && !keys.every((key) => form.fields?.includes(key) === true)) return void 0;
+		return {
 			tag: "call",
 			name: form.name,
-			args: value.map((item, index) => [index, item])
+			args: keys.map((key) => [
+				key,
+				value[key],
+				wraps(form, key)
+			]),
+			named: true
+		};
+	}
+	if (form.fields === void 0) {
+		if (!Array.isArray(value) || value.length < form.min) return void 0;
+		return {
+			tag: "call",
+			name: form.name,
+			args: value.map((item, index) => [
+				index,
+				item,
+				wraps(form, index)
+			])
 		};
 	}
 	if (!isRecord(value)) return void 0;
@@ -8581,7 +9698,11 @@ function formShape(form, value) {
 	return {
 		tag: "call",
 		name: form.name,
-		args: present.map((key) => [key, value[key]])
+		args: present.map((key) => [
+			key,
+			value[key],
+			wraps(form, key)
+		])
 	};
 }
 function opShape(syn, key, terms) {
@@ -8594,7 +9715,16 @@ function opShape(syn, key, terms) {
 /** This function gives the shape of a document: a literal or a reference, an operator, a call, or no text. */
 function shapeOf(syn, doc) {
 	if (!isEnvelope(doc)) return Array.isArray(doc) || isRecord(doc) ? none("This syntax has no text for a list or a record literal.") : literalShape(syn, doc);
-	if (doc.name !== void 0 || doc.own !== void 0) return none("This syntax has no text for the header of a document.");
+	if (doc.own !== void 0) return none("This syntax has no text for the own entries of a document.");
+	if (doc.name !== void 0) {
+		if (syn.bind === void 0) return none("This syntax has no text for the name of a document.");
+		const { name, ...rest } = doc;
+		return {
+			tag: "bind",
+			name,
+			doc: rest
+		};
+	}
 	const path = typePath(doc.type);
 	if (path === void 0) return none("This syntax has no text for a computed type.");
 	const value = doc.value;
@@ -8615,7 +9745,7 @@ function shapeOf(syn, doc) {
 	const op = Array.isArray(value) ? opShape(syn, key, value) : void 0;
 	if (op !== void 0) return op;
 	for (const form of syn.formsByKind.get(key) ?? []) {
-		const shape = formShape(form, value);
+		const shape = formShape(syn, form, value);
 		if (shape !== void 0) return shape;
 	}
 	const called = path[0] === "ops" && Array.isArray(value) ? callName(syn, path.slice(1)) : void 0;
@@ -8628,7 +9758,7 @@ function shapeOf(syn, doc) {
 }
 function levelOf(syn, doc) {
 	const shape = shapeOf(syn, doc);
-	return shape.tag === "op" ? shape.op.prec : Number.POSITIVE_INFINITY;
+	return shape.tag === "op" ? shape.op.prec : shape.tag === "bind" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
 }
 /** This function tells if a term needs parentheses in its position, so that `parse` reads the same tree. */
 function needsGroup(op, index, level) {
@@ -8658,18 +9788,42 @@ function printNode(syn, doc, sub) {
 	if (shape.tag === "text") return ok(shape.text);
 	if (shape.tag === "none") return fail("#VALUE!", shape.reason);
 	if (shape.tag === "op") return opText(syn, shape.op, shape.terms, sub);
+	if (shape.tag === "bind") {
+		const head = wrappedShape(syn, shape.doc);
+		const inner = head === void 0 ? printNode(syn, shape.doc, sub) : head.tag === "text" ? ok(head.text) : fail("#VALUE!", WRAPPED);
+		return inner.ok ? ok(`${NAME.test(shape.name) ? shape.name : quoteName(shape.name)} ${syn.bind} ${inner.value}`) : inner;
+	}
+	if (shape.tag === "path") {
+		const texts = [];
+		for (const segment of shape.segments) {
+			if (typeof segment === "string") {
+				texts.push(segment);
+				continue;
+			}
+			const result = sub(segment[1], [segment[0]]);
+			if (!result.ok) return result;
+			texts.push(`(${result.value})`);
+		}
+		return ok(texts.join("."));
+	}
 	const texts = [];
-	for (const [key, arg] of shape.args) {
-		const result = sub(arg, [key]);
+	for (const [key, arg, wrapped] of shape.args) {
+		const result = sub(arg, [key], wrapped);
 		if (!result.ok) return result;
-		texts.push(result.value);
+		texts.push(shape.named === true ? `${NAME.test(String(key)) ? String(key) : quoteName(String(key))}: ${result.value}` : result.value);
 	}
 	return ok(`${shape.name}(${texts.join(`${syn.separator} `)})`);
 }
 function printTree(syn, doc, place) {
-	const result = printNode(syn, doc, (child, path) => printTree(syn, child, [...place, ...path]));
+	const result = printNode(syn, doc, (child, path, wrapped) => (wrapped === true ? printPlace : printTree)(syn, child, [...place, ...path]));
 	return result.ok || result.error.place !== void 0 ? result : fail(result.error.code, result.error.reason, { place });
 }
+/** This function writes a document in a place that takes a document, for example the whole text (K159). */
+function printPlace(syn, doc, place) {
+	const shape = wrappedShape(syn, doc);
+	if (shape === void 0) return printTree(syn, doc, place);
+	return shape.tag === "text" ? ok(shape.text) : fail("#VALUE!", WRAPPED, { place });
+}
 /**
 * This function writes a document as text with the rules of a profile (SYNTAX.PRINT). It writes the fewest
 * parentheses that keep the tree. `parse` reads the text back to the same document (SYNTAX.ROUNDTRIP).
@@ -8682,7 +9836,7 @@ function printTree(syn, doc, place) {
 function print(profile, doc) {
 	const syn = compileProfile(profile);
 	try {
-		return printTree(syn, doc, []);
+		return printPlace(syn, doc, []);
 	} catch (error) {
 		if (isStackOverflow(error)) return fail("#DEPTH!", "The document is too deep for the stack of the host.", { cause: error });
 		throw error;
@@ -8700,7 +9854,9 @@ function syntaxFormat(profile) {
 	const syn = compileProfile(profile);
 	const code = ({ doc, parts, place }) => {
 		const byPath = new Map(parts.map((part) => [JSON.stringify(part.path), part]));
-		return printNode(syn, doc, (child, path) => {
+		return printNode(syn, doc, (child, path, wrapped) => {
+			const own = wrapped === true ? wrappedShape(syn, child) : void 0;
+			if (own !== void 0) return own.tag === "text" ? ok(own.text) : fail("#VALUE!", WRAPPED, { place: [...place, ...path] });
 			const part = byPath.get(JSON.stringify(path));
 			if (part === void 0) return printTree(syn, child, [...place, ...path]);
 			const result = part.evaluate();
@@ -8821,6 +9977,54 @@ function resolveFully(machine, ctx, path, options) {
 		hops: []
 	};
 }
+/** The text that names a resolution in the error of an exception of the host (READS.RECORD). */
+const READ_FAILED = "the resolution of a path";
+/**
+* This function resolves a path for a document, and records the read when the evaluation has a list (REF.READS,
+* READS.RECORD). An exception of the host gives the error value of the read, and the exception goes on.
+*/
+function readAt(env, ctx, path, options) {
+	const reading = env.reading;
+	if (reading === void 0) return resolveFully(env.machine, ctx, path, options);
+	const free = freeIn(reading.root, ctx, path);
+	let found;
+	try {
+		found = resolveFully(env.machine, ctx, path, options);
+	} catch (error) {
+		reading.list.push({
+			path,
+			reached: thrown(error, READ_FAILED),
+			free
+		});
+		throw error;
+	}
+	reading.list.push(options?.hops === true ? {
+		path,
+		reached: reachedOf(found),
+		free,
+		hops: found.hops
+	} : {
+		path,
+		reached: reachedOf(found),
+		free
+	});
+	return found;
+}
+/**
+* This function tells if a read reads the context at the root of the evaluation (READS.FREE). The reference reads
+* the rule from SPEC. A name that a kind binds, a `self` that a kind sets and a path without a root are not free. A
+* name that a kind does not bind keeps its value from the root.
+*/
+function freeIn(root, ctx, path) {
+	const head = path[0];
+	if (head === "self") return Object.is(ctx.self, root.self);
+	if (head !== "names") return typeof head === "string" && ROOTS.includes(head);
+	const name = path[1];
+	if (ctx.names === root.names || !isKey(name)) return true;
+	const key = String(name);
+	const bound = Object.hasOwn(ctx.names, key);
+	return bound === Object.hasOwn(root.names, key) && (!bound || Object.is(ctx.names[key], root.names[key]));
+}
 /**
 * 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
@@ -8975,7 +10179,7 @@ function evalInput(env, seen, at) {
 		place: at.place,
 		machine: env.machine,
 		...at.address ? { address: true } : {},
-		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
+		resolve: (path, options) => readAt(env, at.ctx, path, options),
 		effect: (kind, payload) => causeFromEvaluator(env, at.ctx, kind, payload, at.place),
 		fill
 	};
@@ -9002,7 +10206,7 @@ function runInput(env, seen, at) {
 		context: at.ctx,
 		place: at.place,
 		machine: env.machine,
-		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
+		resolve: (path, options) => readAt(env, at.ctx, path, options),
 		effect: (kind, payload) => causeAndWait(env, at.ctx, kind, payload, at.place),
 		all: (list, options) => together(env, list, options),
 		fill
@@ -9031,6 +10235,7 @@ function* together(env, list, options = {}) {
 	outer.alls += 1;
 	let failed = false;
 	let started = 0;
+	let before = 0;
 	const end = (index, result) => {
 		results[index] = result;
 		if (failFast && !result.ok) failed = true;
@@ -9094,10 +10299,11 @@ function* together(env, list, options = {}) {
 	};
 	startMore();
 	while (waiting.length > 0 && !failed) {
-		const chosen = env.journal?.next?.(address, waiting.map((waiter) => waiter.index));
+		const chosen = env.journal?.next?.(address, waiting.map((waiter) => waiter.index), before);
 		const pick = chosen === void 0 ? void 0 : waiting.find((waiter) => waiter.index === chosen);
 		const resumed = yield pick === void 0 ? Promise.race(waiting.map((waiter) => waiter.next)) : pick.next;
 		env.journal?.settled?.(address, resumed.waiter.index);
+		before += 1;
 		waiting.splice(waiting.indexOf(resumed.waiter), 1);
 		goOn(resumed.waiter.index, resumed.waiter.steps, resumed);
 		startMore();
@@ -9124,9 +10330,17 @@ function* together(env, list, options = {}) {
 * @returns The result.
 */
 function reference(machine, doc, context = makeContext(), options = {}) {
-	const env = envOf(machine, options, false);
+	return evaluateRoot(machine, doc, context, options, void 0);
+}
+/**
+* This function evaluates a document from its root. An equation of a tree gives the record of its tree. Thus the
+* reads of the equation go in the list of the outer evaluation (REF.READS).
+*/
+function evaluateRoot(machine, doc, context, options, outer) {
+	const at = rootAt(machine, doc, context, options);
+	const env = envOf(machine, options, false, at.ctx, outer);
 	try {
-		return within(env, () => evaluateAt(env, rootAt(machine, doc, context, options)));
+		return within(env, () => evaluateAt(env, at));
 	} catch (error) {
 		return placed(thrown(error, "the reference"), []);
 	}
@@ -9147,11 +10361,15 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 * @returns The result, when the run ends.
 */
 function referenceRun(machine, doc, context = makeContext(), options = {}) {
-	const env = envOf(machine, options, true);
-	return driveRun(env, stepsAt(env, rootAt(machine, doc, context, options)), options.signal).catch((error) => placed(thrown(error, "the reference"), []));
+	const at = rootAt(machine, doc, context, options);
+	const env = envOf(machine, options, true, at.ctx, void 0);
+	return driveRun(env, stepsAt(env, at), options.signal).catch((error) => placed(thrown(error, "the reference"), []));
 }
-/** This function makes the state of the reference for one evaluation or one run. */
-function envOf(machine, options, running) {
+/**
+* This function makes the state of the reference for one evaluation or one run. The record of the reads comes from
+* the evaluation around it, or from the list of the options.
+*/
+function envOf(machine, options, running, root, outer) {
 	const perform = options.perform;
 	return {
 		machine,
@@ -9166,7 +10384,11 @@ function envOf(machine, options, running) {
 			prefix: "",
 			counts: /* @__PURE__ */ new Map(),
 			alls: 0
-		}
+		},
+		reading: outer ?? (options.reads === void 0 ? void 0 : {
+			list: options.reads,
+			root
+		})
 	};
 }
 /** This function gives the root position of a document. A context without a world gets the world of the machine. */
@@ -9241,7 +10463,8 @@ function refNodeOf(thing) {
 }
 /**
 * TREE.LADDER: an equation of the kind of a node evaluates in the reference. It gets the node as `self`, the names of
-* its rung and no capabilities. A bare equation gets the type `of` of the parts of the kind.
+* its rung and no capabilities. A bare equation gets the type `of` of the parts of the kind. The reads of the
+* equation go in the record of the evaluation that made the node (REF.READS).
 */
 function equationOf(node, term, names) {
 	const env = node.env;
@@ -9252,10 +10475,10 @@ function equationOf(node, term, names) {
 		caps: [],
 		self: node.thing
 	};
-	return reference(env.machine, term, ctx, {
+	return evaluateRoot(env.machine, term, ctx, {
 		definitions: env.definitions,
 		...node.of === void 0 ? {} : { declaredType: node.of }
-	});
+	}, env.reading);
 }
 function termIn(table, name) {
 	return table === void 0 || !Object.hasOwn(table, name) ? void 0 : table[name];
@@ -9501,10 +10724,13 @@ function formulaDefinitions(profile = {}) {
 		}
 		const head = path[0] === "names" && typeof path[1] === "string" ? path[1] : void 0;
 		const bound = head === void 0 ? void 0 : own$1(context.names, head);
-		if (bound instanceof Held) return {
-			ok: false,
-			error: bound.error
-		};
+		if (bound instanceof Held) {
+			walk(["names", head]);
+			return {
+				ok: false,
+				error: bound.error
+			};
+		}
 		const found = walk(steps);
 		if (!found.ok) return fail(found.code, found.reason);
 		if (address === true) return ok(found.thing);
@@ -9667,18 +10893,21 @@ function valuesOfStrict(parts) {
 * Its log keeps each effect with its address, its kind, its payload and the outcome that the kernel gives it. The log
 * also keeps the order in which the waits of each `all` settle.
 *
+* The recorder gives each call of its journal to the journal of the inner function, for example of a replayer. Thus a
+* recording of a replay settles the waits in the order of the replayer, and it gives the same log (RUN.REPLAY-ORDER).
+*
 * @param perform - The function of the host. Without it, each effect gives its payload, as in a run without a host.
 * @returns The function `perform` for the run, and the log.
 */
 function recorder(perform) {
 	const seen = [];
 	const settles = [];
-	const journal = { settled: (all, item) => {
+	const journal = relay(perform, (all, item) => {
 		settles.push({
 			all,
 			item
 		});
-	} };
+	});
 	const host = (effect) => {
 		const entry = {
 			effect,
@@ -9704,56 +10933,928 @@ function recorder(perform) {
 	};
 }
 /**
-* This function makes a replayer: a function `perform` that answers each effect from a log, by its address (RUN.REPLAY). A
-* recorded error comes again with its code, its reason, its place and its cause. The waits of each `all` settle in the
-* recorded order. An effect that the log does not have at its address gives `#REPLAY!` (RUN.REPLAY-MISMATCH).
+* This function makes a replayer: a function `perform` that answers each effect from a log, by its address (RUN.REPLAY). A
+* recorded error comes again with its code, its reason, its place and its cause. The waits of each `all` settle in the
+* recorded order. An effect that the log does not have at its address gives `#REPLAY!` (RUN.REPLAY-MISMATCH).
+*
+* One replayer serves more than one run, also two runs at the same time (RUN.REPLAY-RUNS). The kernel tells the journal
+* the number of the waits of each `all` that settled before, thus the replayer keeps no state of a run. When the
+* recorded item of a wait does not wait in the run, that wait follows the order of the host.
+*
+* @param log - The log of a recorder, or of `decodeLog`.
+* @param options - `wait: false` for an evaluation, and the rule of the host for payloads.
+* @returns The function `perform` for the replay.
+*/
+function replayer(log, options = {}) {
+	const wait = options.wait !== false;
+	const equal = options.equal;
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of log.effects) entries.set(entry.address, entry);
+	const order = /* @__PURE__ */ new Map();
+	for (const settle of log.settles) {
+		const items = order.get(settle.all);
+		if (items === void 0) order.set(settle.all, [settle.item]);
+		else items.push(settle.item);
+	}
+	let places;
+	const journal = { next: (all, waiting, before) => {
+		const items = order.get(all);
+		if (items === void 0) return void 0;
+		const at = before ?? (places ??= /* @__PURE__ */ new Map()).get(all) ?? 0;
+		const item = items[at];
+		if (item === void 0 || !waiting.includes(item)) return void 0;
+		if (before === void 0) places?.set(all, at + 1);
+		return item;
+	} };
+	const perform = (effect) => {
+		const entry = effect.address === void 0 ? void 0 : entries.get(effect.address);
+		const wrong = mismatch(effect, entry, equal);
+		if (wrong !== void 0 || entry === void 0) throw wrong;
+		const outcome = entry.outcome;
+		const failure = outcome === void 0 ? replayError(effect, `The log has no outcome for the effect ${effect.kind} at ${effect.address ?? ""}: the recorded run stopped before the answer.`) : outcome.ok ? void 0 : new Failure(outcome.error);
+		const value = outcome?.ok === true ? outcome.value : void 0;
+		if (wait && entry.waited) return failure === void 0 ? Promise.resolve(value) : Promise.reject(failure);
+		if (failure !== void 0) throw failure;
+		return value;
+	};
+	return Object.assign(perform, { [JOURNAL]: journal });
+}
+/** This function gives the error of an effect that the log does not have at its address, or `undefined`. */
+function mismatch(effect, entry, equal) {
+	const at = effect.address ?? "";
+	if (entry === void 0) return replayError(effect, `The log has no effect at the address ${at}, and the run asks for the effect ${effect.kind}.`);
+	if (entry.kind !== effect.kind) return replayError(effect, `The log has the effect ${entry.kind} at the address ${at}, and the run asks for the effect ${effect.kind}.`);
+	if (!equalWith(entry.payload, effect.payload, equal)) return replayError(effect, `The effect ${effect.kind} at the address ${at} has another payload than the log.`);
+}
+/** This function gives the exception that carries `#REPLAY!` to the kernel, with the place of the effect. */
+function replayError(effect, reason) {
+	return new Failure(fail("#REPLAY!", reason, { place: effect.place }).error);
+}
+/**
+* This function gives a journal that tells a function of its own each wait that settles. It gives each call to the
+* journal of the inner function `perform`, when that function has one.
+*
+* @param perform - The inner function.
+* @param settled - The function of its own.
+* @returns The journal.
+*/
+function relay(perform, settled) {
+	const inner = perform === void 0 ? void 0 : perform[JOURNAL];
+	const tell = (all, item) => {
+		settled(all, item);
+		inner?.settled?.(all, item);
+	};
+	if (inner?.next === void 0) return { settled: tell };
+	return {
+		settled: tell,
+		next: (all, waiting, before) => inner.next?.(all, waiting, before)
+	};
+}
+/** This function tells if a key is a field of an error value that the JSON form keeps. */
+function errorField(key) {
+	return key === "code" || key === "reason" || key === "place" || key === "cause";
+}
+/** This function tells if a key is a field of an exception that the JSON form keeps in a field of its own, or drops. */
+function ownField(key) {
+	return key === "name" || key === "message" || key === "stack" || key === "cause";
+}
+/** This function tells if a key is a field of the JSON form of an exception. */
+function exceptionField(key) {
+	return key === "name" || key === "message" || key === "fields" || key === "parts" || key === "dropped" || key === "hidden" || key === "cause" || key === "exception" || key === "loop" || key === "causeParts";
+}
+/**
+* The own fields that are not enumerable and that the JSON form keeps in `hidden` (D77). The standard classes define
+* them: `errors` of `AggregateError`, `error` and `suppressed` of `SuppressedError`.
+*/
+const HIDDEN = /* @__PURE__ */ Object.freeze([
+	"errors",
+	"error",
+	"suppressed"
+]);
+/** The result of `readField` for a field that the walk of `causeJson` cannot read. */
+const MISSING = /* @__PURE__ */ Symbol("missing");
+/**
+* This function tells if a value holds a hole of a list at some depth. `encodeValue` writes a hole as `undefined`. Thus
+* the walk of `causeJson` keeps such a value in parts, and the hole keeps its mark (D82).
+*/
+function holdsHole(value) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [value];
+	while (stack.length > 0) {
+		const at = stack.pop();
+		if (typeof at !== "object" || at === null || seen.has(at) || !(Array.isArray(at) || isRecord(at))) continue;
+		seen.add(at);
+		if (Array.isArray(at)) for (let item = 0; item < at.length; item += 1) {
+			if (!Object.hasOwn(at, item)) return true;
+			stack.push(at[item]);
+		}
+		else for (const key of Object.keys(at)) stack.push(at[key]);
+	}
+	return false;
+}
+/**
+* This function tells if a list or a plain record holds an exception at some depth (D87). It reads the items as the
+* walk of `causeJson` does, thus a cause container with an exception gets a form.
+*/
+function holdsException(value) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [value];
+	while (stack.length > 0) {
+		const at = stack.pop();
+		if (at instanceof Error) return true;
+		if (typeof at !== "object" || at === null || seen.has(at) || !(Array.isArray(at) || isRecord(at))) continue;
+		seen.add(at);
+		if (Array.isArray(at)) {
+			for (let item = 0; item < at.length; item += 1) if (Object.hasOwn(at, item)) stack.push(readField(at, item));
+		} else for (const key of Object.keys(at)) stack.push(readField(at, key));
+	}
+	return false;
+}
+/** This function gives the field of a cause for its form after the walk (D76, D87). A cause without a form has no field. */
+function causeOf(built) {
+	const form = built.form;
+	if (form === void 0) return { names: built.names };
+	if (Array.isArray(form) || "record" in form || "share" in form) return {
+		link: { causeParts: form },
+		names: built.names
+	};
+	return {
+		link: "value" in form ? { cause: form.value } : form,
+		names: built.names
+	};
+}
+/** This function gives the term document of a value of an exception, or `undefined` when the value has none. */
+function termOrNothing(machine, value) {
+	if (holdsHole(value)) return void 0;
+	try {
+		return encodeValue(machine, value);
+	} catch {
+		return;
+	}
+}
+/** This function reads a field of a value, or gives `MISSING` when the read throws. */
+function readField(value, key) {
+	try {
+		return value[key];
+	} catch {
+		return MISSING;
+	}
+}
+/** This function gives the forms of the parts with a form, with their keys, in the order of the keys. */
+function keptOf(keys, built) {
+	const kept = [];
+	for (let place = 0; place < keys.length; place += 1) {
+		const form = built[place]?.form;
+		if (form !== void 0) kept.push([keys[place], form]);
+	}
+	return kept;
+}
+/**
+* This function writes a cause without a term document as JSON (RUN.REPLAY-CAUSES, RUN.REPLAY-HIDDEN, RUN.REPLAY-FIELDS).
+* The cause is an exception with its hidden fields and its causes, or a container with an exception (D87). A host
+* makes the exception, thus a part without a term document is a note in `dropped`, not a refusal (D75, D76).
+*
+* The walk gives each exception an index in the order of a depth-first walk. It takes the fields in `parts` in the
+* order of their keys, the hidden fields in the order of `HIDDEN`, then the cause (D78). A list or a plain record
+* without a term document is a container of parts, with its items in their order (D82). A cause is a container only
+* when it holds an exception (D87). A value that is an earlier exception of the walk is its index in `loop` (D77).
+*
+* A container that an earlier place holds is its index in `share`, also a container that holds itself (D88). The walk is
+* a loop, thus a long chain does not overflow the stack.
+*/
+function causeJson(machine, root) {
+	const items = [];
+	const index = /* @__PURE__ */ new Map();
+	const holders = /* @__PURE__ */ new Map();
+	const tasks = [];
+	const later = (children) => {
+		for (let place = children.length - 1; place >= 0; place -= 1) tasks.push(children[place]);
+	};
+	const hold = (name, value, keep, children) => {
+		const at = items.length;
+		holders.set(value, at);
+		const list = Array.isArray(value);
+		const keys = list ? [] : Object.keys(value);
+		const slots = [];
+		items.push({
+			name,
+			list,
+			keep,
+			keys,
+			slots
+		});
+		const size = list ? value.length : keys.length;
+		for (let place = 0; place < size; place += 1) {
+			const key = list ? place : keys[place];
+			const item = list && !Object.hasOwn(value, place) ? MISSING : readField(value, key);
+			const put = (part) => {
+				slots[place] = part;
+			};
+			children.push({
+				value: item,
+				name: `${name}.${key}`,
+				tried: false,
+				nest: true,
+				keep: false,
+				put
+			});
+		}
+		return at;
+	};
+	const open = (current) => {
+		const at = items.length;
+		index.set(current, index.size);
+		const fields = [];
+		const linked = [];
+		for (const key of Object.keys(current)) {
+			if (ownField(key)) continue;
+			const value = readField(current, key);
+			const term = value === MISSING ? void 0 : termOrNothing(machine, value);
+			if (term === void 0) linked.push([key, value]);
+			else fields.push([key, term]);
+		}
+		const node = {
+			head: {
+				name: String(current.name),
+				message: String(current.message),
+				...fields.length === 0 ? {} : { fields: Object.fromEntries(fields) }
+			},
+			keys: linked.map(([key]) => key),
+			parts: [],
+			hiddenKeys: [],
+			hidden: []
+		};
+		items.push(node);
+		const children = [];
+		for (let place = 0; place < linked.length; place += 1) {
+			const [key, value] = linked[place];
+			const put = (part) => {
+				node.parts[place] = part;
+			};
+			children.push({
+				value,
+				name: key,
+				tried: true,
+				nest: true,
+				keep: false,
+				put
+			});
+		}
+		for (const key of HIDDEN) {
+			if (Object.getOwnPropertyDescriptor(current, key)?.enumerable !== false) continue;
+			const place = node.hiddenKeys.length;
+			node.hiddenKeys.push(key);
+			const value = readField(current, key);
+			const put = (part) => {
+				node.hidden[place] = part;
+			};
+			children.push({
+				value,
+				name: key,
+				tried: false,
+				nest: true,
+				keep: Array.isArray(value),
+				put
+			});
+		}
+		if (Object.hasOwn(current, "cause")) {
+			const put = (part) => {
+				node.cause = part;
+			};
+			children.push({
+				value: current.cause,
+				name: "cause",
+				tried: false,
+				nest: false,
+				keep: false,
+				put
+			});
+		}
+		later(children);
+		return at;
+	};
+	let top = { none: "cause" };
+	tasks.push({
+		value: root,
+		name: "cause",
+		tried: true,
+		nest: false,
+		keep: false,
+		put: (part) => {
+			top = part;
+		}
+	});
+	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+		const value = task.value;
+		if (value === MISSING) {
+			task.put({ none: task.name });
+			continue;
+		}
+		const loop = index.get(value);
+		if (loop !== void 0) {
+			task.put({ loop });
+			continue;
+		}
+		const term = task.tried || task.keep ? void 0 : termOrNothing(machine, value);
+		if (term !== void 0) task.put({ value: term });
+		else if (value instanceof Error) task.put({ node: open(value) });
+		else if ((Array.isArray(value) || isRecord(value)) && (task.nest || holdsException(value))) {
+			const held = holders.get(value);
+			if (held === void 0) {
+				const children = [];
+				task.put({ holder: hold(task.name, value, task.keep, children) });
+				later(children);
+			} else {
+				if (task.keep) items[held].keep = true;
+				task.put({
+					same: held,
+					name: task.name
+				});
+			}
+		} else task.put({ none: task.name });
+	}
+	const { formed, shares } = formsOf(items);
+	const forms = [];
+	const builtOf = (part) => {
+		if ("none" in part) return { names: [part.none] };
+		if ("node" in part) return {
+			form: { exception: forms[part.node] },
+			names: []
+		};
+		if ("holder" in part) return forms[part.holder];
+		if ("same" in part) return formed[part.same] === true ? {
+			form: { share: shares[part.same] },
+			names: []
+		} : { names: [part.name] };
+		return {
+			form: part,
+			names: []
+		};
+	};
+	for (let at = items.length - 1; at >= 0; at -= 1) {
+		const item = items[at];
+		if ("slots" in item) {
+			if (formed[at] !== true) {
+				forms[at] = { names: [item.name] };
+				continue;
+			}
+			const built = Array.from(item.slots, builtOf);
+			const form = item.list ? built.map((part) => part.form ?? { dropped: true }) : { record: Object.fromEntries(keptOf(item.keys, built)) };
+			forms[at] = {
+				form,
+				names: built.flatMap((part) => part.names)
+			};
+			continue;
+		}
+		const { head, keys, parts, hiddenKeys, hidden, cause } = item;
+		const linked = Array.from(parts, builtOf);
+		const kept = Array.from(hidden, builtOf);
+		const link = cause === void 0 ? { names: [] } : causeOf(builtOf(cause));
+		const dropped = [
+			...linked,
+			...kept,
+			link
+		].flatMap((part) => part.names);
+		const partsOf = keptOf(keys, linked);
+		const hiddenOf = keptOf(hiddenKeys, kept);
+		forms[at] = {
+			...head,
+			...partsOf.length === 0 ? {} : { parts: Object.fromEntries(partsOf) },
+			...dropped.length === 0 ? {} : { dropped },
+			...hiddenOf.length === 0 ? {} : { hidden: Object.fromEntries(hiddenOf) },
+			...link.link
+		};
+	}
+	return causeOf(builtOf(top));
+}
+/**
+* This function tells which containers of the walk of `causeJson` get a form, and it gives each such container its
+* index for `share` (D88). A container gets a form when it is a hidden list, or when an item has a form. A share has
+* the form of its container. Thus a cycle of containers without another form has no form. The index counts the
+* containers with a form in the order of the walk, as `decodeLog` meets them.
+*/
+function formsOf(items) {
+	const formed = [];
+	const users = /* @__PURE__ */ new Map();
+	const work = [];
+	for (let at = 0; at < items.length; at += 1) {
+		const item = items[at];
+		if (!("slots" in item)) continue;
+		let seed = item.keep;
+		for (const part of item.slots) {
+			const on = "holder" in part ? part.holder : "same" in part ? part.same : void 0;
+			if (on === void 0) seed ||= !("none" in part);
+			else {
+				const list = users.get(on);
+				if (list === void 0) users.set(on, [at]);
+				else list.push(at);
+			}
+		}
+		if (seed) {
+			formed[at] = true;
+			work.push(at);
+		}
+	}
+	for (let at = work.pop(); at !== void 0; at = work.pop()) for (const user of users.get(at) ?? []) {
+		if (formed[user] === true) continue;
+		formed[user] = true;
+		work.push(user);
+	}
+	const shares = [];
+	let count = 0;
+	for (let at = 0; at < items.length; at += 1) {
+		if (formed[at] !== true) continue;
+		shares[at] = count;
+		count += 1;
+	}
+	return {
+		formed,
+		shares
+	};
+}
+/** This function gives the message of an exception, or a short text for another value. */
+function messageOf(error) {
+	return error instanceof Error ? error.message : describe(error);
+}
+/** This function writes a value of a log as a term document, or throws a `TypeError` that names the value. */
+function termOf(machine, value, what) {
+	try {
+		return encodeValue(machine, value);
+	} catch (error) {
+		throw new TypeError(`encodeLog cannot write ${what()}: ${messageOf(error)}`);
+	}
+}
+/** This function writes an error value of a log as JSON, or throws a `TypeError` that names the error. */
+function errorJson(machine, error, what) {
+	for (const key of Object.keys(error)) if (!errorField(key)) throw new TypeError(`encodeLog cannot write ${what()}: the error has the field ${key}, and the JSON form has no field for it.`);
+	const base = {
+		code: error.code,
+		reason: error.reason,
+		...error.place === void 0 ? {} : { place: error.place }
+	};
+	if (!Object.hasOwn(error, "cause")) return base;
+	const cause = error.cause;
+	try {
+		return {
+			...base,
+			cause: encodeValue(machine, cause)
+		};
+	} catch (failure) {
+		const { link, names } = causeJson(machine, cause);
+		if (link === void 0) throw new TypeError(`encodeLog cannot write the cause of ${what()}: ${messageOf(failure)}`);
+		return {
+			...base,
+			...link,
+			...names.length === 0 ? {} : { dropped: names }
+		};
+	}
+}
+/**
+* This function writes a log as JSON (RUN.REPLAY-JSON, D75). Then `JSON.stringify` gives the text of a golden file.
+*
+* - Each payload and each value of an outcome is a term document of `encodeValue`. Thus `NaN`, `-0` and `undefined`
+*   stay exact, and a member of a domain with a codec is `ext.domain`.
+* - An error keeps its code, its reason, its place and its cause. A cause that `encodeValue` cannot write and that is
+*   an exception keeps its name and its message in the field `exception`.
+* - An exception also keeps its own fields that `encodeValue` writes, and the chain of its causes (RUN.REPLAY-CAUSES).
+*   The list `dropped` names each other own field. A cause that is an earlier exception of the chain is its index in `loop`.
+* - An exception keeps the hidden fields of the standard classes in `hidden`, for example `errors` of an
+*   `AggregateError` (RUN.REPLAY-HIDDEN, D77). Each exception in them has the rule of a cause.
+* - An enumerable field without a term document that is an exception, a list or a plain record is in `parts`
+*   (RUN.REPLAY-FIELDS, D78, D82). An item of a list without a form is the mark `dropped` at its place.
+* - A cause without a term document that is a list or a plain record with an exception is in `causeParts`
+*   (RUN.REPLAY-CAUSE-PARTS, D87). The rule is the same for the cause of an exception and of an error value.
+* - A list or a record of parts that an earlier place of one error holds is the part `share` with its index
+*   (RUN.REPLAY-SHARED, D88). This rule also covers a container that holds itself.
+* - An outcome that the log does not have stays absent.
+*
+* @param machine - The machine of the run, or only its domains.
+* @param log - The log of a recorder.
+* @returns The JSON form. `decodeLog` gives the log again.
+* @throws {TypeError} A value has no term document, for example a closure, a host thing, a symbol, or a value that no
+*   domain with a codec holds. The message names the effect and its address. A part of an exception is not a refusal.
+*/
+function encodeLog(machine, log) {
+	return {
+		version: 1,
+		effects: log.effects.map((entry) => {
+			const at = (field) => () => `the ${field} of the effect ${entry.kind} at the address ${entry.address}`;
+			const head = {
+				address: entry.address,
+				kind: entry.kind,
+				payload: termOf(machine, entry.payload, at("payload"))
+			};
+			const outcome = entry.outcome;
+			if (outcome === void 0) return {
+				...head,
+				waited: entry.waited
+			};
+			const json = outcome.ok ? {
+				ok: true,
+				value: termOf(machine, outcome.value, at("outcome"))
+			} : {
+				ok: false,
+				error: errorJson(machine, outcome.error, at("outcome"))
+			};
+			return {
+				...head,
+				outcome: json,
+				waited: entry.waited
+			};
+		}),
+		settles: log.settles.map((settle) => ({
+			all: settle.all,
+			item: settle.item
+		}))
+	};
+}
+/** This function gives an exception with a name and a message. A standard name gives an instance of its class. */
+function exception(name, message) {
+	const made = standard(name, message);
+	if (made.name !== name) made.name = name;
+	return made;
+}
+/**
+* This function gives an instance of the standard class with a name, or an `Error`. An `AggregateError` gets an empty
+* list `errors`, and a `SuppressedError` gets `undefined` for `error` and `suppressed`, as their constructors do.
+*/
+function standard(name, message) {
+	switch (name) {
+		case "TypeError": return new TypeError(message);
+		case "RangeError": return new RangeError(message);
+		case "SyntaxError": return new SyntaxError(message);
+		case "ReferenceError": return new ReferenceError(message);
+		case "AggregateError": return new AggregateError([], message);
+		case "SuppressedError": return typeof SuppressedError === "function" ? new SuppressedError(void 0, void 0, message) : new Error(message);
+		default: return new Error(message);
+	}
+}
+/** This function gives an exception a field that is not enumerable, as the constructor of `Error` does for `cause`. */
+function hide(error, key, value) {
+	Object.defineProperty(error, key, {
+		value,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+}
+/** This function gives the failed result of a JSON form that `decodeLog` cannot read. */
+function bad(place, reason) {
+	return fail("#VALUE!", `decodeLog cannot read the log: ${reason}`, { place });
+}
+/** This function reads a term document of a log again, with the formula kit and the domains of the machine. */
+function readTerm(kit, doc, place) {
+	const value = decodeValue(kit, doc);
+	return value.ok ? value : bad(place, `the term document gives ${value.error.code}: ${value.error.reason}`);
+}
+/** This function reads the JSON form of an error value again. */
+function readError(kit, data, place) {
+	if (!isRecord(data) || typeof data["code"] !== "string" || !data["code"].startsWith("#") || typeof data["reason"] !== "string") return bad(place, "an error is a record with a code that starts with # and a reason.");
+	for (const key of Object.keys(data)) if (!errorField(key) && key !== "exception" && key !== "causeParts" && key !== "dropped") return bad(place, `an error has no field ${key}.`);
+	const keys = data["place"];
+	if (keys !== void 0 && !(Array.isArray(keys) && keys.every((key) => isKey(key)))) return bad([...place, "place"], "a place is a list of texts and numbers.");
+	const dropped = data["dropped"];
+	if (dropped !== void 0 && !(Array.isArray(dropped) && dropped.every((name) => typeof name === "string"))) return bad([...place, "dropped"], "the list dropped holds texts.");
+	const error = {
+		code: data["code"],
+		reason: data["reason"]
+	};
+	if (keys !== void 0) error.place = keys;
+	const record = data;
+	const links = LINKS.filter((key) => key !== "loop" && Object.hasOwn(record, key));
+	if (links.length > 1) return bad(place, "an error has a cause, an exception or causeParts, not more than one.");
+	const link = links[0];
+	if (link === "cause") {
+		const cause = readTerm(kit, data["cause"], [...place, "cause"]);
+		if (!cause.ok) return cause;
+		error.cause = cause.value;
+	} else if (link !== void 0) {
+		const read = readCause(kit, link, data[link], [...place, link]);
+		if (!read.ok) return read;
+		error.cause = read.value;
+	}
+	return ok(error);
+}
+/**
+* This function reads the JSON form of a cause again: an exception in `exception`, or a container in `causeParts`
+* (RUN.REPLAY-CAUSES, RUN.REPLAY-HIDDEN, RUN.REPLAY-FIELDS, D87). The walk has the order of `causeJson`, thus a loop
+* gives the same exception. A list or a record of parts gives a new list or plain record (D82). A share gives the same
+* list or record as its earlier place (D88). The walk is a loop, thus a long chain does not overflow the stack.
+*/
+function readCause(kit, kind, data, place) {
+	const chain = [];
+	const held = [];
+	const tasks = [];
+	const open = (at, where) => {
+		if (!isRecord(at) || typeof at["name"] !== "string" || typeof at["message"] !== "string" || !Object.keys(at).every(exceptionField)) return bad(where, "an exception is a record with the texts name and message, and only the fields fields, parts, dropped, hidden, cause, exception, loop and causeParts.");
+		const made = exception(at["name"], at["message"]);
+		const fields = at["fields"];
+		if (fields !== void 0) {
+			if (!isRecord(fields)) return bad([...where, "fields"], "the fields of an exception are a record.");
+			for (const key of Object.keys(fields)) {
+				if (ownField(key)) return bad([
+					...where,
+					"fields",
+					key
+				], `the field ${key} of an exception is not in its fields.`);
+				const value = readTerm(kit, fields[key], [
+					...where,
+					"fields",
+					key
+				]);
+				if (!value.ok) return value;
+				Object.defineProperty(made, key, {
+					value: value.value,
+					writable: true,
+					enumerable: true,
+					configurable: true
+				});
+			}
+		}
+		const dropped = at["dropped"];
+		if (dropped !== void 0 && !(Array.isArray(dropped) && dropped.every((name) => typeof name === "string"))) return bad([...where, "dropped"], "the list dropped holds texts.");
+		chain.push(made);
+		const children = [];
+		const taken = (key) => isRecord(fields) && Object.hasOwn(fields, key);
+		const parts = at["parts"];
+		if (parts !== void 0) {
+			if (!isRecord(parts)) return bad([...where, "parts"], "the parts of an exception are a record.");
+			for (const key of Object.keys(parts)) {
+				if (ownField(key) || taken(key)) return bad([
+					...where,
+					"parts",
+					key
+				], `the field ${key} of an exception is not in its parts.`);
+				const show = (value) => {
+					Object.defineProperty(made, key, {
+						value,
+						writable: true,
+						enumerable: true,
+						configurable: true
+					});
+				};
+				const read = slotTask(parts[key], [
+					...where,
+					"parts",
+					key
+				], false, show);
+				if (!read.ok) return read;
+				show(void 0);
+				children.push(read.value);
+			}
+		}
+		const hidden = at["hidden"];
+		if (hidden !== void 0) {
+			if (!isRecord(hidden)) return bad([...where, "hidden"], "the hidden fields of an exception are a record.");
+			for (const key of Object.keys(hidden)) if (!HIDDEN.includes(key) || taken(key) || isRecord(parts) && Object.hasOwn(parts, key)) return bad([
+				...where,
+				"hidden",
+				key
+			], `an exception has no hidden field ${key}.`);
+			for (const key of HIDDEN) {
+				if (!Object.hasOwn(hidden, key)) continue;
+				const read = slotTask(hidden[key], [
+					...where,
+					"hidden",
+					key
+				], false, (value) => hide(made, key, value));
+				if (!read.ok) return read;
+				children.push(read.value);
+			}
+		}
+		const record = at;
+		const links = LINKS.filter((key) => Object.hasOwn(record, key));
+		if (links.length > 1) return bad(where, "an exception has a cause, an exception, a loop or causeParts, not more than one.");
+		const link = links[0];
+		if (link !== void 0) {
+			const read = linkTask(link, record[link], [...where, link], (value) => hide(made, "cause", value));
+			if (!read.ok) return read;
+			children.push(read.value);
+		}
+		for (let index = children.length - 1; index >= 0; index -= 1) tasks.push(children[index]);
+		return ok(made);
+	};
+	let cause;
+	const root = linkTask(kind, data, place, (value) => {
+		cause = value;
+	});
+	if (!root.ok) return root;
+	tasks.push(root.value);
+	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+		const { kind, data: part, where } = task;
+		if (kind === "dropped") continue;
+		if (kind === "loop") {
+			if (typeof part !== "number" || !Number.isInteger(part) || part < 0 || part >= chain.length) return bad(where, "a loop is the index of an exception of the chain until this one.");
+			task.put(chain[part]);
+			continue;
+		}
+		if (kind === "share") {
+			if (typeof part !== "number" || !Number.isInteger(part) || part < 0 || part >= held.length) return bad(where, "a share is the index of a list or a record of parts of the walk until this one.");
+			task.put(held[part]);
+			continue;
+		}
+		if (kind === "list" || kind === "record") {
+			const items = kind === "list" ? listTasks(part, where, held, task.put) : recordTasks(part, where, held, task.put);
+			if (!items.ok) return items;
+			for (let index = items.value.length - 1; index >= 0; index -= 1) tasks.push(items.value[index]);
+			continue;
+		}
+		const value = kind === "exception" ? open(part, where) : readTerm(kit, part, where);
+		if (!value.ok) return value;
+		task.put(value.value);
+	}
+	return ok(cause);
+}
+/**
+* This function reads the field of a cause: `cause`, `exception`, `loop` or `causeParts`. A value of `causeParts` is a
+* list of parts, the part `record` or the part `share`, and no other part (D87, D88).
+*/
+function linkTask(kind, data, where, put) {
+	if (kind !== "causeParts") return ok({
+		kind,
+		data,
+		where,
+		put
+	});
+	if (Array.isArray(data)) return ok({
+		kind: "list",
+		data,
+		where,
+		put
+	});
+	const key = isRecord(data) && Object.keys(data).length === 1 ? Object.keys(data)[0] : void 0;
+	if (isRecord(data) && (key === "record" || key === "share")) return ok({
+		kind: key,
+		data: data[key],
+		where: [...where, key],
+		put
+	});
+	return bad(where, "a cause of parts is a list of parts, the part record or the part share.");
+}
+/**
+* This function reads one value of a field in `parts`, in `hidden` or in a record of parts. A list is a list of parts,
+* and another value is one part.
+*/
+function slotTask(data, where, item, put) {
+	return Array.isArray(data) ? ok({
+		kind: "list",
+		data,
+		where,
+		put
+	}) : partTask(data, where, item, put);
+}
+/**
+* This function gives a list of parts its length at once, and it gives the tasks of its items. Thus the mark `dropped`
+* leaves a hole at its place, and each later item keeps its index (D78). The list goes in `held` for a share (D88).
+*/
+function listTasks(data, where, held, put) {
+	const items = data;
+	const list = [];
+	list.length = items.length;
+	held.push(list);
+	put(list);
+	const tasks = [];
+	for (let item = 0; item < items.length; item += 1) {
+		const task = slotTask(items[item], [...where, item], true, (value) => {
+			list[item] = value;
+		});
+		if (!task.ok) return task;
+		tasks.push(task.value);
+	}
+	return ok(tasks);
+}
+/**
+* This function gives a record of parts a new plain record (D82). It gives the tasks of its fields in the order of
+* the keys. Each key gets its place at once, thus the record keeps the order of the keys. The record goes in `held`
+* for a share (D88).
+*/
+function recordTasks(data, where, held, put) {
+	if (!isRecord(data)) return bad(where, "a record of parts is a record.");
+	const record = {};
+	held.push(record);
+	put(record);
+	const tasks = [];
+	for (const key of Object.keys(data)) {
+		const show = (value) => {
+			Object.defineProperty(record, key, {
+				value,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+		};
+		const task = slotTask(data[key], [...where, key], false, show);
+		if (!task.ok) return task;
+		show(void 0);
+		tasks.push(task.value);
+	}
+	return ok(tasks);
+}
+/**
+* This function reads one part: a record with only one of the fields `value`, `exception`, `loop`, `record` and
+* `share`. An item of a list can also be the mark `{ "dropped": true }`.
+*/
+function partTask(data, where, item, put) {
+	const keys = isRecord(data) ? Object.keys(data) : [];
+	const kind = keys[0];
+	const mark = kind === "dropped" && item && isRecord(data) && data[kind] === true;
+	if (!isRecord(data) || keys.length !== 1 || kind === void 0 || !(PARTS$1.includes(kind) || mark)) return bad(where, "a field of parts is a part or a list of parts. A part has only one of the fields value, exception, loop, record and share, or an item is the mark dropped.");
+	return ok({
+		kind,
+		data: data[kind],
+		where: [...where, kind],
+		put
+	});
+}
+/** The fields of the JSON form of an exception that give its cause. */
+const LINKS = /* @__PURE__ */ Object.freeze([
+	"cause",
+	"exception",
+	"loop",
+	"causeParts"
+]);
+/** The fields of the JSON form of a part of a field in `parts` or `hidden`. */
+const PARTS$1 = /* @__PURE__ */ Object.freeze([
+	"value",
+	"exception",
+	"loop",
+	"record",
+	"share"
+]);
+/** This function reads the JSON form of one effect again. */
+function readEntry(kit, data, place) {
+	if (!isRecord(data) || typeof data["address"] !== "string" || typeof data["kind"] !== "string" || typeof data["waited"] !== "boolean" || !Object.hasOwn(data, "payload")) return bad(place, "an effect is a record with the texts address and kind, a payload, and the truth value waited.");
+	for (const key of Object.keys(data)) if (key !== "address" && key !== "kind" && key !== "payload" && key !== "outcome" && key !== "waited") return bad(place, `an effect has no field ${key}.`);
+	const payload = readTerm(kit, data["payload"], [...place, "payload"]);
+	if (!payload.ok) return payload;
+	const head = {
+		address: data["address"],
+		kind: data["kind"],
+		payload: payload.value,
+		waited: data["waited"]
+	};
+	if (!Object.hasOwn(data, "outcome")) return ok(head);
+	const raw = data["outcome"];
+	const at = [...place, "outcome"];
+	if (isRecord(raw) && raw["ok"] === true && Object.hasOwn(raw, "value") && Object.keys(raw).length === 2) {
+		const value = readTerm(kit, raw["value"], [...at, "value"]);
+		return value.ok ? ok({
+			...head,
+			outcome: ok(value.value)
+		}) : value;
+	}
+	if (isRecord(raw) && raw["ok"] === false && Object.keys(raw).length === 2) {
+		const error = readError(kit, raw["error"], [...at, "error"]);
+		return error.ok ? ok({
+			...head,
+			outcome: {
+				ok: false,
+				error: error.value
+			}
+		}) : error;
+	}
+	return bad(at, "an outcome is a record with ok true and a value, or with ok false and an error.");
+}
+/**
+* This function reads the JSON form of a log again (RUN.REPLAY-JSON). It reads each term document with the formula kit
+* and the domains of the machine. A cause in the field `exception` becomes an exception with that name and message.
+* The exception gets its fields and the chain of its causes again, also a cycle (RUN.REPLAY-CAUSES). A list gets a
+* hole at the place of the mark `dropped`, thus each later item keeps its index (D78). Each share of a list or a record
+* gives the same object (RUN.REPLAY-SHARED).
 *
-* A replayer keeps its place in the order of the waits, thus each run needs a new replayer.
-*
-* @param log - The log of a recorder.
-* @param options - `wait: false` for an evaluation.
-* @returns The function `perform` for the replay.
+* @param machine - The machine of the run, or only its domains.
+* @param data - The JSON form, for example from `JSON.parse` of a golden file.
+* @returns The log for `replayer`, or `#VALUE!` with the place of the first field that it cannot read.
 */
-function replayer(log, options = {}) {
-	const wait = options.wait !== false;
-	const entries = /* @__PURE__ */ new Map();
-	for (const entry of log.effects) entries.set(entry.address, entry);
-	const order = /* @__PURE__ */ new Map();
-	for (const settle of log.settles) {
-		const items = order.get(settle.all);
-		if (items === void 0) order.set(settle.all, [settle.item]);
-		else items.push(settle.item);
-	}
-	const journal = { next: (all, waiting) => {
-		const items = order.get(all);
-		const item = items?.[0];
-		if (items === void 0 || item === void 0 || !waiting.includes(item)) return void 0;
-		items.shift();
-		return item;
-	} };
-	const perform = (effect) => {
-		const entry = effect.address === void 0 ? void 0 : entries.get(effect.address);
-		const wrong = mismatch(effect, entry);
-		if (wrong !== void 0 || entry === void 0) throw wrong;
-		const outcome = entry.outcome;
-		const failure = outcome === void 0 ? replayError(effect, `The log has no outcome for the effect ${effect.kind} at ${effect.address ?? ""}: the recorded run stopped before the answer.`) : outcome.ok ? void 0 : new Failure(outcome.error);
-		const value = outcome?.ok === true ? outcome.value : void 0;
-		if (wait && entry.waited) return failure === void 0 ? Promise.resolve(value) : Promise.reject(failure);
-		if (failure !== void 0) throw failure;
-		return value;
+function decodeLog(machine, data) {
+	if (!isRecord(data) || data["version"] !== 1) return bad([], "the form is a record with the version 1.");
+	const list = data["effects"];
+	const order = data["settles"];
+	if (!Array.isArray(list) || !Array.isArray(order) || Object.keys(data).length !== 3) return bad([], "the form has only the version and the lists effects and settles.");
+	const domains = machine.domains;
+	const kit = {
+		...formulaMachine(),
+		...domains === void 0 ? {} : { domains }
 	};
-	return Object.assign(perform, { [JOURNAL]: journal });
-}
-/** This function gives the error of an effect that the log does not have at its address, or `undefined`. */
-function mismatch(effect, entry) {
-	const at = effect.address ?? "";
-	if (entry === void 0) return replayError(effect, `The log has no effect at the address ${at}, and the run asks for the effect ${effect.kind}.`);
-	if (entry.kind !== effect.kind) return replayError(effect, `The log has the effect ${entry.kind} at the address ${at}, and the run asks for the effect ${effect.kind}.`);
-	if (!docEquals(entry.payload, effect.payload)) return replayError(effect, `The effect ${effect.kind} at the address ${at} has another payload than the log.`);
-}
-/** This function gives the exception that carries `#REPLAY!` to the kernel, with the place of the effect. */
-function replayError(effect, reason) {
-	return new Failure(fail("#REPLAY!", reason, { place: effect.place }).error);
+	const effects = [];
+	for (let index = 0; index < list.length; index += 1) {
+		const entry = readEntry(kit, list[index], ["effects", index]);
+		if (!entry.ok) return entry;
+		effects.push(entry.value);
+	}
+	const settles = [];
+	for (let index = 0; index < order.length; index += 1) {
+		const settle = order[index];
+		if (!isRecord(settle) || typeof settle["all"] !== "string" || !Number.isInteger(settle["item"]) || Object.keys(settle).length !== 2) return bad(["settles", index], "a settle is a record with only the text all and the whole number item.");
+		settles.push({
+			all: settle["all"],
+			item: settle["item"]
+		});
+	}
+	return ok({
+		effects,
+		settles
+	});
 }
 //#endregion
 //#region src/agree.ts
@@ -9762,7 +11863,8 @@ const DEFAULT_TIERS = /* @__PURE__ */ Object.freeze([
 	"reference",
 	"traced",
 	"again",
-	"folds"
+	"folds",
+	"fixed"
 ]);
 /**
 * This function tells if two values are the same for `agree`. Lists and plain records compare item by item and field
@@ -9791,6 +11893,7 @@ function sameInTiers(x, y) {
 	if (x instanceof Held || y instanceof Held) return x instanceof Held && y instanceof Held && errorDiffers(x.error, y.error, false) === void 0;
 }
 const CLOSURE = /* @__PURE__ */ Symbol.for("coeval.closure");
+/** This function gives the parameters of a closure of `fn`, or `undefined` for another function. */
 function closureParams(fn) {
 	return fn[CLOSURE]?.params;
 }
@@ -9830,6 +11933,67 @@ function effectsDiffer(a, b, options) {
 	}
 }
 /**
+* This function compares the plan with the tier `fixed` (PLAN.FIXED). The tier declares each name of plain data fixed,
+* with a frozen copy of its value. It evaluates with these copies, thus the folds with fixed names give the result.
+* Then it evaluates with the context of `agree`, thus the code without the fold gives the result. A fold moves the
+* calls of the host to the compilation, thus only the result and the effects compare.
+*/
+function fixedDiffers(machine, doc, context, result, effects, given, options) {
+	const { perform, ...declared } = given;
+	const held = fixedContext(context);
+	const plan = prepare(machine, doc, {
+		...declared,
+		fixed: { names: held.fixed }
+	});
+	for (const each of [held.context, context]) {
+		const tierEffects = [];
+		const other = plan.evaluate(each, {
+			effects: tierEffects,
+			...perform === void 0 ? {} : { perform }
+		});
+		options.observe?.();
+		if (overflowed(result) || overflowed(other)) continue;
+		const reason = resultDiffers(result, other, options) ?? effectsDiffer(effects, tierEffects, options);
+		if (reason !== void 0) return {
+			other,
+			reason
+		};
+	}
+}
+/**
+* This function gives the context of the tier `fixed`. Each name of plain data gets a deeply frozen copy of its value,
+* and the record of the fixed names holds the same copy. Each other name keeps its value.
+*/
+function fixedContext(context) {
+	const given = context.names;
+	const names = Object.create(Object.getPrototypeOf(given));
+	const fixed = Object.create(null);
+	for (const key of Reflect.ownKeys(given)) {
+		let field = Object.getOwnPropertyDescriptor(given, key);
+		if (typeof key === "string" && "value" in field) {
+			const copy = sharedCopy(field.value);
+			if (copy !== void 0 || field.value === void 0) {
+				Object.defineProperty(fixed, key, {
+					value: copy,
+					enumerable: true
+				});
+				field = {
+					...field,
+					value: copy
+				};
+			}
+		}
+		Object.defineProperty(names, key, field);
+	}
+	return {
+		context: {
+			...context,
+			names
+		},
+		fixed
+	};
+}
+/**
 * This function evaluates a document with a plan and with other tiers, and compares the results (PLAN.AGREES). Two
 * results agree when they have the same value by `sameValue`, or errors with the same code, and the same place when
 * both have one. The effects must have the same kinds, places and payloads, in the same order. A language gives its
@@ -9886,6 +12050,19 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 			});
 			other = traced.result;
 			otherEffects = [...traced.effects];
+		} else if (tier === "fixed") {
+			const why = fixedDiffers(machine, doc, context, result, effects, {
+				...declared,
+				...mock
+			}, options);
+			if (why !== void 0) return {
+				ok: false,
+				tier,
+				plan: result,
+				other: why.other,
+				reason: why.reason
+			};
+			continue;
 		} else if (tier === "folds") {
 			other = prepare(machine, doc, {
 				...declared,
@@ -9950,18 +12127,12 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 function watched(perform) {
 	const effects = [];
 	const settles = [];
-	const inner = perform[JOURNAL];
-	const settled = (all, item) => {
+	const journal = relay(perform, (all, item) => {
 		settles.push({
 			all,
 			item
 		});
-		inner?.settled?.(all, item);
-	};
-	const journal = inner?.next === void 0 ? { settled } : {
-		settled,
-		next: (all, waiting) => inner.next?.(all, waiting)
-	};
+	});
 	const host = (effect) => {
 		effects.push(effect);
 		return perform(effect);
@@ -9983,6 +12154,82 @@ function settlesDiffer(a, b) {
 		if (x?.all !== y?.all || x?.item !== y?.item) return `The wait ${index} settles ${settleText(x)} in the plan, and ${settleText(y)} in the tier.`;
 	}
 }
+/** The roots beside `self` that a value without static reads keeps whole (READS.KEPT). */
+const KEPT_ROOTS = /* @__PURE__ */ Object.freeze([
+	"names",
+	"world",
+	"event",
+	"caps"
+]);
+/**
+* This function tells if the plan does not know the reads of a run. A value without static reads keeps each root
+* (READS.KEPT), thus the list holds a kept read of each whole root.
+*/
+function readsUnknown(reads) {
+	return KEPT_ROOTS.every((root) => reads.some((read) => read.kept === true && read.path.length === 1 && read.path[0] === root));
+}
+/**
+* This function gives the reads that `agreeRun` compares: the free reads of the resolutions (RUN.AGREES-READS). A
+* kept read is the bound of the plan for the later reads of a value, and the reference has no such bound.
+*/
+function resolutions(reads) {
+	return reads.filter((read) => read.free && read.kept !== true);
+}
+function pathText(path) {
+	if (path === void 0) return "no read";
+	try {
+		return JSON.stringify(path);
+	} catch {
+		return path.map(String).join(", ");
+	}
+}
+/**
+* This function gives the rule of a comparison of reads. The rule of the caller answers first. Each tier makes its
+* own nodes of a tree and its own adopted things. Thus two host things are the same when they have the same label,
+* and they are nodes or have the same JSON object.
+*/
+function sameThing(equal) {
+	return (a, b) => {
+		const told = equal?.(a, b);
+		if (told !== void 0) return told;
+		if (!isHostThing(a) || !isHostThing(b)) return void 0;
+		if (a.label !== b.label) return false;
+		if (a.label.startsWith("node ")) return true;
+		try {
+			return Object.is(a.toJson(), b.toJson());
+		} catch {
+			return false;
+		}
+	};
+}
+/** This function gives the difference of what two reads reached, or `undefined` when they agree. */
+function reachedDiffers(a, b, equal, strict) {
+	if (a.ok && b.ok) return sameValue(a.value, b.value, equal) ? void 0 : "The read reaches another value in the tier.";
+	if (!a.ok && !b.ok) {
+		if (a.error.code !== b.error.code) return `The read gives ${a.error.code} in the plan, and ${b.error.code} in the tier.`;
+		return strict && a.error.reason !== b.error.reason ? `The read gives ${a.error.code} with another reason in the tier: "${b.error.reason}" for "${a.error.reason}".` : void 0;
+	}
+	if (!b.ok) return `The read reaches a value in the plan, and ${b.error.code} in the tier.`;
+	return `The read gives ${a.error.code} in the plan, and a value in the tier.`;
+}
+/**
+* This function gives the first difference of the reads of the plan and of a tier, or `undefined` when they agree
+* (RUN.AGREES-READS). Only the free reads of the resolutions compare, in their order. When the plan does not know its
+* reads, the function compares nothing.
+*/
+function readsDiffer(plan, tier, options) {
+	if (readsUnknown(plan)) return void 0;
+	const a = resolutions(plan);
+	const b = resolutions(tier);
+	const equal = sameThing(options.equal);
+	for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+		const x = a[index];
+		const y = b[index];
+		if (x === void 0 || y === void 0 || !sameValue(x.path, y.path, equal)) return `The free read ${index} is ${pathText(x?.path)} in the plan, and ${pathText(y?.path)} in the tier.`;
+		const why = reachedDiffers(x.reached, y.reached, equal, options.strict === true);
+		if (why !== void 0) return `The free read ${index} of ${pathText(x.path)} differs. ${why}`;
+	}
+}
 /**
 * This function compares the run of a document in a plan with its run in other tiers (RUN.AGREES). First the plan
 * starts the run with a recorder around the host. Then each tier replays the log of that run. These tiers are the
@@ -9991,6 +12238,13 @@ function settlesDiffer(a, b) {
 * The rules of `agree` compare the results and the effects, with their addresses and outcomes. A tier must also
 * settle the waits of each `all` in the order of the plan, thus a replay keeps the order of the waits.
 *
+* The reference run must also give the free reads of the plan, in their order (RUN.AGREES-READS). Another replay of
+* the plan records these reads. A kept read does not compare. When the plan keeps each root, its reads are not known,
+* and no read compares.
+*
+* One replayer of the log serves each tier and the replay for the reads (RUN.AGREES-ONE-REPLAYER). The replayer keeps
+* no state of a run (RUN.REPLAY-RUNS), thus each tier replays the same log as with a replayer of its own.
+*
 * @param machine - The world, the evaluators and the runners.
 * @param doc - The document.
 * @param context - The names and the capabilities at the root.
@@ -10014,16 +12268,24 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 	const result = await plan.run(context, { perform: first.perform });
 	const saw = observe?.();
 	const log = recording.log();
+	let planReads;
+	let compared;
+	const replay = replayer(log);
 	for (const tier of options.tiers ?? DEFAULT_TIERS) {
-		const replay = watched(replayer(log));
-		const host = { perform: replay.perform };
+		if (tier === "fixed") continue;
+		const tierReplay = watched(replay);
+		const host = { perform: tierReplay.perform };
 		let other;
-		if (tier === "reference") other = await referenceRun(machine, doc, context, {
-			...declared,
-			...host,
-			...options.definitions === void 0 ? {} : { definitions: options.definitions }
-		});
-		else if (tier === "traced") other = (await run(machine, doc, context, {
+		let tierReads;
+		if (tier === "reference") {
+			tierReads = [];
+			other = await referenceRun(machine, doc, context, {
+				...declared,
+				...host,
+				reads: tierReads,
+				...options.definitions === void 0 ? {} : { definitions: options.definitions }
+			});
+		} else if (tier === "traced") other = (await run(machine, doc, context, {
 			...declared,
 			...host
 		})).result;
@@ -10035,7 +12297,20 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 		const compareCalls = observe !== void 0 && tier !== "folds";
 		const calls = observe?.();
 		if (overflowed(result) || overflowed(other)) continue;
-		const why = resultDiffers(result, other, options) ?? effectsDiffer(first.effects, replay.effects, options) ?? settlesDiffer(first.settles, replay.settles) ?? (compareCalls && !sameValue(saw, calls, options.equal) ? "The host saw other calls in the tier." : void 0);
+		let why = resultDiffers(result, other, options) ?? effectsDiffer(first.effects, tierReplay.effects, options) ?? settlesDiffer(first.settles, tierReplay.settles) ?? (compareCalls && !sameValue(saw, calls, options.equal) ? "The host saw other calls in the tier." : void 0);
+		if (why === void 0 && tierReads !== void 0) {
+			if (planReads === void 0) {
+				const reads = [];
+				await plan.run(context, {
+					perform: replay,
+					reads
+				});
+				observe?.();
+				planReads = reads;
+			}
+			why = readsDiffer(planReads, tierReads, options);
+			if (why === void 0 && !readsUnknown(planReads)) compared = resolutions(planReads);
+		}
 		if (why !== void 0) return {
 			ok: false,
 			tier,
@@ -10044,10 +12319,15 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 			reason: why
 		};
 	}
-	return {
+	return compared === void 0 ? {
 		ok: true,
 		result,
 		effects: first.effects
+	} : {
+		ok: true,
+		result,
+		effects: first.effects,
+		reads: compared
 	};
 }
 //#endregion
@@ -10466,7 +12746,8 @@ const ORDER = [
 	"C7",
 	"C8",
 	"local",
-	"agree"
+	"agree",
+	"truth"
 ];
 /** A function in the results of the probe parts. It gives the count of its arguments. */
 const PROBE_FN = (...args) => args.length;
@@ -11344,14 +13625,41 @@ function examine(env, sample, contract) {
 	if (env.runner) for (const scenario of scenariosOf(env, sample, contract, true)) checkShot(env, sample, contract, scenario, shoot(env, code, sample, scenario));
 }
 /**
+* This function checks the declared truth of a profile (D86). The function `truthy` must give `true` or `false` for
+* each member of `truthType`, and it must not throw. The members come from the lists `values` of the domains of the
+* type. A type without such a list gets the values of the results of the palette that are its members.
+*/
+function checkTruth(env, code, probe) {
+	const truth = declaredTruthOf(code);
+	if (truth === void 0) return;
+	const domains = env.machine.domains;
+	if (typeIssues(truth.truthType, domains).length > 0) return;
+	const samples = env.results.flatMap((result) => result.ok ? [result.value] : []);
+	const of = (value) => `the member ${valueText(value)} of the truth type ${typeText(truth.truthType)}`;
+	for (const value of membersOf(truth.truthType, domains, samples)) {
+		let given;
+		try {
+			given = truth.truthy(value);
+		} catch (error) {
+			report(env, "truth", `The function truthy of the profile throws for ${of(value)}: ${describe(error)}`, () => probe(value));
+			return;
+		}
+		if (typeof given === "boolean") continue;
+		report(env, "truth", `The function truthy of the profile gives ${given === void 0 ? "no truth" : valueText(given)} for ${of(value)}. A truth is true or false.`, () => probe(value));
+		return;
+	}
+}
+/**
 * This function examines one evaluator or runner of a machine against the obligations of host code (K92, D36). It
 * starts the code directly, without the kernel, with probe parts and a probe runtime. It generates probe documents from
 * the contract of each kind that names the code, and it gives the probe parts chosen and random results.
 *
 * The checks follow the obligations C1 to C8 of `docs/SEMANTICS.md`. Two more checks follow the premises of the
 * simulation of the plan. The check `local` finds state that stays from one call to the next. The check `agree` compares
-* compiled code with its definition. The
-* finding of an obligation names the first probe that breaks it. An empty list means that each probe conforms.
+* compiled code with its definition. The finding of an obligation names the first probe that breaks it. An empty list
+* means that each probe conforms.
+*
+* The check `truth` tests the declared truth of a formula profile (D86).
 *
 * @param machine - The machine with the code and the world of the kinds.
 * @param name - The name of the evaluator or of the runner. A runner wins over an evaluator of the same name.
@@ -11382,14 +13690,34 @@ function conforms(machine, name, options = {}) {
 		found: /* @__PURE__ */ new Map()
 	};
 	const types = options.types ?? typesNaming(machine.world, name, verb);
+	let first;
 	if (types.length === 0) throw new Error(`No kind of the world names ${name} for the verb ${verb}. Give the types of the probe documents in the option types.`);
 	for (const type of types) {
 		const found = lookupKind(machine.world, type);
 		if (!found.ok) throw new Error(`The world has no kind for the type ${typeName(type)}.`);
 		const contract = contractOf(env, found.kind, found.path, options.caps);
 		const extra = own(options.values, typeName(type)) ?? own(options.values, found.path.join(".")) ?? [];
-		for (const sample of samplesOf(type, found.path, found.kind, contract, extra)) examine(env, sample, contract);
+		for (const sample of samplesOf(type, found.path, found.kind, contract, extra)) {
+			first ??= sample;
+			examine(env, sample, contract);
+		}
 	}
+	checkTruth(env, code, (value) => first === void 0 ? {
+		type: typeName(types[0]),
+		doc: {
+			type: types[0],
+			value: null
+		},
+		results: {},
+		waits: [],
+		caps: NO_CAPS,
+		running: runner
+	} : probeOf(first, {
+		results: first.split.parts.map(() => ok(value)),
+		waits: [],
+		caps: NO_CAPS,
+		running: runner
+	}));
 	return ORDER.filter((obligation) => env.found.has(obligation)).map((obligation) => env.found.get(obligation));
 }
 //#endregion
@@ -11494,6 +13822,22 @@ function verifyReads(target, reads, context, options = {}) {
 			read,
 			now: stop
 		};
+		if (read.kept === true) {
+			const now = keptAgain(machine, root, read.path);
+			if (now === void 0) return {
+				same: false,
+				index,
+				read,
+				now: fail("#N/A", "The host does not know the value of the kept read yet.")
+			};
+			if (!sameResult(read.reached, now, equal)) return {
+				same: false,
+				index,
+				read,
+				now
+			};
+			continue;
+		}
 		const asked = read.hops !== void 0;
 		const now = readAgain(machine, root, read.path, asked);
 		if (!sameResult(read.reached, now.reached, equal) || read.hops !== void 0 && !sameHops(read.hops, now.hops, equal)) return {
@@ -11766,7 +14110,7 @@ function cyclic(graph, members) {
 	return false;
 }
 /** This function gives the names of the nodes of a component, without the node `all`. */
-function named(graph, members) {
+function named$1(graph, members) {
 	const out = [];
 	for (const member of members) if (member !== graph.all) out.push(graph.ids[member]);
 	return out;
@@ -11805,7 +14149,7 @@ function components(graph, options = {}) {
 	const index = indexed(graph, options);
 	const out = [];
 	for (const members of strong(index).list) {
-		const names = named(index, members);
+		const names = named$1(index, members);
 		if (names.length > 0) out.push(names);
 	}
 	return out;
@@ -11912,7 +14256,7 @@ function cycles(graph) {
 	const out = [];
 	found.list.forEach((members, component) => {
 		if (!cyclic(every, members)) return;
-		const nodes = named(every, members);
+		const nodes = named$1(every, members);
 		const certain = inside.get(component) ?? [];
 		if (certain.length === 1 && certain[0]?.length === nodes.length) {
 			out.push({
@@ -11926,7 +14270,7 @@ function cycles(graph) {
 			certain: false
 		});
 		for (const part of certain) out.push({
-			nodes: named(eager, part),
+			nodes: named$1(eager, part),
 			certain: true
 		});
 	});
@@ -12168,10 +14512,12 @@ function schedule(machine, options = {}) {
 	};
 	/**
 	* This function gives the state of the current data epoch. Each data epoch has a new host thing at the root
-	* `world`. Thus a read that reaches the whole root changes at each change of data (READS.KEPT).
+	* `world`. Thus a read that reaches the whole root changes at each change of data (READS.KEPT). A kept read of a
+	* closure reads a node through `known`, without a demand (SCHED.CLOSURE).
 	*/
 	const current = () => {
 		if (now !== void 0) return now;
+		const values = /* @__PURE__ */ new Map();
 		const nodesThing = {
 			[THING]: true,
 			label: "nodes",
@@ -12183,14 +14529,20 @@ function schedule(machine, options = {}) {
 				return result.value;
 			},
 			has: (key) => docs.has(String(key)),
-			toJson: record
+			toJson: record,
+			known(key) {
+				const result = values.get(String(key));
+				if (result === void 0) return void 0;
+				if (!result.ok) throw new Failure(result.error);
+				return { thing: result.value };
+			}
 		};
 		now = {
 			context: rootContext(machine, {
 				...base,
 				world: nodesThing
 			}),
-			values: /* @__PURE__ */ new Map()
+			values
 		};
 		return now;
 	};
@@ -12265,6 +14617,406 @@ function schedule(machine, options = {}) {
 	};
 }
 //#endregion
+//#region src/meaning.ts
+/** A list of eight reference types. The generator then gives more references, thus more reads of nodes. */
+function moreRefs() {
+	return Array.from({ length: 8 }, () => ["ref"]);
+}
+/** The default options of the document generator, for `STD_MACHINE`. The kinds `log` and `write` need a capability. */
+function standardGenerate() {
+	return {
+		maxSize: 16,
+		types: [
+			...typesOf(STD_MACHINE.world).filter((type) => type[0] !== "log" && type[0] !== "write"),
+			...moreRefs(),
+			["if"],
+			["add"]
+		],
+		data: (type, rng) => {
+			const name = type.join(".");
+			if (name === "number") return rng.chance(.9) ? rng.pick([
+				0,
+				1,
+				2,
+				3.5,
+				-1
+			]) : "1";
+			if (name === "text") return rng.chance(.9) ? rng.pick([
+				"",
+				"a",
+				"b"
+			]) : 1;
+			if (name === "bool") return rng.chance(.9) ? rng.chance(.5) : 0;
+			if (name === "nearest") return rng.pick([{ type: "panel" }, "panel"]);
+		}
+	};
+}
+/** The default `wire`, for `STD_MACHINE`. A list evaluates each part, also after a failed part. */
+function standardWire(rng, node) {
+	if (rng.chance(.5)) return {
+		type: "list",
+		value: [node(), node()]
+	};
+	return rng.chance(.5) ? {
+		type: "add",
+		value: [node(), 1]
+	} : node();
+}
+/** The default values of the names of the host. Some are equal by structure, and some are host values. */
+function standardValues() {
+	return [
+		0,
+		1,
+		2,
+		-0,
+		NaN,
+		"two",
+		null,
+		void 0,
+		[1, 2],
+		{ a: 1 },
+		{ a: 2 },
+		{
+			type: "ref",
+			value: ["names", "a"]
+		},
+		new Held({
+			code: "#HELD",
+			reason: "The binding failed."
+		})
+	];
+}
+/** The default contexts of the host at the start of a run. */
+function standardContexts() {
+	return [context({
+		names: {
+			a: 1,
+			b: [1, "two"],
+			x: { a: 1 },
+			n: 2
+		},
+		caps: ["log"]
+	}), context({
+		names: {
+			a: "two",
+			b: 0,
+			x: null
+		},
+		self: { a: 1 },
+		event: { a: 2 }
+	})];
+}
+/** This function puts a field on a record, also the field `__proto__`. */
+function put(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+/** This function changes each path from `names` to a node into a path from `world`. Some paths read the whole root. */
+function linked(value, rng, nodes) {
+	if (Array.isArray(value)) {
+		const items = value.map((item) => linked(item, rng, nodes));
+		if (items[0] === "names" && typeof items[1] === "string" && nodes.includes(items[1])) return rng.chance(.03) ? ["world"] : ["world", ...items.slice(1)];
+		return items;
+	}
+	if (typeof value !== "object" || value === null) return value;
+	const out = {};
+	for (const key of Object.keys(value)) put(out, key, linked(value[key], rng, nodes));
+	return out;
+}
+/** This function gives new names of the host, with one or two changes. */
+function change(base, rng, names, values) {
+	const out = { ...base.names };
+	for (let step = 1 + rng.int(2); step > 0; step -= 1) {
+		const name = rng.pick(names);
+		if (rng.chance(.15)) delete out[name];
+		else out[name] = rng.pick(values);
+	}
+	return out;
+}
+function shuffle(items, rng) {
+	const out = [...items];
+	for (let index = out.length - 1; index > 0; index -= 1) {
+		const other = rng.int(index + 1);
+		[out[index], out[other]] = [out[other], out[index]];
+	}
+	return out;
+}
+/**
+* This function evaluates each node of a graph from scratch, with the meaning of D31. Each node gets a new plan and
+* one value. The algorithm of Tarjan over the demands finds the cycles. The function keeps nothing between calls.
+*/
+function fromScratch(machine, docs, base, declaredType) {
+	const declared = declaredType === void 0 ? {} : { declaredType };
+	const values = /* @__PURE__ */ new Map();
+	const index = /* @__PURE__ */ new Map();
+	const lowest = /* @__PURE__ */ new Map();
+	const component = [];
+	const evaluating = [];
+	const selfReads = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		const reader = evaluating[evaluating.length - 1];
+		const link = (to) => {
+			if (reader !== void 0) lowest.set(reader, Math.min(lowest.get(reader), to));
+		};
+		const done = values.get(id);
+		if (done !== void 0) {
+			if (component.includes(id)) link(index.get(id));
+			return done;
+		}
+		if (evaluating.includes(id)) {
+			link(index.get(id));
+			if (reader === id) selfReads.add(id);
+			return cycleOf(id);
+		}
+		if (factsOf(machine, docs.get(id), declared).side === "run") {
+			const refused = runSide(id);
+			values.set(id, refused);
+			return refused;
+		}
+		index.set(id, index.size);
+		lowest.set(id, index.get(id));
+		component.push(id);
+		evaluating.push(id);
+		let result = prepare(machine, docs.get(id), declared).evaluate(ctx);
+		evaluating.pop();
+		if (lowest.get(id) < index.get(id)) result = cycleOf(id);
+		else if (component.splice(component.indexOf(id)).length > 1 || selfReads.has(id)) result = cycleOf(id);
+		values.set(id, result);
+		link(lowest.get(id));
+		return result;
+	};
+	const world = {
+		[THING]: true,
+		label: "nodes",
+		deref: (key) => {
+			if (!docs.has(String(key))) return void 0;
+			const result = visit(String(key));
+			if (!result.ok) throw new Failure(result.error);
+			return result.value;
+		},
+		has: (key) => docs.has(String(key)),
+		toJson: () => {
+			const out = {};
+			for (const id of [...docs.keys()].sort()) {
+				if (factsOf(machine, docs.get(id), declared).side === "run") continue;
+				const result = visit(id);
+				if (!result.ok) throw new Failure(result.error);
+				put(out, id, result.value);
+			}
+			return out;
+		}
+	};
+	const ctx = {
+		...base,
+		world
+	};
+	for (const id of [...docs.keys()].sort()) visit(id);
+	return values;
+}
+/** This function names a result for the reason of a disagreement: its error code, or "a value". */
+function named(result) {
+	return result.ok ? "a value" : result.error.code;
+}
+/**
+* This function examines an engine of a host against an evaluation from scratch (SCHED.AGREES, R4 P4, D58). Each run
+* makes a new engine and a random graph of named nodes from the document generator. Then it gives random commands:
+* edits, new nodes, removed nodes, the same document again, new machines and changes of data.
+*
+* - Each read command evaluates the whole graph from scratch two times, with the meaning of D31.
+* - It then demands each node in a random order, or one node, and compares each answer with `sameResult`.
+* - A read whose answer from scratch differs between the two evaluations is not compared.
+* - Two errors agree when they have the same code, reason and place. Thus an engine gives the `#CYCLE!` and the
+*   `#REF!` of D31.
+*
+* The same seed and the same options give the same commands, thus a disagreement occurs again.
+*
+* @param engine - This function makes a new engine for each run, for example `schedule`.
+* @param options - The machines, the generator, the contexts, the number of runs and the rule for host values.
+* @returns What the harness reached, or the first read whose answer differs from the answer from scratch.
+*/
+function agreeSchedule(engine, options = {}) {
+	const machines = options.machines ?? [STD_MACHINE, { ...STD_MACHINE }];
+	const declaredType = options.declaredType;
+	const generateOptions = options.generate ?? standardGenerate();
+	const value = options.value ?? ((rng) => ({
+		type: "number",
+		value: rng.pick([
+			0,
+			1,
+			2
+		])
+	}));
+	const wire = options.wire ?? standardWire;
+	const wired = options.wired ?? .2;
+	const runs = options.runs ?? true;
+	const nodes = options.nodes ?? [
+		"p",
+		"q",
+		"r",
+		"s",
+		"t"
+	];
+	const hostNames = options.names ?? [
+		"a",
+		"b",
+		"x",
+		"n"
+	];
+	const hostValues = options.values ?? standardValues();
+	const contexts = options.contexts ?? standardContexts();
+	const total = options.count ?? 100;
+	const steps = options.steps ?? 30;
+	const first = options.seed ?? 9000011;
+	const given = options.equal;
+	const equal = (a, b) => {
+		const answer = given?.(a, b);
+		if (answer !== void 0) return answer;
+		if (isClosure(a) || isClosure(b)) return isClosure(a) && isClosure(b) && docEquals(closureParams(a), closureParams(b));
+	};
+	const counts = {
+		reads: 0,
+		compared: 0,
+		unrepeatable: 0,
+		values: 0,
+		cycles: 0,
+		runs: 0,
+		data: 0,
+		empty: 0,
+		edits: 0,
+		additions: 0,
+		removes: 0,
+		same: 0,
+		machines: 0
+	};
+	const declared = declaredType === void 0 ? {} : { declaredType };
+	for (let run = 0; run < total; run += 1) {
+		const seed = first + run;
+		const rng = random(seed);
+		const node = () => ({
+			type: "ref",
+			value: ["world", rng.pick(nodes)]
+		});
+		let at = 0;
+		let machine = machines[0];
+		let made = 0;
+		const make = () => {
+			if (rng.chance(wired)) return wire(rng, node);
+			const roll = rng.int(10);
+			if (roll === 0) return value(rng);
+			const names = roll < 5 ? hostNames : [
+				...hostNames,
+				...nodes,
+				...nodes,
+				...nodes
+			];
+			const doc = linked(generate(machine.world, {
+				...generateOptions,
+				names,
+				seed: seed * 31 + made++
+			}), rng, nodes);
+			return runs && roll === 9 ? {
+				type: "log",
+				value: [doc]
+			} : doc;
+		};
+		const docs = new Map(nodes.map((id) => [id, make()]));
+		const start = contexts[run % contexts.length];
+		let base = {
+			...start,
+			names: { ...start.names }
+		};
+		const host = engine(machine, {
+			...declared,
+			context: base
+		});
+		for (const [id, doc] of docs) host.set(id, doc);
+		for (let step = 0; step < steps; step += 1) {
+			const what = rng.int(12);
+			if (what < 4) {
+				const fresh = fromScratch(machine, docs, base, declaredType);
+				const again = fromScratch(machine, docs, base, declaredType);
+				const ids = shuffle([...docs.keys()], rng);
+				for (const id of rng.chance(.5) ? ids : ids.slice(0, 1)) {
+					const got = host.read(id);
+					const want = fresh.get(id);
+					counts.reads += 1;
+					if (!sameResult(want, again.get(id), equal)) {
+						counts.unrepeatable += 1;
+						continue;
+					}
+					counts.compared += 1;
+					if (sameResult(want, cycleOf(id))) counts.cycles += 1;
+					else if (sameResult(want, runSide(id))) counts.runs += 1;
+					else if (want.ok) counts.values += 1;
+					if (!sameResult(got, want, equal)) {
+						const reason = got.ok === want.ok && !got.ok ? `The engine and the evaluation from scratch give two different errors ${named(got)} and ${named(want)} for the node ${id}.` : `The engine gives ${named(got)} for the node ${id}, and the evaluation from scratch gives ${named(want)}.`;
+						return {
+							ok: false,
+							seed,
+							step,
+							node: id,
+							engine: got,
+							scratch: want,
+							docs: new Map(docs),
+							context: base,
+							machine,
+							reason,
+							counts: { ...counts }
+						};
+					}
+				}
+			} else if (what < 6) {
+				base = {
+					...base,
+					names: change(base, rng, hostNames, hostValues)
+				};
+				host.changeData(base);
+				counts.data += 1;
+			} else if (what === 6) {
+				host.changeData(base);
+				counts.empty += 1;
+			} else if (what < 9) {
+				const id = rng.pick(nodes);
+				const doc = make();
+				docs.set(id, doc);
+				host.set(id, doc);
+				counts.edits += 1;
+			} else if (what === 9) {
+				const absent = nodes.filter((id) => !docs.has(id));
+				if (absent.length > 0 && (docs.size <= 2 || rng.chance(.65))) {
+					const id = rng.pick(absent);
+					const doc = make();
+					docs.set(id, doc);
+					host.set(id, doc);
+					counts.additions += 1;
+				} else {
+					const id = rng.pick([...docs.keys()]);
+					docs.delete(id);
+					host.remove(id);
+					counts.removes += 1;
+				}
+			} else if (what === 10) {
+				const id = rng.pick([...docs.keys()]);
+				host.set(id, docs.get(id));
+				counts.same += 1;
+			} else if (host.changeMachine !== void 0) {
+				at = (at + 1) % machines.length;
+				machine = machines[at];
+				host.changeMachine(machine);
+				counts.machines += 1;
+			}
+		}
+	}
+	return {
+		ok: true,
+		counts
+	};
+}
+//#endregion
 //#region src/providers.ts
 /** The deepest schema that `typeFromSchema` reads. A deeper schema reads as `unknown`. */
 const MAX_SCHEMA_DEPTH = 256;
@@ -12575,6 +15327,6 @@ function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
 //#endregion
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, 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, agree, agreeRun, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, 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, 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, placed, planner, prepare, print, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, 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, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, 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, 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, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map