@mark1russell7/coeval 0.7.0 → 0.8.0

package/build/index.js

@@ -357,6 +357,17 @@ function describe(value) {
 //#endregion
 //#region 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.
+*
+* @param kind - The kind.
+* @returns The type, or `undefined` when the shape declares none.
+*/
+function equationType(kind) {
+	const parts = kind.parts;
+	return parts?.of ?? parts?.rest?.of;
+}
+/**
 * This function tells if an entry of the world is a kind.
 *
 * @param entry - The entry.
@@ -759,7 +770,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$4(target, key, value) {
+function setOwn$5(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -778,10 +789,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$4(fields, key, joinAt(a.fields[key], b.fields[key], domains, depth));
+			setOwn$5(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$4(fields, key, inA ? a.fields[key] : b.fields[key]);
+			setOwn$5(fields, key, inA ? a.fields[key] : b.fields[key]);
 			optional.push(key);
 		}
 	}
@@ -1185,7 +1196,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$3(target, key, value) {
+function setOwn$4(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -1202,7 +1213,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$3(out, key, defined(value[key]));
+	for (const key of Object.keys(value)) if (value[key] !== void 0) setOwn$4(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. */
@@ -1247,7 +1258,7 @@ function extendDomain(name, more) {
 			...Object.keys(steps).length === 0 ? {} : { steps }
 		};
 		const domains = {};
-		setOwn$3(domains, name, domain);
+		setOwn$4(domains, name, domain);
 		return {
 			domains,
 			replaces: [["domains", name]]
@@ -1297,10 +1308,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$3(table, key, later);
+		setOwn$4(table, key, later);
 		m.give(path, part);
 	} else if (replaces.has(keyOf(path))) {
-		setOwn$3(table, key, later);
+		setOwn$4(table, key, later);
 		m.replace(path, part);
 	} else if (!equal(earlier, later)) m.clash(path, part, reason);
 }
@@ -1321,9 +1332,9 @@ function mergeEntries(m, into, from, path, part, replaces) {
 		const at = [...path, key];
 		const earlier = own$2(into, key);
 		if (earlier === void 0) {
-			setOwn$3(into, key, later);
+			setOwn$4(into, key, later);
 			m.give(at, part);
-		} else setOwn$3(into, key, mergeEntry(m, earlier, later, at, part, replaces));
+		} else setOwn$4(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. */
@@ -1476,8 +1487,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$3(draft.evaluators, name, evaluator);
-			if (runner !== void 0) setOwn$3(draft.runners ??= {}, name, runner);
+			else setOwn$4(draft.evaluators, name, evaluator);
+			if (runner !== void 0) setOwn$4(draft.runners ??= {}, name, runner);
 			else if (draft.runners !== void 0) delete draft.runners[name];
 			m.replace(evaluatorPath, index);
 			m.replace(runnerPath, index);
@@ -1600,7 +1611,7 @@ function removeEntry(entries, path) {
 	}
 	const out = { ...entries };
 	if (next === void 0) delete out[key];
-	else setOwn$3(out, key, next);
+	else setOwn$4(out, key, next);
 	return out;
 }
 /**
@@ -1694,7 +1705,7 @@ const RUNGS = [
 	"kind",
 	"default"
 ];
-function entryOf(verbs, verb) {
+function entryOf$1(verbs, verb) {
 	return verbs !== void 0 && Object.hasOwn(verbs, verb) ? verbs[verb] : void 0;
 }
 /**
@@ -1735,18 +1746,18 @@ const EACH_NAME = () => true;
 * @returns The evaluator name and its rung, or `undefined` when no rung answers.
 */
 function answerOf(world, own, kind, verb, has = EACH_NAME) {
-	const ownName = entryOf(own, verb);
+	const ownName = entryOf$1(own, verb);
 	if (ownName !== void 0 && has(ownName)) return {
 		name: ownName,
 		rung: "own"
 	};
 	if (kind === null) return void 0;
-	const kindName = kind === void 0 ? void 0 : entryOf(kind.verbs, verb);
+	const kindName = kind === void 0 ? void 0 : entryOf$1(kind.verbs, verb);
 	if (kindName !== void 0 && has(kindName)) return {
 		name: kindName,
 		rung: "kind"
 	};
-	const fallback = entryOf(world.defaults, verb);
+	const fallback = entryOf$1(world.defaults, verb);
 	return fallback !== void 0 && has(fallback) ? {
 		name: fallback,
 		rung: "default"
@@ -1768,7 +1779,7 @@ function answerOf(world, own, kind, verb, has = EACH_NAME) {
 */
 function ask(world, doc, verb, options = {}) {
 	const steps = [];
-	const own = entryOf(doc.own, verb);
+	const own = entryOf$1(doc.own, verb);
 	if (own !== void 0) {
 		steps.push({
 			rung: "own",
@@ -1808,7 +1819,7 @@ function ask(world, doc, verb, options = {}) {
 				steps
 			};
 		}
-		const entry = entryOf(kind.verbs, verb);
+		const entry = entryOf$1(kind.verbs, verb);
 		if (entry !== void 0) {
 			steps.push({
 				rung: "kind",
@@ -1831,7 +1842,7 @@ function ask(world, doc, verb, options = {}) {
 			source
 		});
 	}
-	const fallback = entryOf(world.defaults, verb);
+	const fallback = entryOf$1(world.defaults, verb);
 	if (fallback !== void 0) {
 		steps.push({
 			rung: "default",
@@ -2412,7 +2423,7 @@ var Bad = class {
 	}
 };
 /** 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,
@@ -2584,7 +2595,7 @@ function splitParts(shape, value) {
 		const out = {};
 		for (const [key, child] of node.fields) {
 			const kept = strip(child);
-			if (kept !== void 0) setOwn$2(out, key, kept);
+			if (kept !== void 0) setOwn$3(out, key, kept);
 		}
 		return out;
 	};
@@ -2593,7 +2604,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$2(out, key, fillWith(child, handles));
+		for (const [key, child] of node.fields) setOwn$3(out, key, fillWith(child, handles));
 		return out;
 	};
 	return {
@@ -2667,6 +2678,75 @@ function pathMatches(path, pattern) {
 	}
 	return true;
 }
+function valueAt(value, path) {
+	let here = value;
+	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
+	else if (isRecord(here) && Object.hasOwn(here, String(key))) here = here[String(key)];
+	else return void 0;
+	return here;
+}
+function headerName(item) {
+	return isEnvelope(item) && typeof item.name === "string" ? item.name : void 0;
+}
+function namesOf(source, value, covered) {
+	if ("fixed" in source) return source.fixed;
+	if ("keysAt" in source) {
+		const at = valueAt(value, source.keysAt);
+		return isRecord(at) ? Object.keys(at) : [];
+	}
+	if ("listAt" in source) {
+		const at = valueAt(value, source.listAt);
+		return Array.isArray(at) ? at.filter((item) => typeof item === "string") : [];
+	}
+	if ("textAt" in source) {
+		const at = valueAt(value, source.textAt);
+		if (typeof at === "string") return [at];
+		return source.otherwise === void 0 ? [] : [source.otherwise];
+	}
+	return covered.map((slot) => headerName(slot.item)).filter((name) => name !== void 0);
+}
+/**
+* This function gives the names that the scope rules of a kind give each part, and the names that only later parts
+* see. `check`, `conforms` and the plan read the scope rules with it.
+*
+* @param rules - The scope rules of the kind.
+* @param value - The value of the document.
+* @param slots - The parts of the value, in order.
+* @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
+*/
+function scopesOf(rules, value, slots) {
+	const sees = slots.map(() => []);
+	const later = slots.map(() => []);
+	for (const rule of rules ?? []) {
+		const covered = slots.map((slot, index) => ({
+			slot,
+			index
+		})).filter(({ slot }) => rule.in.some((pattern) => pathMatches(slot.path, pattern)));
+		if (rule.sequential !== true) {
+			const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+			for (const { index } of covered) sees[index]?.push(...names);
+			continue;
+		}
+		if ("headers" in rule.names) {
+			covered.forEach(({ index }, position) => {
+				const before = covered.slice(0, position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
+				const after = covered.slice(position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
+				sees[index]?.push(...before);
+				later[index]?.push(...after);
+			});
+			continue;
+		}
+		const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+		covered.forEach(({ index }, position) => {
+			if (position > 0) sees[index]?.push(...names);
+			else later[index]?.push(...names);
+		});
+	}
+	return {
+		sees,
+		later
+	};
+}
 //#endregion
 //#region src/evaluate.ts
 /**
@@ -2727,7 +2807,7 @@ function narrow(parent, next) {
 	};
 }
 /** No capabilities. One list serves each masked part. */
-const NO_CAPS$1 = /* @__PURE__ */ Object.freeze([]);
+const NO_CAPS$2 = /* @__PURE__ */ Object.freeze([]);
 /** No capability rules. One list serves each part that no rule narrows. */
 const NO_RULES = /* @__PURE__ */ Object.freeze([]);
 /**
@@ -2755,7 +2835,7 @@ function rulesFor(rules, path) {
 function capsUnder(rules, caps) {
 	let out = caps;
 	for (const rule of rules) {
-		if (rule.rule === "mask") return NO_CAPS$1;
+		if (rule.rule === "mask") return NO_CAPS$2;
 		if (rule.rule === "only") out = intersectCaps(out, rule.caps);
 	}
 	return out;
@@ -2786,7 +2866,7 @@ const GRANT = /* @__PURE__ */ Symbol("coeval.grant");
 function granted(ctx) {
 	const grant = ctx[GRANT];
 	if (grant === ctx.caps) return ctx;
-	const caps = grant === void 0 ? NO_CAPS$1 : ctx.caps.every((cap) => permits(grant, cap)) ? ctx.caps : ctx.caps.filter((cap) => permits(grant, cap));
+	const caps = grant === void 0 ? NO_CAPS$2 : ctx.caps.every((cap) => permits(grant, cap)) ? ctx.caps : ctx.caps.filter((cap) => permits(grant, cap));
 	return {
 		...ctx,
 		caps,
@@ -2952,6 +3032,10 @@ var Session = class {
 	get effects() {
 		return this.list ??= [];
 	}
+	/** `true` when the evaluation records its reads. Then folded code evaluates again, thus each read goes in the list (PLAN.FOLD). */
+	get recording() {
+		return this.reading !== void 0;
+	}
 	resolve(ctx, path, options) {
 		return this.read(ctx, path, void 0, options);
 	}
@@ -3416,6 +3500,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	let meta = meta0;
 	let name;
 	let unknown;
+	let quick;
 	if (c.traced) {
 		const answer = ask(world, envelope ?? {}, c.verb, declared === void 0 ? {} : { declaredType: declared });
 		meta = {
@@ -3426,7 +3511,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		name = answer.evaluator;
 		unknown = answer.error === "unknown-kind";
 	} else {
-		const quick = answerOf(world, envelope?.own, kind ?? null, c.verb);
+		quick = answerOf(world, envelope?.own, kind ?? null, c.verb);
 		name = quick?.name;
 		unknown = quick === void 0 && kind === void 0;
 	}
@@ -3437,9 +3522,11 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	const evaluator = name !== void 0 && Object.hasOwn(c.machine.evaluators, name) ? c.machine.evaluators[name] : void 0;
 	if (name === void 0 || runner === void 0 && evaluator === void 0) return failing(c, meta, place, "#NOEVAL", `No rung gives an evaluator for ${kindText}.`);
 	if (!split.ok) return failing(c, meta, place, "#VALUE!", split.reason);
+	const frees = c.fold ? [] : void 0;
 	const parts = split.parts.map((slot) => {
 		const item = slot.item;
 		const own = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1, slot.address === true);
+		frees?.push(own.free);
 		const rules = rulesFor(kind?.caps, slot.path);
 		const compiled = rules.length === 0 ? own : gated(rules, own);
 		const header = typeof item?.name === "string" && isEnvelope(item) ? item.name : void 0;
@@ -3457,9 +3544,10 @@ function compileNode(c, value, place, declared, depth, address = false) {
 			run
 		};
 	});
+	const typePath = read.typePath ?? [];
 	const input = {
 		kind: kindText,
-		typePath: read.typePath ?? [],
+		typePath,
 		doc,
 		value: split.parts.length === 0 ? doc.value : split.fill(parts),
 		data: split.data,
@@ -3485,7 +3573,238 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	} catch (error) {
 		return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
 	}
-	return finish$1(c, meta, placedCode(inner, place, name), void 0);
+	const done = finish$1(c, meta, placedCode(inner, place, name), void 0);
+	if (frees === void 0 || kind === void 0 || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
+	const free = freeOf(doc, kind, split.parts, frees);
+	if (free === void 0) return done;
+	return free.length === 0 ? folded(c, done) : {
+		code: done.code,
+		run: done.run,
+		free
+	};
+}
+/** The free names of a closed part. */
+const CLOSED = /* @__PURE__ */ Object.freeze([]);
+/**
+* This function tells if the code of a document is pure, by the facts of D24 (FACTS.PURE). It reads the facts as
+* `factsOf` reads them. A kind with a run side, with declared effects or with volatile code is not pure here.
+*/
+function pureCode(c, envelope, kind, typePath, name, quick) {
+	if (kind.side === "run" || kind.effects !== void 0 && kind.effects.length > 0) return false;
+	let answer;
+	try {
+		answer = c.machine.facts?.(typePath, name);
+	} catch {
+		return false;
+	}
+	const described = c.verb === "eval" && (envelope === void 0 || quick?.rung !== "own" || name === answerOf(c.machine.world, void 0, kind, c.verb)?.name);
+	const pure = described ? answer?.pure ?? kind.pure : answer?.pure;
+	const volatile = described ? answer?.volatile ?? kind.volatile : answer?.volatile;
+	return pure === true && volatile !== true;
+}
+/**
+* This function gives the names that a document reads and does not bind, or `undefined` when the document can read
+* other roots. A reference reads the name of its path. Each other document reads the free names of its parts, less
+* the names that its scope rules give each part (STATIC.REFS).
+*/
+function freeOf(doc, kind, slots, frees) {
+	if (isRef(doc)) {
+		const path = doc.value;
+		if (path.length < 2 || path[0] !== "names" || !path.every((step, index) => index === 0 || isKey(step))) return void 0;
+		return [String(path[1])];
+	}
+	let sees;
+	let out;
+	for (let index = 0; index < frees.length; index += 1) {
+		const free = frees[index];
+		if (free === void 0) return void 0;
+		if (free.length === 0) continue;
+		if (sees === void 0) sees = kind.scope === void 0 || kind.scope.length === 0 ? [] : scopesOf(kind.scope, doc.value, slots).sees;
+		const bound = sees[index] ?? CLOSED;
+		for (const name of free) {
+			if (bound.includes(name)) continue;
+			out ??= [];
+			if (!out.includes(name)) out.push(name);
+		}
+	}
+	return out ?? CLOSED;
+}
+/** This class is the runtime of a fold. It reads only the names that the folded part binds, and it causes no effect. */
+var Probe = class {
+	machine;
+	running = false;
+	/** `true` after the part asked for something that a fold cannot give. */
+	refused = false;
+	/** The count of the names that the part read. */
+	reads = 0;
+	/**
+	* The context of the folded part. Its roots `self`, `event` and `names` are traps: a direct read of a field
+	* refuses the fold, as a resolution of these roots does. A copy of the record of the names reads no field.
+	*/
+	root;
+	constructor(machine) {
+		this.machine = machine;
+		const refuse = () => {
+			this.refused = true;
+		};
+		const root = {
+			self: trap(refuse, false),
+			event: trap(refuse, false),
+			names: trap(refuse, true),
+			world: worldThing(machine.world),
+			caps: NO_CAPS$2,
+			[GRANT]: NO_CAPS$2
+		};
+		this.root = root;
+	}
+	resolve(ctx, path) {
+		const name = path[1];
+		if (path[0] === "names" && isKey(name) && Object.hasOwn(ctx.names, String(name))) {
+			this.reads += 1;
+			const found = resolve(this.machine, ctx, path, WITH_HOPS);
+			if (found.hops.some((hop) => hop.by === "collapse" || isRef(hop.thing))) this.refused = true;
+			return found;
+		}
+		this.refused = true;
+		return {
+			ok: false,
+			code: "#REF!",
+			reason: "A folded part reads only the names that it binds.",
+			hops: []
+		};
+	}
+	effect() {
+		this.refused = true;
+		return fail("#CAP!", "A folded part causes no effect.");
+	}
+	*runEffect() {
+		return this.effect();
+	}
+	*all() {
+		this.refused = true;
+		return [];
+	}
+	keepsContext() {
+		this.refused = true;
+	}
+};
+/**
+* This function makes a trap for a root of the context of a fold. Each read of a field calls `refuse`. A trap of the
+* names gives no keys, thus a copy of the names reads no field.
+*/
+function trap(refuse, copies) {
+	const no = () => {
+		refuse();
+	};
+	return new Proxy({}, {
+		get: no,
+		getOwnPropertyDescriptor: no,
+		has: () => (refuse(), false),
+		ownKeys: () => {
+			if (!copies) refuse();
+			return [];
+		},
+		getPrototypeOf: () => (refuse(), null),
+		set: () => (refuse(), false),
+		defineProperty: () => (refuse(), false),
+		deleteProperty: () => (refuse(), false)
+	});
+}
+/**
+* This function folds the code of a closed pure part. The part evaluates one time with the probe. Its result becomes
+* one deeply frozen copy, and the code gives that copy at each evaluation (PLAN.SHARED). A fold that the probe cancels
+* gives the code without free names, thus no parent tries the fold again.
+*/
+function folded(c, done) {
+	const probe = c.probe ??= new Probe(c.machine);
+	probe.refused = false;
+	probe.reads = 0;
+	let constant;
+	try {
+		const result = done.code(probe.root, probe);
+		if (!probe.refused && (result.ok || result.error.code !== "#DEPTH!")) constant = sharedCopy(result);
+	} catch {
+		constant = void 0;
+	}
+	if (constant === void 0) return {
+		code: done.code,
+		run: done.run
+	};
+	const value = constant;
+	if (probe.reads === 0) return {
+		code: () => value,
+		run: void 0,
+		free: CLOSED
+	};
+	const original = done.code;
+	return {
+		code: (ctx, rt) => rt instanceof Session && !rt.traced && !rt.recording ? value : original(ctx, rt),
+		run: void 0,
+		free: CLOSED
+	};
+}
+/** The objects that a fold made. Each one is deeply frozen, thus a later fold uses it again and does not copy it. */
+const SHARED = /* @__PURE__ */ new WeakSet();
+/** The mark of a value that is not plain data. */
+const NOT_PLAIN = /* @__PURE__ */ Symbol("not plain");
+/**
+* This function gives a deeply frozen copy of plain data, or `undefined` for other values. Plain data is a primitive or
+* an array without holes and extra keys. It is also a record of enumerable data fields with the prototype of an object
+* or no prototype. The copy keeps cycles and shared objects. The objects of the host do not change.
+*/
+function sharedCopy(value) {
+	try {
+		const out = copyPlain(value, /* @__PURE__ */ new Map());
+		return out === NOT_PLAIN ? void 0 : out;
+	} catch {
+		return;
+	}
+}
+/** This function copies one value for `sharedCopy`. The map holds the copy of each object that the copy saw. */
+function copyPlain(value, memo) {
+	if (typeof value === "function") return NOT_PLAIN;
+	if (typeof value !== "object" || value === null) return value;
+	if (SHARED.has(value)) return value;
+	const seen = memo.get(value);
+	if (seen !== void 0) return seen;
+	const proto = Object.getPrototypeOf(value);
+	const keys = Reflect.ownKeys(value);
+	let out;
+	if (Array.isArray(value)) {
+		if (proto !== Array.prototype || keys.length !== value.length + 1) return NOT_PLAIN;
+		const list = [];
+		memo.set(value, list);
+		for (let index = 0; index < value.length; index += 1) {
+			const field = Object.getOwnPropertyDescriptor(value, index);
+			if (field === void 0 || !("value" in field) || field.enumerable !== true) return NOT_PLAIN;
+			const item = copyPlain(field.value, memo);
+			if (item === NOT_PLAIN) return NOT_PLAIN;
+			list.push(item);
+		}
+		out = list;
+	} else {
+		if (proto !== Object.prototype && proto !== null) return NOT_PLAIN;
+		const record = proto === null ? Object.create(null) : {};
+		memo.set(value, record);
+		for (const key of keys) {
+			if (typeof key !== "string") return NOT_PLAIN;
+			const field = Object.getOwnPropertyDescriptor(value, key);
+			if (field === void 0 || !("value" in field) || field.enumerable !== true) return NOT_PLAIN;
+			const item = copyPlain(field.value, memo);
+			if (item === NOT_PLAIN) return NOT_PLAIN;
+			if (key === "__proto__") Object.defineProperty(record, key, {
+				value: item,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			else record[key] = item;
+		}
+		out = record;
+	}
+	Object.freeze(out);
+	SHARED.add(out);
+	return out;
 }
 /**
 * This function gives the code of a document: the code of its evaluator, with the place of each error and of each
@@ -3555,7 +3874,7 @@ function fillOf(split, doc) {
 	return (items) => split.parts.length === 0 ? doc.value : split.fill(items);
 }
 function interpret(fn, input, fill) {
-	const { kind, typePath, doc, data, place } = input;
+	const { kind, typePath, doc, data, place, machine } = input;
 	const address = input.address === true ? { address: true } : {};
 	const refill = input.fill;
 	const compiled = input.parts;
@@ -3576,6 +3895,7 @@ function interpret(fn, input, fill) {
 			parts,
 			context: ctx,
 			place,
+			machine,
 			...address,
 			resolve: (path, options) => rt.resolve(ctx, path, options),
 			effect: (effectKind, payload) => rt.effect(ctx, effectKind, payload, place),
@@ -3584,7 +3904,7 @@ function interpret(fn, input, fill) {
 	};
 }
 function interpretRun(fn, input, fill) {
-	const { kind, typePath, doc, data, place } = input;
+	const { kind, typePath, doc, data, place, machine } = input;
 	const refill = input.fill;
 	const compiled = input.parts;
 	const hasParts = compiled.length > 0;
@@ -3604,6 +3924,7 @@ function interpretRun(fn, input, fill) {
 			parts,
 			context: ctx,
 			place,
+			machine,
 			resolve: (path, options) => rt.resolve(ctx, path, options),
 			effect: (effectKind, payload) => rt.runEffect(ctx, effectKind, payload, place),
 			all: (list, options) => rt.all(list.map((part) => () => part.evaluate()), options),
@@ -3648,12 +3969,14 @@ function prepare(machine, doc, options = {}) {
 		error: "no-answer",
 		steps: []
 	};
+	const traced = options.trace === true;
 	const c = {
 		machine,
-		traced: options.trace === true,
+		traced,
 		maxDepth: machine.maxDepth ?? 1e3,
 		verb,
-		noAnswer
+		noAnswer,
+		fold: !traced && options.fold !== false
 	};
 	let root;
 	try {
@@ -3751,8 +4074,8 @@ function record(s, result) {
 * tells where its parts are. The evaluator gets each part sealed: it can evaluate the part, and it cannot read its
 * value.
 *
-* A failure gives an error value, and the function does not throw. An effect is recorded in its order, and the host
-* does not do it. A mock can answer each effect at once (RUN.MOCK).
+* A failure gives an error value, and the function does not throw. The function records each effect in its order,
+* and the host does not do it. A mock can answer each effect at once (RUN.MOCK).
 *
 * @param machine - The world and the code of the evaluators.
 * @param doc - The document, as JSON.
@@ -4110,6 +4433,56 @@ const STD_EVALUATORS = {
 };
 /** The brand of a node of the decorated tree. Its value is the state that the kit reads. */
 const TREE_NODE = /* @__PURE__ */ Symbol.for("coeval.tree.node");
+/** The rungs of the ladder of an attribute, in their order (TREE.LADDER, D42). */
+const ATTRIBUTE_RUNGS = /* @__PURE__ */ Object.freeze([
+	"own",
+	"kind",
+	"parent",
+	"copy",
+	"default"
+]);
+/** The capabilities of an equation: none (CAP.PURE). */
+const NO_CAPS$1 = /* @__PURE__ */ Object.freeze([]);
+/** The names of an equation of `equations`, of a `unit` and of a `default`. */
+const NO_NAMES$1 = /* @__PURE__ */ Object.freeze({});
+/** The planners of equations, for each machine and each type of a bare equation (TREE.PLAN). */
+const equationPlanners = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives the plan of an equation. Each equation compiles one time for each machine (PLAN.CACHE). The
+* plan of the document does not keep it (PLAN.LEAN).
+*/
+function equationPlan(machine, of, term) {
+	let byType = equationPlanners.get(machine);
+	if (byType === void 0) {
+		byType = /* @__PURE__ */ new Map();
+		equationPlanners.set(machine, byType);
+	}
+	const key = of ?? "";
+	let plans = byType.get(key);
+	if (plans === void 0) {
+		plans = planner(machine, of === void 0 ? {} : { declaredType: of });
+		byType.set(key, plans);
+	}
+	return plans(term);
+}
+/** This function gives the own entry of a table of a tree contract, or `undefined`. */
+function entryOf(table, key) {
+	return table !== void 0 && Object.hasOwn(table, key) ? table[key] : void 0;
+}
+const NO_CONTRACT = /* @__PURE__ */ Object.freeze({
+	tree: void 0,
+	of: void 0
+});
+/** This function finds the tree contract of the kind of a node in the world of the machine. */
+function contractOf$1(machine, typePath) {
+	if (machine === void 0 || typePath.length === 0) return NO_CONTRACT;
+	const found = lookupKind(machine.world, typePath);
+	if (!found.ok || found.kind.tree === void 0) return NO_CONTRACT;
+	return {
+		tree: found.kind.tree,
+		of: equationType(found.kind)
+	};
+}
 const BUSY = /* @__PURE__ */ Object.freeze({ busy: true });
 /** The attributes in evaluation, in the order of their demands. An evaluation does not wait, thus one list serves. */
 const demands = [];
@@ -4177,28 +4550,92 @@ function plainOf(value, path) {
 }
 /**
 * This function makes a node of the decorated tree. A step `parent` gives the self of the context of the node, and a
-* step `type` gives its type. A step with the key of a part reads that attribute. A failed attribute throws `Failure`
-* with its own error, thus a reference to it gives that error.
+* step `type` gives its type. Another step reads an attribute through its ladder (TREE.LADDER). The rungs are a part of
+* the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
+* fold or a default, come last. A failed attribute throws `Failure` with its own error, thus a reference to it gives that error.
 */
-function treeThing(parts, context, type, place, build) {
+function treeThing(input, build) {
+	const { parts, context, kind: type, place, machine } = input;
+	const { tree, of } = contractOf$1(machine, input.typePath);
+	const above = stateOf(context.self);
+	const up = above !== void 0 && above.build === build ? above : void 0;
 	const cells = /* @__PURE__ */ new Map();
+	/** The positions of the items of the list `children`, for the names of the children. */
+	let positions;
+	const fold = (key, declared) => {
+		let acc = state.equation(declared.unit, NO_NAMES$1);
+		if (!acc.ok) return acc;
+		const children = read("children");
+		if (children === void 0) return acc;
+		if (!children.ok) return children;
+		if (!Array.isArray(children.value)) return fail("#VALUE!", `The fold of ${key} needs a list in children.`);
+		for (const item of children.value) {
+			const child = stateOf(item);
+			if (child === void 0 || child.build !== build) continue;
+			const value = child.read(key);
+			if (value === void 0) return fail("#N/A", `No rung gives ${attributeText(key, child.type, child.place)}.`);
+			if (!value.ok) return value;
+			acc = state.equation(declared.combine, {
+				acc: acc.value,
+				item: value.value
+			});
+			if (!acc.ok) return acc;
+		}
+		return acc;
+	};
+	/** This function visits the rungs of the ladder of an attribute in their order, until one answers. */
+	const climb = (key) => {
+		const part = parts.find((item) => item.key === key);
+		if (part !== void 0) return {
+			result: part.evaluate({
+				...context,
+				self: node
+			}),
+			by: "own"
+		};
+		const equation = entryOf(tree?.equations, key);
+		if (equation !== void 0) return {
+			result: state.equation(equation, NO_NAMES$1),
+			by: "kind"
+		};
+		const down = up === void 0 ? void 0 : entryOf(up.tree?.down, key);
+		if (up !== void 0 && down !== void 0) {
+			const names = up.childNames(node);
+			return {
+				result: names.ok ? up.equation(down, names.value) : names,
+				by: "parent"
+			};
+		}
+		const declared = entryOf(tree?.attributes, key);
+		if (declared?.copy === true && up !== void 0) {
+			const copied = up.read(key);
+			if (copied !== void 0) return {
+				result: copied,
+				by: "copy"
+			};
+		}
+		if (declared?.fold !== void 0) return {
+			result: fold(key, declared.fold),
+			by: "default"
+		};
+		if (declared?.default !== void 0) return {
+			result: state.equation(declared.default, NO_NAMES$1),
+			by: "default"
+		};
+	};
 	const read = (key) => {
 		const cell = cells.get(key);
 		if (cell !== void 0) return cell.busy ? cycleAt(cells, key, attributeText(key, type, place)) : cell.result;
-		const part = parts.find((item) => item.key === key);
-		if (part === void 0) return void 0;
+		if (tree === void 0 && up?.tree === void 0 && !parts.some((item) => item.key === key)) return void 0;
 		cells.set(key, BUSY);
 		demands.push({
 			cells,
 			key,
 			text: attributeText(key, type, place)
 		});
-		let result;
+		let answer;
 		try {
-			result = part.evaluate({
-				...context,
-				self: node
-			});
+			answer = climb(key);
 		} catch (error) {
 			cells.delete(key);
 			throw error;
@@ -4207,14 +4644,60 @@ function treeThing(parts, context, type, place, build) {
 		}
 		cells.set(key, {
 			busy: false,
-			result
+			result: answer?.result,
+			by: answer?.by
 		});
-		return result;
+		return answer?.result;
 	};
 	const state = {
 		build,
 		type,
 		place,
+		tree,
+		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({
+				...context,
+				names,
+				caps: NO_CAPS$1,
+				self: node
+			});
+		},
+		childNames(child) {
+			const children = read("children");
+			if (children !== void 0 && !children.ok) return children;
+			const list = children !== void 0 && Array.isArray(children.value) ? children.value : [];
+			if (positions?.list !== list) {
+				const at = /* @__PURE__ */ new Map();
+				list.forEach((item, index) => {
+					if (!at.has(item)) at.set(item, index);
+				});
+				positions = {
+					list,
+					at
+				};
+			}
+			const index = positions.at.get(child);
+			return ok({
+				child,
+				index: index ?? null,
+				prev: index === void 0 || index === 0 ? null : list[index - 1]
+			});
+		},
+		trace(key) {
+			const cell = cells.get(key);
+			if (cell === void 0 || cell.busy) return void 0;
+			const rungs = cell.by === void 0 ? ATTRIBUTE_RUNGS : ATTRIBUTE_RUNGS.slice(0, ATTRIBUTE_RUNGS.indexOf(cell.by) + 1);
+			return cell.by === void 0 ? {
+				attribute: key,
+				rungs
+			} : {
+				attribute: key,
+				rungs,
+				by: cell.by
+			};
+		},
 		json(path) {
 			path.add(node);
 			try {
@@ -4246,7 +4729,9 @@ function treeThing(parts, context, type, place, build) {
 			return result.value;
 		},
 		has(key) {
-			return key === "parent" || key === "type" || parts.some((part) => part.key === String(key));
+			if (key === "parent" || key === "type" || parts.some((part) => part.key === String(key))) return true;
+			const cell = cells.get(String(key));
+			return cell !== void 0 && !cell.busy && cell.result !== void 0;
 		},
 		toJson() {
 			const result = state.json(/* @__PURE__ */ new Set());
@@ -4257,14 +4742,25 @@ function treeThing(parts, context, type, place, build) {
 	return node;
 }
 /**
+* This function gives the record of the demand of an attribute of a node of the decorated tree (TREE.RUNGS). The
+* record holds the rungs that the demand visited, and the rung that answered. An explorer draws the ladder with it.
+*
+* @param node - The thing of a node.
+* @param attribute - The name of the attribute.
+* @returns The record, or `undefined` for a thing that is not a node or an attribute that no demand reached.
+*/
+function attributeTrace(node, attribute) {
+	return stateOf(node)?.trace(attribute);
+}
+/**
 * This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
 * thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree.
 */
-function treeNode({ parts, context, kind, place }) {
-	const above = stateOf(context.self);
-	if (above !== void 0 && above.build.open) return ok(treeThing(parts, context, kind, place, above.build));
+function treeNode(input) {
+	const above = stateOf(input.context.self);
+	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build));
 	const build = { open: true };
-	const root = treeThing(parts, context, kind, place, build);
+	const root = treeThing(input, build);
 	try {
 		return stateOf(root).json(/* @__PURE__ */ new Set());
 	} finally {
@@ -5007,96 +5503,27 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 }
 //#endregion
 //#region src/static.ts
-function valueAt(value, path) {
-	let here = value;
-	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
-	else if (isRecord(here) && Object.hasOwn(here, String(key))) here = here[String(key)];
-	else return void 0;
-	return here;
-}
-function headerName(item) {
-	return isEnvelope(item) && typeof item.name === "string" ? item.name : void 0;
+/** 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. */
+function withoutNames(options) {
+	const { names: _host, ...rest } = options;
+	return rest;
 }
-function namesOf(source, value, covered) {
-	if ("fixed" in source) return source.fixed;
-	if ("keysAt" in source) {
-		const at = valueAt(value, source.keysAt);
-		return isRecord(at) ? Object.keys(at) : [];
-	}
-	if ("listAt" in source) {
-		const at = valueAt(value, source.listAt);
-		return Array.isArray(at) ? at.filter((item) => typeof item === "string") : [];
-	}
-	if ("textAt" in source) {
-		const at = valueAt(value, source.textAt);
-		if (typeof at === "string") return [at];
-		return source.otherwise === void 0 ? [] : [source.otherwise];
+/** This function gives the keys of a trail, from its start. It keeps the result in the trail. */
+function keysOf(trail) {
+	if (trail === void 0) return [];
+	if (trail.full !== void 0) return trail.full;
+	const steps = [];
+	let here = trail;
+	while (here !== void 0 && here.full === void 0) {
+		steps.push(here);
+		here = here.up;
 	}
-	return covered.map((slot) => headerName(slot.item)).filter((name) => name !== void 0);
-}
-/**
-* This function gives the names that the scope rules of a kind give each part, and the names that only later parts
-* see. `check` and `conforms` read the scope rules with it.
-*
-* @param rules - The scope rules of the kind.
-* @param value - The value of the document.
-* @param slots - The parts of the value, in order.
-* @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
-*/
-function scopesOf(rules, value, slots) {
-	const sees = slots.map(() => []);
-	const later = slots.map(() => []);
-	for (const rule of rules ?? []) {
-		const covered = slots.map((slot, index) => ({
-			slot,
-			index
-		})).filter(({ slot }) => rule.in.some((pattern) => pathMatches(slot.path, pattern)));
-		if (rule.sequential !== true) {
-			const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
-			for (const { index } of covered) sees[index]?.push(...names);
-			continue;
-		}
-		if ("headers" in rule.names) {
-			covered.forEach(({ index }, position) => {
-				const before = covered.slice(0, position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
-				const after = covered.slice(position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
-				sees[index]?.push(...before);
-				later[index]?.push(...after);
-			});
-			continue;
-		}
-		const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
-		covered.forEach(({ index }, position) => {
-			if (position > 0) sees[index]?.push(...names);
-			else later[index]?.push(...names);
-		});
-	}
-	return {
-		sees,
-		later
-	};
-}
-/** 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. */
-function withoutNames(options) {
-	const { names: _host, ...rest } = options;
-	return rest;
-}
-/** This function gives the keys of a trail, from its start. It keeps the result in the trail. */
-function keysOf(trail) {
-	if (trail === void 0) return [];
-	if (trail.full !== void 0) return trail.full;
-	const steps = [];
-	let here = trail;
-	while (here !== void 0 && here.full === void 0) {
-		steps.push(here);
-		here = here.up;
-	}
-	const keys = here?.full === void 0 ? [] : [...here.full];
-	for (let index = steps.length - 1; index >= 0; index -= 1) for (const key of steps[index].keys) keys.push(key);
-	trail.full = keys;
-	return keys;
+	const keys = here?.full === void 0 ? [] : [...here.full];
+	for (let index = steps.length - 1; index >= 0; index -= 1) for (const key of steps[index].keys) keys.push(key);
+	trail.full = keys;
+	return keys;
 }
 /** A visit with its paths as trails. It makes the keys of a path only when a reader asks for them. */
 var Visit = class {
@@ -5420,11 +5847,81 @@ function typeCheck(machine, doc, options = {}) {
 		places: pass.places
 	};
 }
+/** The names that an equation of `down` sees (TREE.DOWN). */
+const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
+	"child",
+	"index",
+	"prev"
+]);
+/** The names that the term `combine` of a fold sees (TREE.FOLD). */
+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.
+*/
+function equationsOf(kind) {
+	const tree = kind.tree;
+	if (tree === void 0) return [];
+	const out = [];
+	for (const [name, term] of Object.entries(tree.equations ?? {})) out.push({
+		label: `tree.equations.${name}`,
+		term,
+		names: []
+	});
+	for (const [name, term] of Object.entries(tree.down ?? {})) out.push({
+		label: `tree.down.${name}`,
+		term,
+		names: DOWN_NAMES
+	});
+	for (const [name, declared] of Object.entries(tree.attributes ?? {})) {
+		if (declared.fold !== void 0) {
+			out.push({
+				label: `tree.attributes.${name}.fold.unit`,
+				term: declared.fold.unit,
+				names: []
+			});
+			out.push({
+				label: `tree.attributes.${name}.fold.combine`,
+				term: declared.fold.combine,
+				names: FOLD_NAMES
+			});
+		}
+		if (declared.default !== void 0) out.push({
+			label: `tree.attributes.${name}.default`,
+			term: declared.default,
+			names: []
+		});
+	}
+	return out;
+}
+/**
+* This function checks the equations of the tree contract of a kind, each with the names of its rung (TREE.DOWN-NAMES).
+* An equation evaluates without capabilities, thus a check with capabilities gives it none. Each issue gets the place
+* of the document of the kind, and its reason names the equation.
+*/
+function equationIssues(machine, kind, kindText, options, seen) {
+	const of = equationType(kind);
+	const out = [];
+	for (const { label, term, names } of equationsOf(kind)) {
+		const inner = {
+			names,
+			...of === void 0 ? {} : { declaredType: of },
+			...options.caps === void 0 ? {} : { caps: [] }
+		};
+		for (const issue of checkAll(machine, term, inner, void 0, seen)) out.push({
+			code: issue.code,
+			place: [],
+			reason: `In the equation ${label} of the kind ${kindText}: ${issue.reason}`
+		});
+	}
+	return out;
+}
 /**
 * This function finds the issues of `check`. With a list of nodes, it also records each document that it visits for
-* the pass of types. It marks each document with an issue.
+* the pass of types. It marks each document with an issue. The set `seen` holds the kinds whose equations the check
+* walked, thus it walks the equations of each kind one time.
 */
-function checkAll(machine, doc, options, nodes) {
+function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()) {
 	const issues = [];
 	const verb = options.verb ?? "eval";
 	const indices = nodes === void 0 ? void 0 : /* @__PURE__ */ new Map();
@@ -5476,6 +5973,14 @@ function checkAll(machine, doc, options, nodes) {
 			});
 			return "skip";
 		}
+		if (v.kind?.tree !== void 0 && !seen.has(v.kind)) {
+			seen.add(v.kind);
+			for (const issue of equationIssues(machine, v.kind, typeName(v.doc.type), options, seen)) push({
+				...issue,
+				place: v.place,
+				at: v.at
+			});
+		}
 		const name = answer.evaluator;
 		if (current !== void 0) current.evaluator = name;
 		const runner = name !== void 0 && has(machine.runners, name);
@@ -5873,6 +6378,178 @@ function checkLatent(machine, declared, body, options = {}) {
 	return issues;
 }
 //#endregion
+//#region 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;
+	if (typeof codec !== "object" || codec === null) return void 0;
+	const { encode, decode } = codec;
+	return typeof encode === "function" && typeof decode === "function" ? codec : void 0;
+}
+/**
+* This function reads the value of an extension `ext.domain` (EXT.DOMAIN). The value is a record with only the text
+* `domain` and the JSON `data`. The codec of the named domain reads the data, and the result must be a member of the
+* domain.
+*
+* @param data - The value of the extension document.
+* @param domains - The domains of the machine.
+* @returns The member, `#NAME?` for a domain without a codec, or `#VALUE!` for data that the codec cannot read.
+*/
+function decodeDomain(data, domains) {
+	if (!isRecord(data) || typeof data["domain"] !== "string" || !Object.hasOwn(data, "data") || Object.keys(data).length !== 2) return fail("#VALUE!", "The value of ext.domain is a record with only the text domain and the data.");
+	const name = data["domain"];
+	const domain = domainOf(name, domains);
+	if (domain === void 0) return fail("#NAME?", `The machine has no domain ${name}.`);
+	const codec = codecOf(domain);
+	if (codec === void 0) return fail("#NAME?", `The domain ${name} has no codec.`);
+	let value;
+	try {
+		value = codec.decode(data["data"]);
+	} catch (error) {
+		return fail("#VALUE!", `The codec of the domain ${name} cannot read the data: ${describe(error)}`, { cause: error });
+	}
+	if (!member(value, name, domains)) return fail("#VALUE!", `The codec of the domain ${name} gives a value that is not a member of the domain.`);
+	return ok(value);
+}
+/**
+* This function gives the static type of an extension `ext.domain`: the name of its domain when that domain has a
+* codec. A run then gives a member of the domain or an error, because `decodeDomain` tests the membership.
+*
+* @param data - The value of the extension document.
+* @param domains - The domains of the machine.
+* @returns The name of the domain, or `unknown`.
+*/
+function domainTypeOf(data, domains) {
+	if (!isRecord(data) || typeof data["domain"] !== "string") return "unknown";
+	const domain = domainOf(data["domain"], 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) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else target[key] = value;
+}
+/**
+* This function tells if JSON writes a value exactly. Such a value is a finite number other than `-0`, a text, a truth
+* value, `null`, or a container of such values.
+*/
+function isJson(value, encoder) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value) && !Object.is(value, -0);
+	const list = Array.isArray(value);
+	if (!list && !isRecord(value)) return false;
+	const container = value;
+	const known = encoder.json.get(container);
+	if (known !== void 0) return known;
+	encoder.json.set(container, false);
+	let all = true;
+	if (list) {
+		const items = value;
+		for (let index = 0; index < items.length && all; index += 1) all = isJson(items[index], encoder);
+	} else {
+		const record = value;
+		for (const key of Object.keys(record)) if (!isJson(record[key], encoder)) {
+			all = false;
+			break;
+		}
+	}
+	encoder.json.set(container, all);
+	return all;
+}
+/** This function gives the text of a number that JSON cannot write, for `ext.number`. */
+function numberText(value) {
+	if (Number.isNaN(value)) return "NaN";
+	if (value === Number.POSITIVE_INFINITY) return "Infinity";
+	if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+	return "-0";
+}
+/** This function gives the term document of a value in one call of `encodeValue`. */
+function encodeTerm(value, encoder) {
+	if (isJson(value, encoder)) return isEnvelope(value) ? {
+		type: "lit",
+		value
+	} : value;
+	if (value === void 0) return {
+		type: ["ext", "undefined"],
+		value: null
+	};
+	if (typeof value === "number") return {
+		type: ["ext", "number"],
+		value: numberText(value)
+	};
+	for (const [name, codec] of encoder.codecs) if (member(value, name, encoder.domains)) return {
+		type: ["ext", "domain"],
+		value: {
+			domain: name,
+			data: codec.encode(value)
+		}
+	};
+	if (!Array.isArray(value) && !isRecord(value)) throw new TypeError(`encodeValue cannot write the value ${describe(value)}: no domain of the machine with a codec holds it.`);
+	if (encoder.open.has(value)) throw new TypeError("encodeValue cannot write a value with a cycle.");
+	encoder.open.add(value);
+	let out;
+	if (Array.isArray(value)) out = {
+		type: "list",
+		value: Array.from(value, (item) => encodeTerm(item, encoder))
+	};
+	else {
+		const fields = {};
+		const record = value;
+		for (const key of Object.keys(record)) setOwn$2(fields, key, encodeTerm(record[key], encoder));
+		out = {
+			type: "record",
+			value: fields
+		};
+	}
+	encoder.open.delete(value);
+	return out;
+}
+/**
+* This function writes a host value as a term document of the formula kit (EXT.ENCODE, D40). Thus the same value has
+* the same document in each language (D12).
+*
+* - A value that JSON writes exactly stays as it is. A literal with the shape of an envelope goes into `lit`.
+* - `NaN`, an infinity and `-0` become `ext.number`, and `undefined` becomes `ext.undefined`.
+* - A member of a domain with a codec becomes `ext.domain`. The domains go in the order of their names.
+* - A list or a plain record with such a value becomes the construct `list` or `record`.
+*
+* @param machine - The machine, or only its domains.
+* @param value - The host value.
+* @returns The document. `decodeValue` gives the value again (EXT.ROUNDTRIP).
+* @throws {TypeError} The value has a cycle, or it is not JSON and no domain with a codec holds it.
+*/
+function encodeValue(machine, value) {
+	const domains = machine.domains;
+	const codecs = [];
+	if (domains !== void 0) for (const name of Object.keys(domains).sort()) {
+		const domain = domainOf(name, domains);
+		const codec = domain === void 0 ? void 0 : codecOf(domain);
+		if (codec !== void 0) codecs.push([name, codec]);
+	}
+	return encodeTerm(value, {
+		domains,
+		codecs,
+		json: /* @__PURE__ */ new WeakMap(),
+		open: /* @__PURE__ */ new Set()
+	});
+}
+/**
+* This function reads a document of `encodeValue` again: it evaluates the document as a term, in an empty context.
+* A bare root value is a literal.
+*
+* @param machine - A machine of the formula kit, with the domains of the document.
+* @param doc - The document.
+* @returns The value, or the error of the evaluation.
+*/
+function decodeValue(machine, doc) {
+	return prepare(machine, doc, { declaredType: "lit" }).evaluate(makeContext());
+}
+//#endregion
 //#region src/formula.ts
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED = /* @__PURE__ */ Symbol("skipped");
@@ -5893,7 +6570,10 @@ const CLOSURE$2 = /* @__PURE__ */ Symbol.for("coeval.closure");
 function isClosure(value) {
 	return typeof value === "function" && value[CLOSURE$2] !== void 0;
 }
-/** The standard extensions: the values that JSON cannot write. */
+/**
+* The standard extensions: the values that JSON cannot write. `ext.domain` reads a member of a domain through the
+* codec of the domain (EXT.DOMAIN, D40).
+*/
 const STD_EXT = {
 	undefined: () => ok(void 0),
 	number: (data) => {
@@ -5902,7 +6582,8 @@ const STD_EXT = {
 		if (data === "-Infinity") return ok(Number.NEGATIVE_INFINITY);
 		if (data === "-0") return ok(-0);
 		return fail("#VALUE!", "The value of ext.number is NaN, Infinity, -Infinity or -0.");
-	}
+	},
+	domain: (data, _context, domains) => decodeDomain(data, domains)
 };
 /** The truth of a value in the rules of JavaScript: `0`, `""`, `null`, `undefined` and `NaN` are false. */
 function jsTruthy(value) {
@@ -6369,8 +7050,9 @@ function formulaTypes(profile) {
 		},
 		"formula.ext": { synth: (input) => {
 			const name = nameOf(input);
-			const own = profile.ext !== void 0 && Object.hasOwn(profile.ext, name);
-			return name === "number" && !own ? "number" : "unknown";
+			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return "unknown";
+			if (name === "number") return "number";
+			return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
 		} }
 	};
 }
@@ -6688,7 +7370,7 @@ function formulaCode(profile) {
 				}
 			};
 		}),
-		"formula.ext": compiled(({ typePath, doc }) => {
+		"formula.ext": compiled(({ typePath, doc, machine }) => {
 			const name = typePath.slice(1).join(".");
 			const handler = (profile.ext !== void 0 && Object.hasOwn(profile.ext, name) ? profile.ext[name] : void 0) ?? (Object.hasOwn(STD_EXT, name) ? STD_EXT[name] : void 0);
 			if (handler === void 0) {
@@ -6697,7 +7379,7 @@ function formulaCode(profile) {
 			}
 			return (ctx) => {
 				try {
-					return handler(doc.value, ctx);
+					return handler(doc.value, ctx, machine.domains);
 				} catch (error) {
 					return thrown(error, `the extension ${name}`);
 				}
@@ -6798,6 +7480,835 @@ function formulaMachine(profile = {}, more = {}) {
 	}, more);
 }
 //#endregion
+//#region 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.
+*/
+const STD_SYNTAX = /* @__PURE__ */ Object.freeze({
+	operators: [
+		{
+			symbol: "or",
+			fixity: "infix",
+			prec: 1,
+			assoc: "flat",
+			kind: "or"
+		},
+		{
+			symbol: "and",
+			fixity: "infix",
+			prec: 2,
+			assoc: "flat",
+			kind: "and"
+		},
+		{
+			symbol: "not",
+			fixity: "prefix",
+			prec: 3,
+			kind: "ops.not"
+		},
+		{
+			symbol: "==",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.eq"
+		},
+		{
+			symbol: "!=",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.ne"
+		},
+		{
+			symbol: "<",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.lt"
+		},
+		{
+			symbol: "<=",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.le"
+		},
+		{
+			symbol: ">",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.gt"
+		},
+		{
+			symbol: ">=",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.ge"
+		},
+		{
+			symbol: "+",
+			fixity: "infix",
+			prec: 5,
+			kind: "ops.add"
+		},
+		{
+			symbol: "-",
+			fixity: "infix",
+			prec: 5,
+			kind: "ops.sub"
+		},
+		{
+			symbol: "*",
+			fixity: "infix",
+			prec: 6,
+			kind: "ops.mul"
+		},
+		{
+			symbol: "/",
+			fixity: "infix",
+			prec: 6,
+			kind: "ops.div"
+		},
+		{
+			symbol: "%",
+			fixity: "infix",
+			prec: 6,
+			kind: "ops.mod"
+		},
+		{
+			symbol: "-",
+			fixity: "prefix",
+			prec: 7,
+			kind: "ops.neg"
+		},
+		{
+			symbol: "^",
+			fixity: "infix",
+			prec: 8,
+			assoc: "right",
+			kind: "ops.pow"
+		}
+	],
+	literals: { words: {
+		true: true,
+		false: false,
+		null: null,
+		undefined: void 0,
+		NaN: NaN,
+		Infinity: Infinity
+	} },
+	calls: { forms: [{
+		name: "if",
+		kind: "if",
+		fields: [
+			"test",
+			"then",
+			"else"
+		],
+		min: 2
+	}, {
+		name: "list",
+		kind: "list"
+	}] }
+});
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const NAME_AT = /[A-Za-z_][A-Za-z0-9_]*/y;
+const DIGITS_AT = /[0-9]+/y;
+const NUMBER_AT = /(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+const SYMBOL = /^[^\sA-Za-z0-9_"'`()$.]+$/;
+const DEFAULT_WORDS = {
+	true: true,
+	false: false,
+	null: null
+};
+const DEFAULT_ROOTS = [
+	"self",
+	"world",
+	"event",
+	"caps"
+];
+const compiledProfiles = /* @__PURE__ */ new WeakMap();
+function typeOfKind(kind) {
+	const keys = kind.split(".");
+	if (kind === "" || keys.some((key) => key === "")) throw new TypeError(`The kind "${kind}" of a syntax profile has an empty key.`);
+	return {
+		type: keys.length === 1 ? keys[0] : keys,
+		key: JSON.stringify(keys)
+	};
+}
+function addTo(map, key, value) {
+	const list = map.get(key);
+	if (list === void 0) map.set(key, [value]);
+	else list.push(value);
+}
+function compileOps(profile, separator) {
+	const prefix = /* @__PURE__ */ new Map();
+	const binary = /* @__PURE__ */ new Map();
+	const byKind = /* @__PURE__ */ new Map();
+	const assocAt = /* @__PURE__ */ new Map();
+	const opWords = /* @__PURE__ */ new Set();
+	for (const given of profile.operators ?? []) {
+		const word = NAME.test(given.symbol);
+		if (!word && (!SYMBOL.test(given.symbol) || given.symbol.includes(separator))) throw new TypeError(`The operator "${given.symbol}" is not a plain name or a group of symbols.`);
+		if (!Number.isFinite(given.prec)) throw new TypeError(`The operator "${given.symbol}" has no finite precedence.`);
+		const { type, key } = typeOfKind(given.kind);
+		const op = {
+			symbol: given.symbol,
+			fixity: given.fixity,
+			prec: given.prec,
+			assoc: given.assoc ?? "left",
+			type,
+			kindKey: key,
+			word
+		};
+		const table = op.fixity === "prefix" ? prefix : binary;
+		if (table.has(op.symbol)) throw new TypeError(`The operator "${op.symbol}" has two entries of the same place.`);
+		table.set(op.symbol, op);
+		if (op.fixity === "infix") {
+			const assoc = assocAt.get(op.prec);
+			if (assoc !== void 0 && assoc !== op.assoc) throw new TypeError(`The infix operators of the precedence ${String(op.prec)} have different groupings.`);
+			assocAt.set(op.prec, op.assoc);
+		}
+		if (word) opWords.add(op.symbol);
+		addTo(byKind, key, op);
+	}
+	const longestFirst = (table) => [...table.keys()].filter((symbol) => !NAME.test(symbol)).sort((a, b) => b.length - a.length);
+	return {
+		prefix,
+		binary,
+		prefixSymbols: longestFirst(prefix),
+		binarySymbols: longestFirst(binary),
+		byKind,
+		opWords
+	};
+}
+function compileProfile(profile) {
+	const cached = compiledProfiles.get(profile);
+	if (cached !== void 0) return cached;
+	const calls = profile.calls ?? {};
+	const separator = calls.separator ?? ",";
+	const ops = compileOps(profile, separator);
+	const literals = profile.literals ?? {};
+	const strings = literals.strings === false ? void 0 : literals.strings ?? {};
+	const words = new Map(Object.entries(literals.words ?? DEFAULT_WORDS));
+	const refs = profile.refs ?? {};
+	const roots = new Set(refs.roots ?? DEFAULT_ROOTS);
+	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 { type, key } = typeOfKind(given.kind);
+		const form = {
+			name: given.name,
+			type,
+			fields: given.fields,
+			min: given.min ?? given.fields?.length ?? 0
+		};
+		forms.set(form.name, form);
+		addTo(formsByKind, key, form);
+	}
+	const compiled = {
+		...ops,
+		numbers: literals.numbers ?? true,
+		signed: literals.signed ?? true,
+		quote: strings === void 0 ? void 0 : strings.quote ?? "\"",
+		doubled: strings !== void 0 && strings.escape === "double",
+		words,
+		bare: refs.bare ?? "names",
+		roots,
+		fields: refs.fields ?? true,
+		patterns: (refs.patterns ?? []).map((p) => {
+			const flags = p.pattern.flags.replace(/[gy]/g, "");
+			return {
+				sticky: new RegExp(p.pattern.source, `${flags}y`),
+				whole: new RegExp(`^(?:${p.pattern.source})$`, flags),
+				read: p.read,
+				write: p.write
+			};
+		}),
+		ops: calls.ops === void 0 || calls.ops === true ? true : new Set(calls.ops === false ? [] : calls.ops),
+		forms,
+		formsByKind,
+		separator,
+		reserved: /* @__PURE__ */ new Set([
+			...words.keys(),
+			...ops.opWords,
+			...roots
+		]),
+		maxDepth: profile.maxDepth ?? 256
+	};
+	compiledProfiles.set(profile, compiled);
+	return compiled;
+}
+/** The stop of a parse. The parser throws it, and `parse` gives its issue. */
+var Stop = class {
+	issue;
+	constructor(issue) {
+		this.issue = issue;
+	}
+};
+function literalDoc(value) {
+	return encodeValue({}, value);
+}
+function opDoc(op, value) {
+	return {
+		type: op.type,
+		value
+	};
+}
+const ESCAPES = {
+	"\"": "\"",
+	"'": "'",
+	"\\": "\\",
+	"/": "/",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+var Parser = class {
+	syn;
+	text;
+	pos = 0;
+	depth = 0;
+	constructor(syn, text) {
+		this.syn = syn;
+		this.text = text;
+	}
+	parse() {
+		this.skip();
+		if (this.pos >= this.text.length) this.stop("The text is empty.", 0, 0);
+		const doc = this.expr(0);
+		this.skip();
+		if (this.pos < this.text.length) this.stop("The text continues after the expression.", this.pos, this.tokenLength());
+		return doc;
+	}
+	position() {
+		return this.pos;
+	}
+	stop(message, offset, length) {
+		throw new Stop({
+			offset,
+			length,
+			message
+		});
+	}
+	skip() {
+		while (this.pos < this.text.length && /\s/.test(this.text[this.pos])) this.pos += 1;
+	}
+	at(pattern, pos = this.pos) {
+		pattern.lastIndex = pos;
+		return pattern.exec(this.text)?.[0];
+	}
+	tokenLength() {
+		return (this.at(NAME_AT) ?? this.at(DIGITS_AT) ?? "x").length;
+	}
+	/** This method reads an expression by precedence climbing. It stops at an operator below `min`. */
+	expr(min) {
+		const start = this.pos;
+		this.depth += 1;
+		if (this.depth > this.syn.maxDepth) this.stop(`The text is deeper than ${String(this.syn.maxDepth)} levels.`, start, 0);
+		let left = this.operand();
+		for (;;) {
+			this.skip();
+			const found = this.operatorAt();
+			if (found === void 0 || found.op.prec < min) break;
+			const op = found.op;
+			this.pos += found.length;
+			if (op.fixity === "postfix") {
+				left = opDoc(op, [left]);
+				continue;
+			}
+			if (op.assoc === "flat") {
+				const terms = [left, this.expr(op.prec + 1)];
+				for (;;) {
+					this.skip();
+					const next = this.operatorAt();
+					if (next === void 0 || next.op.fixity !== "infix" || next.op.kindKey !== op.kindKey) break;
+					this.pos += next.length;
+					terms.push(this.expr(op.prec + 1));
+				}
+				left = opDoc(op, terms);
+				continue;
+			}
+			left = opDoc(op, [left, this.expr(op.assoc === "right" ? op.prec : op.prec + 1)]);
+			if (op.assoc === "none") {
+				this.skip();
+				const next = this.operatorAt();
+				if (next !== void 0 && next.op.fixity === "infix" && next.op.prec === op.prec) this.stop(`The operator ${next.op.symbol} does not chain after ${op.symbol}. Add parentheses.`, this.pos, next.length);
+			}
+		}
+		this.depth -= 1;
+		return left;
+	}
+	/** This method finds an infix or a postfix operator at the position. */
+	operatorAt() {
+		const name = this.at(NAME_AT);
+		if (name !== void 0) {
+			const op = this.syn.binary.get(name);
+			return op !== void 0 && op.word ? {
+				op,
+				length: name.length
+			} : void 0;
+		}
+		for (const symbol of this.syn.binarySymbols) if (this.text.startsWith(symbol, this.pos)) return {
+			op: this.syn.binary.get(symbol),
+			length: symbol.length
+		};
+	}
+	operand() {
+		this.skip();
+		const start = this.pos;
+		const c = this.text[start];
+		if (c === void 0) return this.stop("A term is missing at the end of the text.", start, 0);
+		for (const pattern of this.syn.patterns) {
+			const match = this.at(pattern.sticky);
+			if (match !== void 0 && match !== "" && !/[A-Za-z0-9_$(]/.test(this.text[start + match.length] ?? "")) {
+				this.pos += match.length;
+				return {
+					type: "ref",
+					value: pattern.read(match)
+				};
+			}
+		}
+		if (/[0-9]/.test(c)) return this.number(false);
+		if (c === "-" && this.syn.signed && /[0-9]/.test(this.text[start + 1] ?? "")) return this.number(true);
+		if (c === this.syn.quote) return this.string();
+		if (c === "(") return this.group();
+		if (c === "`" || /[A-Za-z_]/.test(c)) return this.named();
+		for (const symbol of this.syn.prefixSymbols) if (this.text.startsWith(symbol, start)) {
+			this.pos += symbol.length;
+			const op = this.syn.prefix.get(symbol);
+			return opDoc(op, [this.expr(op.prec + 1)]);
+		}
+		if (c === ")" || this.text.startsWith(this.syn.separator, start)) return this.stop("A term is missing.", start, 0);
+		return this.stop(`The text "${c}" cannot start a term.`, start, 1);
+	}
+	number(negative) {
+		const start = this.pos;
+		if (!this.syn.numbers) this.stop("This syntax has no numbers.", start, this.tokenLength());
+		if (negative) this.pos += 1;
+		const digits = this.at(NUMBER_AT);
+		this.pos += digits.length;
+		const value = Number(digits);
+		return literalDoc(negative ? -value : value);
+	}
+	string() {
+		const start = this.pos;
+		const quote = this.syn.quote;
+		let out = "";
+		this.pos += 1;
+		for (;;) {
+			const c = this.text[this.pos];
+			if (c === void 0) return this.stop("A closing quote is missing.", start, this.text.length - start);
+			if (c === quote) {
+				if (this.syn.doubled && this.text[this.pos + 1] === quote) {
+					out += quote;
+					this.pos += 2;
+					continue;
+				}
+				this.pos += 1;
+				return literalDoc(out);
+			}
+			if (c === "\\" && !this.syn.doubled) {
+				out += this.escape();
+				continue;
+			}
+			out += c;
+			this.pos += 1;
+		}
+	}
+	escape() {
+		const start = this.pos;
+		const c = this.text[start + 1] ?? "";
+		if (c === "u") {
+			const hex = this.text.slice(start + 2, start + 6);
+			if (!/^[0-9A-Fa-f]{4}$/.test(hex)) return this.stop("The escape \\u needs four hex digits.", start, 2);
+			this.pos += 6;
+			return String.fromCharCode(Number.parseInt(hex, 16));
+		}
+		const out = Object.hasOwn(ESCAPES, c) ? ESCAPES[c] : void 0;
+		if (out === void 0) return this.stop(`The escape \\${c} is not valid.`, start, 2);
+		this.pos += 2;
+		return out;
+	}
+	group() {
+		const open = this.pos;
+		this.pos += 1;
+		const inner = this.expr(0);
+		this.skip();
+		if (this.text[this.pos] !== ")") {
+			if (this.pos >= this.text.length) this.stop("A closing parenthesis is missing.", open, 1);
+			this.stop("A closing parenthesis is missing.", this.pos, this.tokenLength());
+		}
+		this.pos += 1;
+		return inner;
+	}
+	/** This method reads a name in backticks. Two backticks in the name are one backtick. */
+	quoted() {
+		const start = this.pos;
+		let out = "";
+		this.pos += 1;
+		for (;;) {
+			const c = this.text[this.pos];
+			if (c === void 0) return this.stop("A closing backtick is missing.", start, this.text.length - start);
+			if (c === "`") {
+				if (this.text[this.pos + 1] !== "`") {
+					this.pos += 1;
+					return out;
+				}
+				this.pos += 1;
+			}
+			out += c;
+			this.pos += 1;
+		}
+	}
+	/** This method reads a name: a word operator, a call, a literal word or a reference. */
+	named() {
+		const start = this.pos;
+		const plain = this.text[start] !== "`";
+		const first = plain ? this.at(NAME_AT) : this.quoted();
+		if (plain) {
+			this.pos += first.length;
+			const prefix = this.syn.prefix.get(first);
+			if (prefix !== void 0 && prefix.word) return opDoc(prefix, [this.expr(prefix.prec + 1)]);
+			if (this.syn.binary.get(first)?.word === true) this.stop(`A term is missing before ${first}.`, start, first.length);
+		}
+		const path = [first];
+		let allPlain = plain;
+		for (;;) {
+			const back = this.pos;
+			this.skip();
+			if (!this.syn.fields || this.text[this.pos] !== ".") {
+				this.pos = back;
+				break;
+			}
+			this.pos += 1;
+			this.skip();
+			if (this.text[this.pos] === "`") {
+				path.push(this.quoted());
+				allPlain = false;
+				continue;
+			}
+			const name = this.at(NAME_AT);
+			const digits = name === void 0 ? this.at(DIGITS_AT) : void 0;
+			if (name === void 0 && digits === void 0) this.stop("A name is missing after the dot.", this.pos, 0);
+			this.pos += (name ?? digits).length;
+			path.push(name ?? Number(digits));
+			if (name === void 0) allPlain = false;
+		}
+		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);
+			return this.call(path.join("."), start, back - start);
+		}
+		this.pos = back;
+		if (plain && path.length === 1 && this.syn.words.has(first)) return literalDoc(this.syn.words.get(first));
+		return {
+			type: "ref",
+			value: plain && this.syn.roots.has(first) ? path : [this.syn.bare, ...path]
+		};
+	}
+	call(name, start, nameLength) {
+		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));
+			this.skip();
+			if (this.text.startsWith(this.syn.separator, this.pos)) {
+				this.pos += this.syn.separator.length;
+				continue;
+			}
+			if (this.text[this.pos] === ")") {
+				this.pos += 1;
+				break;
+			}
+			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());
+		}
+		const form = this.syn.forms.get(name);
+		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);
+			const value = {};
+			args.forEach((arg, index) => {
+				value[form.fields?.[index]] = arg;
+			});
+			return opDoc(form, value);
+		}
+		if (this.syn.ops !== true && !this.syn.ops.has(name)) this.stop(`This syntax has no function ${name}.`, start, nameLength);
+		return {
+			type: ["ops", ...name.split(".")],
+			value: args
+		};
+	}
+};
+/**
+* This function reads a text into a document with the rules of a profile (SYNTAX.PARSE). It does not throw for a
+* bad text. The issue gives the offset, the length and a message (SYNTAX.SPAN).
+*
+* @param profile - The syntax profile.
+* @param text - The text.
+* @returns The document, or the issues of the text.
+* @throws {TypeError} The profile is not valid, for example an operator has two entries of the same place.
+*/
+function parse(profile, text) {
+	const parser = new Parser(compileProfile(profile), text);
+	try {
+		return {
+			ok: true,
+			doc: parser.parse()
+		};
+	} catch (error) {
+		if (error instanceof Stop) return {
+			ok: false,
+			issues: [error.issue]
+		};
+		if (isStackOverflow(error)) return {
+			ok: false,
+			issues: [{
+				offset: parser.position(),
+				length: 0,
+				message: "The text is too deep for the stack of the host."
+			}]
+		};
+		throw error;
+	}
+}
+function none(reason) {
+	return {
+		tag: "none",
+		reason
+	};
+}
+function quoteName(name) {
+	return `\`${name.replaceAll("`", "``")}\``;
+}
+function wordFor(syn, value) {
+	for (const [word, held] of syn.words) if (Object.is(held, value)) return word;
+}
+function textOfString(syn, value) {
+	const quote = syn.quote;
+	if (quote === void 0) return void 0;
+	if (syn.doubled) return `${quote}${value.replaceAll(quote, quote + quote)}${quote}`;
+	const json = JSON.stringify(value);
+	return quote === "\"" ? json : `'${json.slice(1, -1).replaceAll("\\\"", "\"").replaceAll("'", "\\'")}'`;
+}
+function textOfNumber(syn, value) {
+	if (!syn.numbers) return wordFor(syn, value);
+	const negative = value < 0 || Object.is(value, -0);
+	if (negative && !syn.signed) return wordFor(syn, value);
+	if (Number.isFinite(value)) return negative ? `-${String(-value)}` : String(value);
+	return wordFor(syn, value) ?? (Number.isNaN(value) ? void 0 : negative ? "-1e999" : "1e999");
+}
+function literalShape(syn, value) {
+	const text = typeof value === "string" ? textOfString(syn, value) : typeof value === "number" ? textOfNumber(syn, value) : wordFor(syn, value);
+	return text === void 0 ? none(`This syntax has no text for the literal ${describe(value)}.`) : {
+		tag: "text",
+		text
+	};
+}
+function plainSegment(syn, name) {
+	return NAME.test(name) && !syn.reserved.has(name) && !syn.patterns.some((p) => p.whole.test(name));
+}
+function laterSegment(step) {
+	if (typeof step === "string") return NAME.test(step) ? step : quoteName(step);
+	return typeof step === "number" && Number.isSafeInteger(step) && step >= 0 ? String(step) : void 0;
+}
+function refShape(syn, value) {
+	if (!Array.isArray(value) || value.length === 0) return none("The path of the reference is empty.");
+	for (const pattern of syn.patterns) {
+		const text = pattern.write(value);
+		if (text !== void 0) return {
+			tag: "text",
+			text
+		};
+	}
+	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))) {
+		first = root;
+		tail = rest.map(laterSegment);
+	}
+	if (first === void 0 || tail.includes(void 0)) return none("This syntax has no text for the path of the reference.");
+	return {
+		tag: "text",
+		text: [first, ...tail].join(".")
+	};
+}
+function callName(syn, keys) {
+	if (keys.length === 0 || !keys.every((key) => typeof key === "string" && NAME.test(key))) return void 0;
+	const name = keys.join(".");
+	if (syn.forms.has(name) || syn.opWords.has(keys[0])) return void 0;
+	return syn.ops === true || syn.ops.has(name) ? name : void 0;
+}
+function formShape(form, value) {
+	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])
+		};
+	}
+	if (!isRecord(value)) return void 0;
+	const count = Object.keys(value).length;
+	const present = form.fields.slice(0, count);
+	if (count < form.min || present.length < count || !present.every((key) => Object.hasOwn(value, key))) return void 0;
+	return {
+		tag: "call",
+		name: form.name,
+		args: present.map((key) => [key, value[key]])
+	};
+}
+function opShape(syn, key, terms) {
+	for (const op of syn.byKind.get(key) ?? []) if (op.fixity === "infix" ? terms.length === 2 || op.assoc === "flat" && terms.length > 2 : terms.length === 1) return {
+		tag: "op",
+		op,
+		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.");
+	const path = typePath(doc.type);
+	if (path === void 0) return none("This syntax has no text for a computed type.");
+	const value = doc.value;
+	const name = path.join(".");
+	if (name === "lit") return isEnvelope(value) || Array.isArray(value) || isRecord(value) ? none("This syntax has no text for a list or a record literal.") : literalShape(syn, value);
+	if (name === "ext.undefined") return literalShape(syn, void 0);
+	if (name === "ext.number") {
+		const numbers = {
+			NaN: NaN,
+			Infinity: Number.POSITIVE_INFINITY,
+			"-Infinity": Number.NEGATIVE_INFINITY,
+			"-0": -0
+		};
+		return typeof value === "string" && Object.hasOwn(numbers, value) ? literalShape(syn, numbers[value]) : none("The value of ext.number is not valid.");
+	}
+	if (name === "ref") return refShape(syn, value);
+	const key = JSON.stringify(path);
+	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);
+		if (shape !== void 0) return shape;
+	}
+	const called = path[0] === "ops" && Array.isArray(value) ? callName(syn, path.slice(1)) : void 0;
+	if (called !== void 0) return {
+		tag: "call",
+		name: called,
+		args: value.map((item, index) => [index, item])
+	};
+	return none(`This syntax has no text for the kind ${name}.`);
+}
+function levelOf(syn, doc) {
+	const shape = shapeOf(syn, doc);
+	return shape.tag === "op" ? shape.op.prec : 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) {
+	if (op.fixity === "postfix") return level < op.prec;
+	if (op.fixity === "prefix" || op.assoc === "none" || op.assoc === "flat") return level <= op.prec;
+	return (op.assoc === "left" ? index === 0 : index !== 0) ? level < op.prec : level <= op.prec;
+}
+function opText(syn, op, terms, sub) {
+	const texts = [];
+	for (let index = 0; index < terms.length; index += 1) {
+		const term = terms[index];
+		const result = sub(term, [index]);
+		if (!result.ok) return result;
+		let text = result.value;
+		const signedDigit = op.fixity === "prefix" && op.symbol === "-" && syn.signed && /^[0-9]/.test(text);
+		if (needsGroup(op, index, levelOf(syn, term)) || signedDigit) text = `(${text})`;
+		texts.push(text);
+	}
+	const [only = ""] = texts;
+	if (op.fixity === "prefix") return ok(op.word || /^[^A-Za-z0-9_("'`$]/.test(only) ? `${op.symbol} ${only}` : `${op.symbol}${only}`);
+	if (op.fixity === "postfix") return ok(op.word ? `${only} ${op.symbol}` : `${only}${op.symbol}`);
+	return ok(texts.join(` ${op.symbol} `));
+}
+/** This function writes one document. `sub` gives the text of each part. */
+function printNode(syn, doc, sub) {
+	const shape = shapeOf(syn, doc);
+	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);
+	const texts = [];
+	for (const [key, arg] of shape.args) {
+		const result = sub(arg, [key]);
+		if (!result.ok) return result;
+		texts.push(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]));
+	return result.ok || result.error.place !== void 0 ? result : fail(result.error.code, result.error.reason, { 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).
+*
+* @param profile - The syntax profile.
+* @param doc - The document.
+* @returns The text, or `#VALUE!` at the place of a document that the profile cannot write.
+* @throws {TypeError} The profile is not valid.
+*/
+function print(profile, doc) {
+	const syn = compileProfile(profile);
+	try {
+		return printTree(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;
+	}
+}
+/**
+* This function makes the part of a merge that adds the verb `format` to a machine (D23, D41). Its default writes
+* each document with the printer of the profile. A part gives its own text through the ladder, thus an own entry or
+* a kind entry of `format` still wins.
+*
+* @param profile - The syntax profile.
+* @returns The part for `mergeMachines`.
+*/
+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) => {
+			const part = byPath.get(JSON.stringify(path));
+			if (part === void 0) return printTree(syn, child, [...place, ...path]);
+			const result = part.evaluate();
+			if (!result.ok) return result;
+			return typeof result.value === "string" ? ok(result.value) : fail("#VALUE!", `The verb format of a part gave ${describe(result.value)}, not a text.`, { place: [...place, ...path] });
+		});
+	};
+	return {
+		world: { defaults: { format: "syntax.format" } },
+		evaluators: { "syntax.format": code }
+	};
+}
+//#endregion
 //#region src/reference.ts
 function own$1(table, name) {
 	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
@@ -6849,13 +8360,22 @@ function examine$1(env, at) {
 		split
 	};
 }
+/**
+* This function gives the effects that two lists of capabilities both permit (CAP.ONLY). The reference reads the rule
+* from SPEC directly, and not from the intersection of the plan. Thus `agree` finds a bug in either one (D15).
+*/
+function bothPermit(a, b) {
+	const out = [];
+	for (const cap of [...a, ...b]) if (permits(a, cap) && permits(b, cap) && !permits(out, cap)) out.push(cap);
+	return out;
+}
 /** This function gives the capabilities that the rules of a kind give one part (D14, CAP.CONTRACT, CAP.ONLY). */
 function capsOfPart(rules, path, caps) {
 	let out = caps;
 	for (const rule of rules ?? []) {
 		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(path, pattern))) continue;
 		if (rule.rule === "mask") return [];
-		if (rule.rule === "only") out = intersectCaps(out, rule.caps);
+		if (rule.rule === "only") out = bothPermit(out, rule.caps);
 	}
 	return out;
 }
@@ -7008,6 +8528,7 @@ function evalInput(env, seen, at) {
 		parts,
 		context: at.ctx,
 		place: at.place,
+		machine: env.machine,
 		...at.address ? { address: true } : {},
 		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
 		effect: (kind, payload) => cause(env, at.ctx, kind, payload, at.place),
@@ -7035,6 +8556,7 @@ function runInput(env, seen, at) {
 		parts,
 		context: at.ctx,
 		place: at.place,
+		machine: env.machine,
 		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
 		effect: function* (kind, payload) {
 			return cause(env, at.ctx, kind, payload, at.place);
@@ -7125,6 +8647,7 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		...context,
 		world: worldThing(machine.world)
 	} : context;
+	activeEnvs.push(env);
 	try {
 		return evaluateAt(env, {
 			value: doc,
@@ -7136,8 +8659,12 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		});
 	} catch (error) {
 		return placed(thrown(error, "the reference"), []);
+	} finally {
+		activeEnvs.pop();
 	}
 }
+/** The evaluations of the reference that run at this time, the innermost last. */
+const activeEnvs = [];
 const refNodes = /* @__PURE__ */ new WeakMap();
 /** The attributes in evaluation in the reference, in the order of their demands (TREE.CYCLE). */
 const inEvaluation = [];
@@ -7147,28 +8674,109 @@ function nameOfAttribute(node, name) {
 function refNodeOf(thing) {
 	return typeof thing === "object" && thing !== null ? refNodes.get(thing) : void 0;
 }
-/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when the node has no such part. */
-function attributeOf(node, self, name) {
+/**
+* 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.
+*/
+function equationOf(node, term, names) {
+	const env = node.env;
+	if (env === void 0) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
+	const ctx = {
+		...node.ctx,
+		names,
+		caps: [],
+		self: node.thing
+	};
+	return reference(env.machine, term, ctx, {
+		definitions: env.definitions,
+		...node.of === void 0 ? {} : { declaredType: node.of }
+	});
+}
+function termIn(table, name) {
+	return table === void 0 || !Object.hasOwn(table, name) ? void 0 : table[name];
+}
+/** TREE.DOWN: the names of a child for an equation of `down` of its parent: `child`, `index` and `prev`. */
+function namesOfChild(up, child) {
+	const children = attributeOf(up, "children");
+	if (children !== void 0 && !children.ok) return children;
+	const list = children !== void 0 && Array.isArray(children.value) ? children.value : [];
+	const index = list.indexOf(child.thing);
+	return ok({
+		child: child.thing,
+		index: index < 0 ? null : index,
+		prev: index > 0 ? list[index - 1] : null
+	});
+}
+/** TREE.FOLD: the unit, then `combine` with the attribute of each node of this tree in the list `children`. */
+function foldOf(node, name, fold) {
+	let acc = equationOf(node, fold.unit, {});
+	if (!acc.ok) return acc;
+	const children = attributeOf(node, "children");
+	if (children === void 0) return acc;
+	if (!children.ok) return children;
+	if (!Array.isArray(children.value)) return fail("#VALUE!", `The fold of ${name} needs a list in children.`);
+	for (const item of children.value) {
+		const child = refNodeOf(item);
+		if (child === void 0 || child.tree !== node.tree) continue;
+		const value = attributeOf(child, name);
+		if (value === void 0) return fail("#N/A", `No rung gives ${nameOfAttribute(child, name)}.`);
+		if (!value.ok) return value;
+		acc = equationOf(node, fold.combine, {
+			acc: acc.value,
+			item: value.value
+		});
+		if (!acc.ok) return acc;
+	}
+	return acc;
+}
+/**
+* TREE.LADDER: the rungs of the ladder of an attribute, in their order. A rung gives `undefined` when it does not
+* answer, and the next rung then tries.
+*/
+const REF_RUNGS = [
+	["own", (node, name) => node.parts.find((item) => item.key === name)?.evaluate({
+		...node.ctx,
+		self: node.thing
+	})],
+	["kind", (node, name) => {
+		const term = termIn(node.contract?.equations, name);
+		return term === void 0 ? void 0 : equationOf(node, term, {});
+	}],
+	["parent", (node, name) => {
+		const up = node.up;
+		const term = up === void 0 ? void 0 : termIn(up.contract?.down, name);
+		if (up === void 0 || term === void 0) return void 0;
+		const names = namesOfChild(up, node);
+		return names.ok ? equationOf(up, term, names.value) : names;
+	}],
+	["copy", (node, name) => node.up !== void 0 && termIn(node.contract?.attributes, name)?.copy === true ? attributeOf(node.up, name) : void 0],
+	["default", (node, name) => {
+		const declared = termIn(node.contract?.attributes, name);
+		if (declared?.fold !== void 0) return foldOf(node, name, declared.fold);
+		return declared?.default === void 0 ? void 0 : equationOf(node, declared.default, {});
+	}]
+];
+/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when no rung of its ladder answers. */
+function attributeOf(node, name) {
 	const done = node.values.get(name);
 	if (done !== void 0) return done;
 	if (node.pending.has(name)) {
 		const from = inEvaluation.findIndex((entry) => entry.node === node && entry.name === name);
 		return fail("#CYCLE!", `The attributes form a cycle: ${[...from < 0 ? [nameOfAttribute(node, name)] : inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name)), nameOfAttribute(node, name)].join(" -> ")}.`);
 	}
-	const part = node.parts.find((item) => item.key === name);
-	if (part === void 0) return void 0;
 	node.pending.add(name);
 	inEvaluation.push({
 		node,
 		name
 	});
 	try {
-		const result = part.evaluate({
-			...node.ctx,
-			self
-		});
-		node.values.set(name, result);
-		return result;
+		for (const [, rung] of REF_RUNGS) {
+			const result = rung(node, name);
+			if (result === void 0) continue;
+			node.values.set(name, result);
+			return result;
+		}
+		return;
 	} finally {
 		node.pending.delete(name);
 		inEvaluation.pop();
@@ -7178,7 +8786,7 @@ function attributeOf(node, self, name) {
 function jsonOfNode(node, self, open) {
 	const record = {};
 	for (const part of node.parts) {
-		const result = attributeOf(node, self, part.key);
+		const result = attributeOf(node, part.key);
 		if (!result.ok) return result;
 		const value = plainValue(result.value, [...open, self]);
 		if (!value.ok) return value;
@@ -7216,15 +8824,23 @@ function plainValue(value, open) {
 * TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
 * tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error.
 */
-const treeDefinition = ({ parts, context, kind, place }) => {
+const treeDefinition = ({ parts, context, kind, place, machine, typePath }) => {
 	const outer = refNodeOf(context.self);
 	const nested = outer !== void 0 && outer.tree.open;
+	const found = machine === void 0 || typePath.length === 0 ? void 0 : lookupKind(machine.world, typePath);
+	const contract = found?.ok === true ? found.kind.tree : void 0;
+	const of = contract === void 0 || found?.ok !== true ? void 0 : equationType(found.kind);
 	const node = {
 		tree: nested ? outer.tree : { open: true },
 		kind,
 		place,
 		parts,
 		ctx: context,
+		contract,
+		of,
+		up: nested ? outer : void 0,
+		env: activeEnvs[activeEnvs.length - 1],
+		thing: null,
 		values: /* @__PURE__ */ new Map(),
 		pending: /* @__PURE__ */ new Set()
 	};
@@ -7235,17 +8851,18 @@ const treeDefinition = ({ parts, context, kind, place }) => {
 		deref: (key) => {
 			if (key === "parent") return context.self;
 			if (key === "type") return kind;
-			const result = attributeOf(node, self, String(key));
+			const result = attributeOf(node, String(key));
 			if (result === void 0 || result.ok) return result?.ok === true ? result.value : void 0;
 			throw new Failure(result.error);
 		},
-		has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)),
+		has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)) || node.values.has(String(key)),
 		toJson: () => {
 			const result = jsonOfNode(node, self, []);
 			if (result.ok) return result.value;
 			throw new Failure(result.error);
 		}
 	};
+	node.thing = self;
 	refNodes.set(self, node);
 	if (nested) return ok(self);
 	try {
@@ -7437,12 +9054,12 @@ function formulaDefinitions(profile = {}) {
 			return thrown(error, `the operation ${name}`);
 		}
 	};
-	const ext = ({ typePath, doc, context }) => {
+	const ext = ({ typePath, doc, context, machine }) => {
 		const name = typePath.slice(1).join(".");
 		const handler = own$1(profile.ext, name) ?? own$1(STD_EXT, name);
 		if (handler === void 0) return fail("#NAME?", `The language has no extension ${name}.`);
 		try {
-			return handler(doc.value, context);
+			return handler(doc.value, context, machine?.domains);
 		} catch (error) {
 			return thrown(error, `the extension ${name}`);
 		}
@@ -7477,6 +9094,13 @@ function valuesOfStrict(parts) {
 }
 //#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"
+]);
 /**
 * 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
@@ -7566,7 +9190,11 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 	};
 	const observe = options.observe;
 	observe?.();
-	const plan = prepare(machine, doc, declared);
+	const folds = observe === void 0;
+	const plan = prepare(machine, doc, {
+		...declared,
+		fold: folds
+	});
 	const effects = [];
 	const result = plan.evaluate(context, {
 		effects,
@@ -7579,11 +9207,7 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 		if (why !== void 0 || observe === void 0) return why;
 		return sameValue(saw, observe(), options.equal) ? void 0 : "The host saw other calls in the tier.";
 	};
-	for (const tier of options.tiers ?? [
-		"reference",
-		"traced",
-		"again"
-	]) {
+	for (const tier of options.tiers ?? DEFAULT_TIERS) {
 		let other;
 		let otherEffects = [];
 		if (tier === "reference") other = reference(machine, doc, context, {
@@ -7599,6 +9223,27 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 			});
 			other = traced.result;
 			otherEffects = [...traced.effects];
+		} else if (tier === "folds") {
+			other = prepare(machine, doc, {
+				...declared,
+				fold: !folds
+			}).evaluate(context, {
+				effects: otherEffects,
+				...mock
+			});
+			if (observe !== void 0) {
+				observe();
+				if (overflowed(result) || overflowed(other)) continue;
+				const why = resultDiffers(result, other, options) ?? effectsDiffer(effects, otherEffects, options);
+				if (why !== void 0) return {
+					ok: false,
+					tier,
+					plan: result,
+					other,
+					reason: why
+				};
+				continue;
+			}
 		} else other = plan.evaluate(context, {
 			effects: otherEffects,
 			...mock
@@ -8633,6 +10278,7 @@ function instanceOf(env, under, doc, split, sample) {
 		doc,
 		data: split.data,
 		place: PLACE,
+		machine: env.machine,
 		fill
 	};
 	const who = `the ${env.runner ? "runner" : "evaluator"} ${env.name}`;
@@ -10244,6 +11890,6 @@ function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
 //#endregion
-export { 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_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, entriesAsJson, 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, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, 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, agree, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, print, random, recorder, ref, reference, 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