@mark1russell7/coeval 0.16.0 → 0.18.0

package/build/index.js

@@ -1,4 +1,4 @@
-//#region src/doc.ts
+// src/doc.ts
 /** The keys that an envelope can have. */
 const ENVELOPE_KEYS = [
 	"type",
@@ -240,8 +240,7 @@ function equalWith(a, b, rule) {
 	}
 	return true;
 }
-//#endregion
-//#region src/errors.ts
+// src/errors.ts
 /**
 * This function makes a result with a value.
 *
@@ -354,8 +353,7 @@ function describe(value) {
 		return "(a value without a text)";
 	}
 }
-//#endregion
-//#region src/world.ts
+// src/world.ts
 /**
 * This function gives the type of a bare equation of a kind (D42). It is the type `of` of the shape of its parts, or
 * else the type `of` of the shape `rest` of a record. The plan, the reference and `check` read it with this one function.
@@ -568,8 +566,7 @@ function kindDocument(name, kind) {
 function looksLikeKind(value) {
 	return isRecord(value) && isRecord(field(value, "verbs"));
 }
-//#endregion
-//#region src/types.ts
+// src/types.ts
 /**
 * The domains of the kernel. `unknown` and `never` are not domains: they are the top and the bottom of the types.
 * A machine that does not name one of these domains gets it from this table.
@@ -577,18 +574,22 @@ 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: {
 		is: (value) => typeof value === "number",
+		samples: [0, -1],
 		summary: "A number of the host, also NaN, an infinity and -0."
 	},
 	text: {
@@ -598,6 +599,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 +627,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 +645,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 +752,419 @@ 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 samples of the domains come after the given samples (D99).
+* 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, withDomainSamples(samples, domains), 0);
+}
+/**
+* This function adds the samples of the domains to a palette (D99). It reads the list `samples` of each domain of the
+* table and of each standard domain that the table does not replace. The result holds each value one time.
+*/
+function withDomainSamples(palette, domains) {
+	const out = [];
+	for (const value of palette) addValue(out, value);
+	const names = /* @__PURE__ */ new Set([...Object.keys(STD_DOMAINS), ...domains === void 0 ? [] : Object.keys(domains)]);
+	for (const name of names) {
+		const samples = domainOf(name, domains)?.samples;
+		if (Array.isArray(samples)) for (const value of samples) addValue(out, value);
+	}
+	return out;
+}
+/**
+* This function finds the false covers of a language from samples (D94). A cover is false when a sample of the covered
+* domain is in no domain of the cover. The function tests each valid cover of each domain of the table. It ignores a
+* cover that does not count by the line rule of D85, because `fits` ignores it too. It also ignores a sample outside
+* the covered domain.
+*
+* The samples of the domains come after the given samples (D99). `conforms` and a test of `fits` use the function. The
+* kernel does not export it.
+*
+* @param domains - The domains of the language, by their names.
+* @param samples - The samples of each covered domain, by the name of the domain.
+* @returns Each sample that breaks a cover, in the order of the domains, the covers and the samples.
+*/
+function falseCovers(domains, samples) {
+	const out = [];
+	for (const [name, domain] of Object.entries(domains)) {
+		const covers = domain.covers;
+		if (!Array.isArray(covers)) continue;
+		const values = withDomainSamples((Object.hasOwn(samples, name) ? samples[name] : void 0) ?? [], domains);
+		for (const cover of covers) {
+			if (!validCover(name, cover, domains)) continue;
+			for (const value of values) if (member(value, name, domains) && !cover.some((part) => member(value, part, domains))) out.push({
+				domain: name,
+				cover,
+				value
+			});
+		}
+	}
+	return out;
+}
+/** 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 a cover, and it tries each valid cover (D102). 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 covers = coversOf(inner.name, domains, false);
+				if (covers.length > 0) later.push({
+					path: [...path, key],
+					covers,
+					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 valid covers of a base type for a type split (D90, D102). The order is the order of the line,
+* then the order of the covers of each domain. With `own`, only the domain of the type itself counts.
+*/
+function coversOf(name, domains, own) {
+	const out = [];
+	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)) out.push(cover);
+	}
+	return out;
+}
+/**
+* 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 covers = form.t === "base" ? coversOf(form.name, domains, true) : [];
+	return covers.length === 0 ? [] : [{
+		path,
+		covers,
+		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.
+*
+* A cover split tries each valid cover of its field until one fits (D102). Each try takes from the same budget.
+*/
+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;
+	if (split.covers !== void 0) {
+		for (const cover of split.covers) {
+			const tried = [...splits];
+			tried[index] = {
+				path: split.path,
+				types: cover,
+				optional: split.optional
+			};
+			if (casesFit(type, closed, tried, index, expected, domains, depth, gradual, budget)) return true;
+		}
+		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 +1181,35 @@ 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 a 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 the
+*   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+* - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
+*   is the order of the line, then the order of the covers of each domain.
+*
+* 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. The
+* failed tries of covers take from these 64 records too. 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 +1220,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 +1239,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 +1345,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 +1568,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;
@@ -1211,8 +1624,7 @@ function typeIssues(type, domains) {
 	}
 	return issues;
 }
-//#endregion
-//#region src/merge.ts
+// src/merge.ts
 /** The exception of a merge with conflicts. It lists each conflict of the merge, not only the first. */
 var MergeError = class extends Error {
 	conflicts;
@@ -1233,7 +1645,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 +1662,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 +1671,39 @@ 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, samples 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),
+		samples: same(a.samples ?? null, b.samples ?? 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, list of values and samples, 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 +1716,22 @@ 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,
+			samples: found.samples,
+			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 +1781,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 +1805,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 +1960,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 +2084,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;
 }
 /**
@@ -1734,8 +2170,7 @@ function restrictMachine(machine, paths) {
 		...tables.domains === void 0 ? {} : { domains: tables.domains }
 	};
 }
-//#endregion
-//#region src/ladder.ts
+// src/ladder.ts
 /** The rungs of the ladder, in the order that a question visits them. */
 const RUNGS = [
 	"own",
@@ -1903,8 +2338,7 @@ function ask(world, doc, verb, options = {}) {
 		steps
 	};
 }
-//#endregion
-//#region src/deref.ts
+// src/deref.ts
 /**
 * The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
 * global symbol, thus two copies of the kernel in one program know the things of each other.
@@ -2043,11 +2477,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 +2720,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,20 +2833,19 @@ 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 deref = (thing, key) => {
-					const reached = derefStep(nav, thing, key);
-					return reached === void 0 ? void 0 : adopt(reached.thing);
-				};
+				const { deref, has } = walkSteps(nav);
 				const result = walker(hops === void 0 ? {
 					data: envelope.value,
 					here,
 					context: ctx,
-					deref
+					deref,
+					has
 				} : {
 					data: envelope.value,
 					here,
 					context: ctx,
 					deref,
+					has,
 					visit: (key, thing) => hops.push({
 						step: key,
 						thing,
@@ -2429,8 +2882,7 @@ function resolveFully$1(nav, ctx, path, hops, known) {
 function valueOfThing(thing) {
 	return isHostThing(thing) ? thing.toJson() : thing;
 }
-//#endregion
-//#region src/classify.ts
+// src/classify.ts
 function isStrictSuperset(larger, smaller) {
 	return larger.length > smaller.length && smaller.every((name) => larger.includes(name));
 }
@@ -2468,8 +2920,7 @@ function classify(shapes, value) {
 function tag(value, kind) {
 	return typed(kind, value);
 }
-//#endregion
-//#region src/parts.ts
+// src/parts.ts
 var Bad = class {
 	reason;
 	at;
@@ -2479,7 +2930,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,
@@ -2493,7 +2944,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 },
@@ -2602,7 +3053,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",
@@ -2614,14 +3065,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]);
@@ -2651,7 +3102,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;
 	};
@@ -2660,7 +3111,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 {
@@ -2803,8 +3254,7 @@ function scopesOf(rules, value, slots) {
 		later
 	};
 }
-//#endregion
-//#region src/evaluate.ts
+// src/evaluate.ts
 /**
 * This function makes a context with names and capabilities. The other roots are empty, and an evaluation sets
 * the world.
@@ -2918,10 +3368,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.
 */
@@ -2941,10 +3400,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.
@@ -2962,16 +3447,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)
 	};
 }
 /**
@@ -2981,8 +3476,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,
@@ -2990,7 +3485,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.
@@ -3019,7 +3514,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) };
 	}
 }
 /**
@@ -3124,7 +3619,7 @@ function keptPath(nav, root, path) {
 			} catch (error) {
 				return {
 					path: path.slice(0, index + 1),
-					reached: thrown(error, READ_FAILED)
+					reached: thrown(error, READ_FAILED$1)
 				};
 			}
 			if (step === void 0) return end(index);
@@ -3160,7 +3655,7 @@ function keptAgain(nav, ctx, path) {
 			try {
 				step = here.known(path[index]);
 			} catch (error) {
-				return thrown(error, READ_FAILED);
+				return thrown(error, READ_FAILED$1);
 			}
 			if (step === void 0) return void 0;
 			known = true;
@@ -3197,6 +3692,11 @@ var Session = class {
 	list;
 	tick = 0;
 	nextId = 0;
+	/**
+	* The count of the drives without a wait that are active at this time. In a run, an effect under such a drive does
+	* not reach the host (RUN.HELD).
+	*/
+	held = 0;
 	current;
 	holder;
 	/**
@@ -3255,7 +3755,7 @@ var Session = class {
 		} catch (error) {
 			reading.list.push({
 				path,
-				reached: thrown(error, READ_FAILED),
+				reached: thrown(error, READ_FAILED$1),
 				free
 			});
 			throw error;
@@ -3343,10 +3843,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 });
@@ -3404,6 +3904,11 @@ var Session = class {
 		if ("ok" in made) return made;
 		const perform = this.perform;
 		if (!this.running || perform === void 0) return this.answer(made, place);
+		if (this.held > 0) {
+			made.outcome = fail("#CALC!", heldReason(made.kind), { place });
+			yield HELD;
+			return made.outcome;
+		}
 		let done;
 		try {
 			done = perform(made);
@@ -3429,6 +3934,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;
@@ -3492,10 +3998,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();
@@ -3581,6 +4088,18 @@ function holderNode() {
 function waitedReason(kindText) {
 	return `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`;
 }
+/**
+* This function gives the reason of an effect that a run does not give to the host: the parent of its runner cannot
+* wait (RUN.HELD). The plan and the reference give the same reason.
+*
+* @param kind - The kind of the effect.
+* @returns The reason.
+*/
+function heldReason(kind) {
+	return `The parent of the runner cannot wait, thus the host does not get the effect ${typeof kind === "string" ? kind : kind.join(".")}.`;
+}
+/** The wait of an effect that a run does not give to the host. A drive without a wait stops at it (RUN.HELD). */
+const HELD = /* @__PURE__ */ Promise.resolve(void 0);
 /** This function drives steps that cannot wait. A step that waits stops the steps, and gives `#CALC!`. */
 function drive$2(steps, kindText) {
 	const step = steps.next();
@@ -4184,7 +4703,8 @@ function gated(rules, part) {
 		return {
 			...ctx,
 			caps,
-			[GRANT]: caps
+			[GRANT]: caps,
+			[EPOCH]: epochOf(ctx)
 		};
 	};
 	return {
@@ -4208,10 +4728,19 @@ function placedRun(inner, place, name) {
 /**
 * This function gives the code of a runner under a parent that cannot wait: its steps, driven without a wait. An
 * evaluation and a run both drive them (RUN.DRIVE-NESTED). Only a step that really waits gives `#CALC!`, at the place
-* of the runner, where the error started (RUN.WAIT).
+* of the runner, where the error started (RUN.WAIT). In a run, an effect under the runner does not reach the host,
+* because the parent cannot wait for its answer (RUN.HELD).
 */
 function runnerCode(run, place, kindText) {
-	return (ctx, rt) => placed(drive$2(run(ctx, rt), kindText), place);
+	return (ctx, rt) => {
+		if (!rt.running || !(rt instanceof Session)) return placed(drive$2(run(ctx, rt), kindText), place);
+		rt.held += 1;
+		try {
+			return placed(drive$2(run(ctx, rt), kindText), place);
+		} finally {
+			rt.held -= 1;
+		}
+	};
 }
 /** This function gives the steps of a run of an evaluator. The code runs at the first step, and it does not wait. */
 function runOf(code) {
@@ -4223,6 +4752,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 } : {};
@@ -4249,7 +4802,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
 		});
 	};
 }
@@ -4285,18 +4839,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
 	};
@@ -4518,8 +5081,7 @@ function flatten(trace) {
 function failures(trace) {
 	return flatten(trace).filter((node) => !node.result.ok && !node.children.some((child) => !child.result.ok && child.result.error === node.result.error)).map((node) => node.result.error);
 }
-//#endregion
-//#region src/stdlib.ts
+// src/stdlib.ts
 /**
 * The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
 * Each kind names an evaluator for `eval` and a view for `view`. The site draws each document with its view.
@@ -4736,6 +5298,158 @@ const STD_WORLD = {
 	},
 	defaults: { view: "view.card" }
 };
+/**
+* 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);
 }
@@ -4914,6 +5628,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;
@@ -5015,12 +5730,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");
@@ -5267,8 +5982,7 @@ const STD_MACHINE = {
 };
 /** The capabilities of the examples at the root: the two effects of the standard world. */
 const STD_CAPS = ["log", "write"];
-//#endregion
-//#region src/order.ts
+// src/order.ts
 /**
 * This function finds the references that a sequence cannot resolve. A step can read only the steps before it.
 *
@@ -5364,8 +6078,7 @@ function layers(steps) {
 	}
 	return result;
 }
-//#endregion
-//#region src/context.ts
+// src/context.ts
 /** The parts of a context. A term can reach outside itself only through these parts. */
 const PARTS = [
 	"self",
@@ -5653,8 +6366,7 @@ const CONSTRUCTS = [
 		}
 	}
 ];
-//#endregion
-//#region src/typing.ts
+// src/typing.ts
 /**
 * The value type of the root `caps`: a list of capabilities. A capability is a text, or a list of keys. The kernel
 * narrows the capabilities for each part, thus the host does not give this type.
@@ -5881,8 +6593,7 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 		places
 	};
 }
-//#endregion
-//#region src/static.ts
+// src/static.ts
 /** The names of a walk without names. A walk does not change a set at any time: it makes a new set to add names. */
 const NO_NAMES = /* @__PURE__ */ new Set();
 /** This function gives the options of a walk without the names of the host. */
@@ -6310,7 +7021,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;
@@ -6564,8 +7275,7 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 	}
 	return issues;
 }
-//#endregion
-//#region src/facts.ts
+// src/facts.ts
 /** The lazy rules that cover each part: the rules of a document whose evaluator the contract does not describe. */
 const EACH$1 = "each";
 /** An empty list. One frozen list serves each empty list of the facts, thus a store of many facts keeps less (PLAN.LEAN). */
@@ -6632,9 +7342,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
@@ -6658,7 +7370,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();
@@ -6666,98 +7377,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,
@@ -6767,8 +7504,7 @@ function factsOf(machine, doc, options = {}) {
 		size
 	};
 }
-//#endregion
-//#region src/effects.ts
+// src/effects.ts
 /** Each capability: one capability with no keys. It permits each effect, because each kind starts with no keys (CAP.KEYS). */
 const EACH = /* @__PURE__ */ Object.freeze([[]]);
 /**
@@ -6848,8 +7584,7 @@ function checkLatent(machine, declared, body, options = {}) {
 	}
 	return issues;
 }
-//#endregion
-//#region src/codec.ts
+// src/codec.ts
 /** This function gives the codec of a domain, or `undefined` when the domain has no codec. */
 function codecOf(domain) {
 	const codec = domain.codec;
@@ -6896,7 +7631,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,
@@ -6971,7 +7706,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
@@ -7020,8 +7755,7 @@ function encodeValue(machine, value) {
 function decodeValue(machine, doc) {
 	return prepare(machine, doc, { declaredType: "lit" }).evaluate(makeContext());
 }
-//#endregion
-//#region src/formula.ts
+// src/formula.ts
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED = /* @__PURE__ */ Symbol("skipped");
 /** The value of a name whose binding failed. A reference to the name gives the error. */
@@ -7067,7 +7801,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,
@@ -7281,11 +8015,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`, `sigs` and `extTypes`.
 */
 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) => {
@@ -7321,10 +8072,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"] };
@@ -7373,7 +8121,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,
@@ -7396,7 +8144,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) ? {} : {
@@ -7412,7 +8160,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) ? {} : {
@@ -7468,10 +8216,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`
@@ -7525,7 +8270,13 @@ function formulaTypes(profile) {
 		},
 		"formula.ext": { synth: (input) => {
 			const name = nameOf(input);
-			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return "unknown";
+			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) {
+				const types = profile.extTypes;
+				const declared = types !== void 0 && Object.hasOwn(types, name) ? types[name] : void 0;
+				if (declared === void 0) return "unknown";
+				const type = input.contract(declared, `type of ext.${name} in extTypes`);
+				return typeIssues(type, input.machine.domains).length > 0 ? "unknown" : type;
+			}
 			if (name === "undefined") return "undefined";
 			if (name === "number") return "number";
 			return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
@@ -7545,18 +8296,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);
 }
@@ -7565,7 +8342,9 @@ const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
 	"ops",
 	"lazy",
 	"ext",
+	"extTypes",
 	"truthy",
+	"truthType",
 	"otherwise",
 	"logic",
 	"omit",
@@ -7750,7 +8529,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);
 				};
@@ -7763,7 +8542,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);
 			};
@@ -7780,7 +8559,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,
@@ -7811,7 +8590,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
@@ -8079,12 +8858,12 @@ function formulaMachine(profile = {}, more = {}) {
 		facts: kit.facts
 	}, more);
 }
-//#endregion
-//#region src/syntax.ts
+// src/syntax.ts
 /**
 * 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: [
@@ -8214,7 +8993,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;
@@ -8232,6 +9012,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(".");
@@ -8287,6 +9073,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;
@@ -8301,13 +9118,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);
@@ -8319,6 +9145,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,
@@ -8335,6 +9162,7 @@ function compileProfile(profile) {
 		forms,
 		formsByKind,
 		separator,
+		bind: compileBind(profile.header?.bind, separator, ops.binary),
 		reserved: /* @__PURE__ */ new Set([
 			...words.keys(),
 			...ops.opWords,
@@ -8361,6 +9189,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 = {
 	"\"": "\"",
 	"'": "'",
@@ -8384,10 +9243,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;
@@ -8409,6 +9268,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;
@@ -8541,7 +9454,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);
@@ -8591,6 +9504,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;
@@ -8606,7 +9524,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;
@@ -8616,14 +9534,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;
@@ -8631,22 +9553,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);
 		}
@@ -8725,8 +9680,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) {
@@ -8740,18 +9697,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) {
@@ -8760,13 +9722,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) {
+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: 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])
+			args: value.map((item, index) => [
+				index,
+				item,
+				wraps(form, index)
+			])
 		};
 	}
 	if (!isRecord(value)) return void 0;
@@ -8776,7 +9783,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) {
@@ -8789,7 +9800,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;
@@ -8810,7 +9830,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;
@@ -8823,7 +9843,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) {
@@ -8853,18 +9873,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).
@@ -8877,7 +9921,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;
@@ -8895,7 +9939,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();
@@ -8908,8 +9954,7 @@ function syntaxFormat(profile) {
 		evaluators: { "syntax.format": code }
 	};
 }
-//#endregion
-//#region src/reference.ts
+// src/reference.ts
 function own$1(table, name) {
 	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
 }
@@ -9016,6 +10061,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
@@ -9047,6 +10140,11 @@ function* causeAndWait(env, ctx, kind, payload, place) {
 	if ("ok" in effect) return effect;
 	const perform = env.perform;
 	if (perform === void 0) return effect.outcome = ok(payload);
+	if (env.held > 0) {
+		effect.outcome = fail("#CALC!", heldReason(kind), { place });
+		yield Promise.resolve(void 0);
+		return effect.outcome;
+	}
 	let given;
 	try {
 		given = perform(effect);
@@ -9116,7 +10214,15 @@ function evaluateSeen(env, seen, at) {
 	const { chosen } = seen;
 	const { place } = at;
 	if ("gap" in chosen) return fail("#NOEVAL", chosen.gap, { place });
-	if ("runner" in chosen) return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+	if ("runner" in chosen) {
+		if (!env.running) return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+		env.held += 1;
+		try {
+			return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+		} finally {
+			env.held -= 1;
+		}
+	}
 	const input = evalInput(env, seen, at);
 	try {
 		return placed(chosen.evaluator(input), place);
@@ -9170,7 +10276,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
 	};
@@ -9197,7 +10303,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
@@ -9226,6 +10332,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;
@@ -9289,10 +10396,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();
@@ -9319,9 +10427,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"), []);
 	}
@@ -9342,11 +10458,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,
@@ -9361,7 +10481,12 @@ function envOf(machine, options, running) {
 			prefix: "",
 			counts: /* @__PURE__ */ new Map(),
 			alls: 0
-		}
+		},
+		held: 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. */
@@ -9436,7 +10561,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;
@@ -9447,10 +10573,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];
@@ -9696,10 +10822,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);
@@ -9855,25 +10984,27 @@ function valuesOfStrict(parts) {
 	}
 	return { values };
 }
-//#endregion
-//#region src/replay.ts
+// src/replay.ts
 /**
 * This function makes a recorder (RUN.RECORD). The recorder gives each effect to the function `perform` of the host.
 * 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,
@@ -9903,14 +11034,17 @@ function recorder(perform) {
 * 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).
 *
-* A replayer keeps its place in the order of the waits, thus each run needs a new replayer.
+* 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.
-* @param options - `wait: false` for an evaluation.
+* @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();
@@ -9919,16 +11053,19 @@ function replayer(log, options = {}) {
 		if (items === void 0) order.set(settle.all, [settle.item]);
 		else items.push(settle.item);
 	}
-	const journal = { next: (all, waiting) => {
+	let places;
+	const journal = { next: (all, waiting, before) => {
 		const items = order.get(all);
-		const item = items?.[0];
-		if (items === void 0 || item === void 0 || !waiting.includes(item)) return void 0;
-		items.shift();
+		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);
+		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);
@@ -9940,59 +11077,998 @@ function replayer(log, options = {}) {
 	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) {
+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 (!docEquals(entry.payload, effect.payload)) return replayError(effect, `The effect ${effect.kind} at the address ${at} has another payload than the log.`);
+	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);
 }
-//#endregion
-//#region src/agree.ts
-/** The tiers that `agree` compares when its options name none. */
-const DEFAULT_TIERS = /* @__PURE__ */ Object.freeze([
-	"reference",
-	"traced",
-	"again",
-	"folds",
-	"fixed"
-]);
 /**
-* This function tells if two values are the same for `agree`. Lists and plain records compare item by item and field
-* by field, and the order of the fields does not matter. Each other leaf compares with `Object.is`, thus `-0` is not
-* `0`, and `NaN` is `NaN`. The identity of a list or of a plain record is not compared.
-*
-* Two closures of `fn` are the same when they have the same parameters. Two `Held` values are the same when their
-* errors have the same code and place. Each other object is the same only as itself, unless the rule of the caller
-* tells otherwise.
+* 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.
 *
-* `docEquals` and `sameResult` use the same walk (D20). `docEquals` has no rules for closures, for `Held` values and
-* for a rule of the caller. `sameResult` is for an early cutoff, thus a closure is the same there only as itself, and
-* two errors also need the same reason.
-*
-* @param a - The first value.
-* @param b - The second value.
-* @param equal - The rule of the caller for other values. It answers first, and `undefined` gives the rules above.
-* @returns `true` when the values are the same.
+* @param perform - The inner function.
+* @param settled - The function of its own.
+* @returns The journal.
 */
-function sameValue(a, b, equal) {
-	return equalWith(a, b, equal === void 0 ? sameInTiers : (x, y) => equal(x, y) ?? sameInTiers(x, y));
+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)
+	};
 }
-/** The rules of `sameValue` for the values that two tiers make again: closures and held errors. */
-function sameInTiers(x, y) {
-	if (isClosure(x) || isClosure(y)) return isClosure(x) && isClosure(y) && docEquals(closureParams(x), closureParams(y));
-	if (x instanceof Held || y instanceof Held) return x instanceof Held && y instanceof Held && errorDiffers(x.error, y.error, false) === void 0;
+/** 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";
 }
-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;
+/** 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";
 }
-function codeAndPlace(error) {
-	return error.place === void 0 ? error.code : `${error.code} at [${error.place.join(", ")}]`;
+/** 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 gives the lists and the plain records that the walk of `causeJson` keeps as containers of parts, also
+* with a term document (D101). Such a container is at two places of the walk, or it holds such a container at some depth.
+* It reads the values as the walk does: the fields of an exception, its hidden fields and its cause, and the items of a
+* container. A term document gives a copy at each place, thus a shared container cannot be one.
+*/
+function sharedOf(root) {
+	const seen = /* @__PURE__ */ new Set();
+	const twice = [];
+	const owners = /* @__PURE__ */ new Map();
+	const stack = [[root, void 0]];
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+		const [at, owner] = next;
+		if (typeof at !== "object" || at === null) continue;
+		const container = Array.isArray(at) || isRecord(at);
+		if (!container && !(at instanceof Error)) continue;
+		if (container && owner !== void 0) {
+			const list = owners.get(at);
+			if (list === void 0) owners.set(at, [owner]);
+			else list.push(owner);
+		}
+		if (seen.has(at)) {
+			if (container) twice.push(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), at]);
+		} else if (container) for (const key of Object.keys(at)) stack.push([readField(at, key), at]);
+		else {
+			for (const key of Object.keys(at)) if (!ownField(key)) stack.push([readField(at, key), void 0]);
+			for (const key of HIDDEN) if (Object.getOwnPropertyDescriptor(at, key)?.enumerable === false) stack.push([readField(at, key), void 0]);
+			if (Object.hasOwn(at, "cause")) stack.push([readField(at, "cause"), void 0]);
+		}
+	}
+	const shared = /* @__PURE__ */ new Set();
+	for (let at = twice.pop(); at !== void 0; at = twice.pop()) {
+		if (shared.has(at)) continue;
+		shared.add(at);
+		for (const owner of owners.get(at) ?? []) twice.push(owner);
+	}
+	return shared;
+}
+/**
+* This function tells if the walk of `causeJson` keeps a value with a term document as a container of parts (D101). The
+* value is in the set of `sharedOf`. A member of a domain stays a term document, because its codec makes it again.
+*/
+function wholeOf(shared, value, term) {
+	if (typeof value !== "object" || value === null || !shared.has(value)) return false;
+	const type = isRecord(term) ? term["type"] : void 0;
+	return !(Array.isArray(type) && type[0] === "ext" && type[1] === "domain");
+}
+/**
+* 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 container cause of an error value 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). The cause of an error value
+* is a container only when it holds an exception (D87). The cause of an exception is a container as a field is (D100).
+* 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). A container
+* of `sharedOf` is a container of parts also with a term document, thus each share gives one object (D101). The value
+* `tried` marks a root that `encodeValue` cannot write. The walk is a loop, thus a long chain does not overflow the stack.
+*/
+function causeJson(machine, root, shared, tried) {
+	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,
+				true
+			]);
+			else if (wholeOf(shared, value, term)) linked.push([
+				key,
+				value,
+				false
+			]);
+			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, without] = linked[place];
+			const put = (part) => {
+				node.parts[place] = part;
+			};
+			children.push({
+				value,
+				name: key,
+				tried: without,
+				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: true,
+				keep: false,
+				put
+			});
+		}
+		later(children);
+		return at;
+	};
+	let top = { none: "cause" };
+	tasks.push({
+		value: root,
+		name: "cause",
+		tried,
+		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 container = Array.isArray(value) || isRecord(value);
+		const held = container ? holders.get(value) : void 0;
+		if (held !== void 0) {
+			if (task.keep) items[held].keep = true;
+			task.put({
+				same: held,
+				name: task.name
+			});
+			continue;
+		}
+		const term = task.tried || task.keep ? void 0 : termOrNothing(machine, value);
+		const whole = term !== void 0 && wholeOf(shared, value, term);
+		if (term !== void 0 && !whole) task.put({ value: term });
+		else if (value instanceof Error) task.put({ node: open(value) });
+		else if (container && (whole || task.nest || holdsException(value))) {
+			const children = [];
+			task.put({ holder: hold(task.name, value, task.keep || whole, children) });
+			later(children);
+		} 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;
+	const shared = sharedOf(cause);
+	let term;
+	let failure;
+	try {
+		term = encodeValue(machine, cause);
+	} catch (thrown) {
+		failure = thrown;
+	}
+	if (term !== void 0 && !wholeOf(shared, cause, term)) return {
+		...base,
+		cause: term
+	};
+	const { link, names } = causeJson(machine, cause, shared, term === void 0);
+	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.
+* - The cause of an exception is also in `causeParts` without an exception in it, when an item has a form
+*   (RUN.REPLAY-CAUSE-ITEMS, D100). Each item without a form is a name in `dropped`, for example `cause.send`.
+* - 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.
+* - A list or a plain record with a term document that two places of one error share is a container of parts
+*   (RUN.REPLAY-SHARED-VALUES, D101). Each later place is a share. A member of a domain stays a term document.
+* - 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).
+*
+* @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 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 }
+	};
+	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
+	});
+}
+// src/agree.ts
+/** The tiers that `agree` compares when its options name none. */
+const DEFAULT_TIERS = /* @__PURE__ */ Object.freeze([
+	"reference",
+	"traced",
+	"again",
+	"folds",
+	"fixed"
+]);
+/**
+* This function tells if two values are the same for `agree`. Lists and plain records compare item by item and field
+* by field, and the order of the fields does not matter. Each other leaf compares with `Object.is`, thus `-0` is not
+* `0`, and `NaN` is `NaN`. The identity of a list or of a plain record is not compared.
+*
+* Two closures of `fn` are the same when they have the same parameters. Two `Held` values are the same when their
+* errors have the same code and place. Each other object is the same only as itself, unless the rule of the caller
+* tells otherwise.
+*
+* `docEquals` and `sameResult` use the same walk (D20). `docEquals` has no rules for closures, for `Held` values and
+* for a rule of the caller. `sameResult` is for an early cutoff, thus a closure is the same there only as itself, and
+* two errors also need the same reason.
+*
+* @param a - The first value.
+* @param b - The second value.
+* @param equal - The rule of the caller for other values. It answers first, and `undefined` gives the rules above.
+* @returns `true` when the values are the same.
+*/
+function sameValue(a, b, equal) {
+	return equalWith(a, b, equal === void 0 ? sameInTiers : (x, y) => equal(x, y) ?? sameInTiers(x, y));
+}
+/** The rules of `sameValue` for the values that two tiers make again: closures and held errors. */
+function sameInTiers(x, y) {
+	if (isClosure(x) || isClosure(y)) return isClosure(x) && isClosure(y) && docEquals(closureParams(x), closureParams(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;
+}
+function codeAndPlace(error) {
+	return error.place === void 0 ? error.code : `${error.code} at [${error.place.join(", ")}]`;
 }
 /** This function gives the difference of two errors, or `undefined` when they agree. */
 function errorDiffers(a, b, strict) {
@@ -10221,18 +12297,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);
@@ -10254,6 +12324,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
@@ -10262,6 +12408,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.
@@ -10285,17 +12438,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) {
 		if (tier === "fixed") continue;
-		const replay = watched(replayer(log));
-		const host = { perform: replay.perform };
+		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;
@@ -10307,7 +12467,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,
@@ -10316,14 +12489,18 @@ 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
-//#region src/generate.ts
+// src/generate.ts
 /**
 * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
 *
@@ -10725,8 +12902,7 @@ function generate(world, options) {
 		hint: void 0
 	});
 }
-//#endregion
-//#region src/conform.ts
+// src/conform.ts
 /** The order of the obligations in the list of findings. */
 const ORDER = [
 	"C1",
@@ -10738,7 +12914,9 @@ const ORDER = [
 	"C7",
 	"C8",
 	"local",
-	"agree"
+	"agree",
+	"truth",
+	"cover"
 ];
 /** A function in the results of the probe parts. It gives the count of its arguments. */
 const PROBE_FN = (...args) => args.length;
@@ -11616,14 +13794,58 @@ 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 its members from the results of the palette and from the samples of the
+* domains (D99).
+*/
+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 checks the covers of the domains of the machine from samples (D94). Each sample of a covered domain
+* must be in one domain of each valid cover. The samples of a domain come from its list `values`. A domain without
+* that list gets its members from the palette and from the samples of the domains, as for the check `truth`.
+*/
+function checkCovers(env, probe) {
+	const domains = env.machine.domains;
+	if (domains === void 0) return;
+	const palette = env.results.flatMap((result) => result.ok ? [result.value] : []);
+	const samples = {};
+	for (const [name, domain] of Object.entries(domains)) if (domain.covers !== void 0) samples[name] = membersOf(name, domains, palette);
+	const found = falseCovers(domains, samples)[0];
+	if (found === void 0) return;
+	report(env, "cover", `The member ${valueText(found.value)} of the domain ${found.domain} is in no domain of its cover ${found.cover.join(", ")}. The check of types trusts the cover, thus it is unsound for ${found.domain}.`, () => probe(found.value));
+}
+/**
 * 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). The check `cover` tests the covers of the
+* domains of the machine from samples (D94).
 *
 * @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.
@@ -11654,18 +13876,39 @@ 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);
+		}
 	}
+	const probeWith = (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
+	});
+	checkTruth(env, code, probeWith);
+	checkCovers(env, probeWith);
 	return ORDER.filter((obligation) => env.found.has(obligation)).map((obligation) => env.found.get(obligation));
 }
-//#endregion
-//#region src/same.ts
+// src/same.ts
 /**
 * This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
 * work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
@@ -11701,8 +13944,7 @@ function sameError(a, b) {
 	if (a.place === void 0 || b.place === void 0) return a.place === b.place;
 	return docEquals(a.place, b.place);
 }
-//#endregion
-//#region src/reads.ts
+// src/reads.ts
 /** One answer serves each list whose reads are all the same. */
 const SAME = /* @__PURE__ */ Object.freeze({ same: true });
 /** This function tells if two lists of hops are the same: the same steps, rungs and things, in order. */
@@ -11793,8 +14035,7 @@ function verifyReads(target, reads, context, options = {}) {
 	}
 	return SAME;
 }
-//#endregion
-//#region src/durable.ts
+// src/durable.ts
 /** The most values that a cache of value documents keeps, as in `planner`. */
 const MAX_VALUES = 1e3;
 /** No reads. One frozen list serves each result of a pure document without reads. */
@@ -11934,8 +14175,7 @@ function durable(machine, options = {}) {
 		}
 	};
 }
-//#endregion
-//#region src/graph.ts
+// src/graph.ts
 /** This function gives the indexed form of a graph, with the edges that the options keep. */
 function indexed(graph, options) {
 	const eager = options.eager === true;
@@ -12265,8 +14505,7 @@ function deepestFirst(from, edgesOf) {
 	}
 	return out;
 }
-//#endregion
-//#region src/schedule.ts
+// src/schedule.ts
 /**
 * This function gives the edges of a node from the static facts of its document (SCHED.EDGES). Each read of the root
 * `world` is an edge to the node of its first key. The keys after that key are the field of the edge (SCHED.GRAIN).
@@ -12560,8 +14799,7 @@ function schedule(machine, options = {}) {
 		}
 	};
 }
-//#endregion
-//#region src/meaning.ts
+// 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"]);
@@ -12960,8 +15198,7 @@ function agreeSchedule(engine, options = {}) {
 		counts
 	};
 }
-//#endregion
-//#region src/providers.ts
+// src/providers.ts
 /** The deepest schema that `typeFromSchema` reads. A deeper schema reads as `unknown`. */
 const MAX_SCHEMA_DEPTH = 256;
 /** The keywords that describe a schema and do not test a value. The reading ignores them without an issue. */
@@ -13270,7 +15507,6 @@ function samplesAt(values, closed, depth) {
 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, agreeSchedule, 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, 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 };
+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