@mark1russell7/coeval 0.7.1 → 0.9.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.
@@ -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",
@@ -2060,7 +2071,7 @@ function context(parts = {}) {
 	};
 }
 const MAX_COLLAPSE = 64;
-const NO_HOPS = /* @__PURE__ */ Object.freeze([]);
+const NO_HOPS$1 = /* @__PURE__ */ Object.freeze([]);
 /** A value that can be a reference document: a record with the type `ref`. The full check comes after. */
 function mayBeRef(thing) {
 	return typeof thing === "object" && thing !== null && thing.type === "ref";
@@ -2111,13 +2122,13 @@ function walkQuick(start, path, plain, keyed) {
 				ok: false,
 				code: "#N/A",
 				reason: `The path ${keys.join(".")} reaches nothing.`,
-				hops: NO_HOPS
+				hops: NO_HOPS$1
 			};
 			if (!plain && mayBeRef(reached.thing)) return void 0;
 			return {
 				ok: true,
 				thing: reached.thing,
-				hops: NO_HOPS
+				hops: NO_HOPS$1
 			};
 		}
 		const step = path[index];
@@ -2134,7 +2145,7 @@ function walkQuick(start, path, plain, keyed) {
 	return {
 		ok: true,
 		thing: here,
-		hops: NO_HOPS
+		hops: NO_HOPS$1
 	};
 }
 /** The root whose value starts the short path of a compiled path. `FULL` takes the full algorithm at once. */
@@ -2245,7 +2256,7 @@ function resolve(nav, ctx, path, options = {}) {
 * @returns What the path reached and each hop, or an error.
 */
 function resolveFully$1(nav, ctx, path, hops, known) {
-	const done = hops ?? NO_HOPS;
+	const done = hops ?? NO_HOPS$1;
 	const failed = (code, reason) => ({
 		ok: false,
 		code,
@@ -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);
 	}
@@ -2970,6 +3054,7 @@ var Session = class {
 		if (reading === void 0) return this.find(ctx, path, compiled, hops);
 		const free = isFree(reading.root, ctx, path);
 		if (!free && path[0] === "self" && !reading.self) this.keep(reading, ["self"]);
+		else if (free && path.length === 1 && path[0] === "self") reading.self = true;
 		let found;
 		try {
 			found = this.find(ctx, path, compiled, hops);
@@ -3416,6 +3501,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 +3512,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 +3523,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 +3545,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 +3574,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
@@ -3650,12 +3970,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 {
@@ -3753,8 +4075,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.
@@ -3969,6 +4291,7 @@ const STD_WORLD = {
 			caps: [{ rule: "mask" }],
 			pure: true,
 			lazy: [{}],
+			reads: ["self"],
 			summary: "A node of a tree. Each part is an attribute that evaluates on demand, one time, with the node as self."
 		},
 		box: {
@@ -3988,6 +4311,7 @@ const STD_WORLD = {
 			caps: [{ rule: "mask" }],
 			pure: true,
 			lazy: [{}],
+			reads: ["self"],
 			summary: "A node of a tree, as panel. A formula in a box can read its parent and its siblings."
 		},
 		math: { kinds: {
@@ -4112,6 +4436,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 = [];
@@ -4179,28 +4553,93 @@ 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.
-*/
-function treeThing(parts, context, type, place, build) {
+* 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.
+* The argument `outer` is the self of the context, that `treeNode` resolved. The node reads no root of the context directly (C4).
+*/
+function treeThing(input, build, outer) {
+	const { parts, context, kind: type, place, machine } = input;
+	const { tree, of } = contractOf$1(machine, input.typePath);
+	const above = stateOf(outer);
+	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;
@@ -4209,14 +4648,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 {
@@ -4240,7 +4725,7 @@ function treeThing(parts, context, type, place, build) {
 		type,
 		label: `node ${type}`,
 		deref(key) {
-			if (key === "parent") return context.self;
+			if (key === "parent") return outer;
 			if (key === "type") return type;
 			const result = read(String(key));
 			if (result === void 0) return void 0;
@@ -4248,7 +4733,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());
@@ -4259,14 +4746,32 @@ function treeThing(parts, context, type, place, build) {
 	return node;
 }
 /**
-* 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.
+* 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 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 attributeTrace(node, attribute) {
+	return stateOf(node)?.trace(attribute);
+}
+/** The path of the root `self`. A node of the tree resolves it, thus the list of reads holds the read (C4). */
+const SELF_PATH = /* @__PURE__ */ Object.freeze(["self"]);
+/** The options of the resolution of `self`: the node needs no hops. */
+const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
+/**
+* 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. The
+* node reads `self` through `resolve` (C4, D44). A machine that closes the root `self` thus gives no nested trees.
+*/
+function treeNode(input) {
+	const found = input.resolve(SELF_PATH, NO_HOPS);
+	const outer = found.ok ? found.thing : void 0;
+	const above = stateOf(outer);
+	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build, outer));
 	const build = { open: true };
-	const root = treeThing(parts, context, kind, place, build);
+	const root = treeThing(input, build, outer);
 	try {
 		return stateOf(root).json(/* @__PURE__ */ new Set());
 	} finally {
@@ -5009,75 +5514,6 @@ 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;
-}
-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` 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. */
@@ -5422,11 +5858,141 @@ function typeCheck(machine, doc, options = {}) {
 		places: pass.places
 	};
 }
+/** This function tells if a table of verbs has an entry for a verb. */
+function hasVerb(table, verb) {
+	return table !== void 0 && Object.hasOwn(table, verb);
+}
+/**
+* This function checks the world of a machine before a document exists. It finds each kind that has no entry for a
+* verb of the list, when the world has no default for that verb (STATIC.COVERAGE). A document of such a kind gets no
+* evaluator for the verb, thus the check gives the same proof of coverage as a type system.
+*
+* The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
+* world. It does not follow an alias, because the kind of an alias has its own place. The check reads only the world.
+*
+* @param machine - The machine, for its world.
+* @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
+* @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
+*   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
+*/
+function checkWorld(machine, verbs) {
+	const world = machine.world;
+	const open = verbs.filter((verb) => !hasVerb(world.defaults, verb));
+	const out = [];
+	if (open.length === 0) return out;
+	const visit = (kind, path, fallback) => {
+		const text = path.join(".");
+		const name = fallback ? path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}` : `the kind ${text}`;
+		for (const verb of open) {
+			if (hasVerb(kind.verbs, verb)) continue;
+			const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
+			out.push(fallback ? {
+				code: "#NOEVAL",
+				kind: path,
+				fallback: true,
+				verb,
+				reason
+			} : {
+				code: "#NOEVAL",
+				kind: path,
+				verb,
+				reason
+			});
+		}
+	};
+	const way = /* @__PURE__ */ new Set();
+	const entries = (kinds, path) => {
+		for (const key of Object.keys(kinds)) {
+			const entry = kinds[key];
+			const here = [...path, key];
+			if (isKind(entry)) visit(entry, here, false);
+			else if (isNamespace(entry) && !way.has(entry)) {
+				way.add(entry);
+				entries(entry.kinds, here);
+				if (entry.fallback !== void 0) visit(entry.fallback, here, true);
+				way.delete(entry);
+			}
+		}
+	};
+	entries(world.kinds, []);
+	if (world.fallback !== void 0) visit(world.fallback, [], true);
+	return out;
+}
+/** 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();
@@ -5478,6 +6044,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);
@@ -5675,7 +6249,8 @@ function partLazy(above, parent, slot) {
 * by the contracts of its kinds:
 *
 * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
-*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`.
+*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
+*   declares `reads` adds a read of each of its roots at each document of the kind.
 * - `side` and `effects`: from the contract of each kind.
 * - `pure`: each kind declares `pure`, and the document has no effect and is not volatile.
 * - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
@@ -5728,18 +6303,35 @@ function factsOf(machine, doc, options = {}) {
 		}
 		const code = codeOf(world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
 		const answer = code.name === void 0 ? void 0 : hook?.(v.typePath ?? [], code.name);
+		let roots;
 		if (code.described) {
 			note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
 			above.set(v, {
 				lazy,
 				rules: answer?.lazy ?? kind.lazy
 			});
+			roots = answer?.reads ?? kind.reads;
 		} else {
 			note(answer?.pure, answer?.volatile);
 			above.set(v, {
 				lazy,
 				rules: answer?.lazy ?? EACH$1
 			});
+			roots = answer?.reads;
+		}
+		for (const root of roots ?? NONE) {
+			const read = {
+				root,
+				keys: NONE,
+				exact: true,
+				lazy,
+				address: false,
+				path: [root],
+				place: tight(v.place),
+				at: tight(v.at)
+			};
+			reads.push(read);
+			if (options.volatile?.(read) === true) volatile = true;
 		}
 		if (kind.side === "run") side = "run";
 		for (const keys of declaredEffects(v)) {
@@ -6557,22 +7149,110 @@ function formulaTypes(profile) {
 * This function makes the evaluators of the formula kit for one language. Each evaluator compiles its document
 * one time into code. Each evaluator also holds its type rule, for a check of types (TYPE.SYNTH).
 *
+* Equal profiles give the same evaluator objects (COMPOSE.UNIFY, D46). Thus two machines of one profile merge without
+* a conflict. Each call gives a new record. Each evaluator object is frozen, because many machines can share it.
+*
 * @param profile - The operations and the rules of the language.
 * @returns The evaluators, by their name.
 */
 function formulaEvaluators(profile = {}) {
+	return { ...kitOf(profile).evaluators };
+}
+/** This function makes new evaluators of the formula kit for the fields of one profile. */
+function makeEvaluators(profile) {
 	const evaluators = formulaCode(profile);
 	const types = formulaTypes(profile);
 	const out = {};
 	for (const name of Object.keys(evaluators)) {
 		const evaluator = evaluators[name];
 		const type = Object.hasOwn(types, name) ? types[name] : void 0;
-		out[name] = type === void 0 ? evaluator : {
+		out[name] = Object.freeze(type === void 0 ? evaluator : {
 			compile: evaluator.compile,
 			type
+		});
+	}
+	return Object.freeze(out);
+}
+/** The keys of a profile that the kit reads. The kit ignores each other key. */
+const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
+	"ops",
+	"lazy",
+	"ext",
+	"truthy",
+	"otherwise",
+	"logic",
+	"omit",
+	"missing",
+	"check",
+	"combine",
+	"pure",
+	"volatile",
+	"sigs"
+]);
+/** The number of recent kits that a profile in a new object can find by its fields. */
+const RECENT_KITS = 16;
+/** The kit of each profile object. A kit goes when its profile object goes. */
+const kitsByProfile = /* @__PURE__ */ new WeakMap();
+/** The recent kits, the most recent first. The list holds `RECENT_KITS` kits or fewer. */
+const recentKits = [];
+/**
+* This function gives the canonical form of a profile: a frozen record of the fields that the kit reads. A field
+* with the value `undefined` is absent, but `otherwise` is present when the profile has it as an own key. A list
+* is a frozen copy. Each other value stays the same object.
+*/
+function fieldsOf(profile) {
+	const out = {};
+	for (const key of PROFILE_KEYS) {
+		if (key === "otherwise" ? !Object.hasOwn(profile, key) : profile[key] === void 0) continue;
+		const value = profile[key];
+		out[key] = Array.isArray(value) ? Object.freeze([...value]) : value;
+	}
+	return Object.freeze(out);
+}
+/**
+* This function tells if two canonical forms are equal. They must have the same keys. A function, a record and a host
+* value are equal only to themselves. Two lists are equal when their items are the same, in order.
+*/
+function sameFields(a, b) {
+	const left = a;
+	const right = b;
+	const keys = Object.keys(left);
+	if (keys.length !== Object.keys(right).length) return false;
+	return keys.every((key) => {
+		if (!Object.hasOwn(right, key)) return false;
+		const x = left[key];
+		const y = right[key];
+		if (Object.is(x, y)) return true;
+		return Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.every((item, index) => Object.is(item, y[index]));
+	});
+}
+/**
+* This function gives the kit of a profile (D46). A profile object that the kit knows, with the same fields, gives its
+* kit. Then a recent kit with equal fields serves a new profile object. Else the function makes a new kit from the
+* canonical form. Thus a later change of a field of the profile object gives a new kit, and an old kit does not change.
+*/
+function kitOf(profile) {
+	const fields = fieldsOf(profile);
+	const known = kitsByProfile.get(profile);
+	if (known !== void 0 && sameFields(known.fields, fields)) return known;
+	const index = recentKits.findIndex((kit) => sameFields(kit.fields, fields));
+	let kit;
+	if (index >= 0) {
+		kit = recentKits[index];
+		recentKits.splice(index, 1);
+	} else {
+		const hook = makeKnown(fields);
+		kit = {
+			fields,
+			evaluators: makeEvaluators(fields),
+			known: hook,
+			facts: makeFacts(fields, hook)
 		};
 	}
-	return out;
+	recentKits.unshift(kit);
+	if (recentKits.length > RECENT_KITS) recentKits.length = RECENT_KITS;
+	kitsByProfile.set(profile, kit);
+	return kit;
 }
 /** This function makes the code of the evaluators of the formula kit, without their type rules. */
 function formulaCode(profile) {
@@ -6891,10 +7571,16 @@ function formulaCode(profile) {
 * `formula.ext` knows an extension of `ext` and each standard extension. The hook knows each name of the other
 * evaluators.
 *
+* Equal profiles give the same hook (D46).
+*
 * @param profile - The operations and the extensions of the language.
 * @returns The hook: `true`, or the reason of the `#NAME?` that the evaluator gives in a run.
 */
 function formulaKnown(profile = {}) {
+	return kitOf(profile).known;
+}
+/** This function makes a new hook `known` for the fields of one profile. */
+function makeKnown(profile) {
 	const hasOp = (name) => {
 		if (profile.lazy !== void 0 && Object.hasOwn(profile.lazy, name)) return true;
 		const ops = profile.ops;
@@ -6928,13 +7614,18 @@ const EACH_PART = /* @__PURE__ */ Object.freeze([/* @__PURE__ */ Object.freeze({
 * - An operation is pure when the profile names it in `pure`, or when `pure` is `true`. A volatile operation is not pure.
 * - A standard extension is pure. An extension of the profile gets the context, thus it is not pure.
 *
+* Equal profiles give the same hook (D46).
+*
 * @param profile - The operations, the extensions and their facts.
 * @returns The hook: the facts of a name, or `undefined` for the facts of the contract.
 */
 function formulaFacts(profile = {}) {
+	return kitOf(profile).facts;
+}
+/** This function makes a new hook `facts` for the fields of one profile, with the hook `known` of the same fields. */
+function makeFacts(profile, known) {
 	const volatile = new Set(profile.volatile ?? []);
 	const pure = profile.pure === true ? void 0 : new Set(profile.pure ?? []);
-	const known = formulaKnown(profile);
 	return (path, code) => {
 		if (code !== "formula.op" && code !== "formula.ext") return void 0;
 		const name = path.slice(1).join(".");
@@ -6962,18 +7653,23 @@ function formulaFacts(profile = {}) {
 * The kit gives the domains of the kernel (`STD_DOMAINS`). Thus a domain of the language with the name `number` is a
 * conflict. The language names `["domains", "number"]` in `replaces` to replace it.
 *
+* Equal profiles give the same evaluators and the same hooks (COMPOSE.UNIFY, D46). Thus two machines of one profile
+* merge, also when each adds its own language. Two profiles with different fields give different evaluators, and
+* their machines conflict at each evaluator name of the kit.
+*
 * @param profile - The operations and the rules of the language.
 * @param more - The parts of a machine that the language adds, with the paths of the entries that it replaces.
 * @returns The machine.
 * @throws {MergeError} The language and the kit have a conflict.
 */
 function formulaMachine(profile = {}, more = {}) {
+	const kit = kitOf(profile);
 	return mergeMachines({
 		world: { kinds: formulaKinds() },
-		evaluators: formulaEvaluators(profile),
+		evaluators: { ...kit.evaluators },
 		domains: STD_DOMAINS,
-		known: formulaKnown(profile),
-		facts: formulaFacts(profile)
+		known: kit.known,
+		facts: kit.facts
 	}, more);
 }
 //#endregion
@@ -7857,13 +8553,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;
 }
@@ -8135,6 +8840,7 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		...context,
 		world: worldThing(machine.world)
 	} : context;
+	activeEnvs.push(env);
 	try {
 		return evaluateAt(env, {
 			value: doc,
@@ -8146,8 +8852,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 = [];
@@ -8157,28 +8867,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();
@@ -8188,7 +8979,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;
@@ -8224,17 +9015,28 @@ 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.
+* tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error. The node
+* reads `self` only through `resolve` (C4, TREE.SELF).
 */
-const treeDefinition = ({ parts, context, kind, place }) => {
-	const outer = refNodeOf(context.self);
+const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk }) => {
+	const reached = walk(["self"]);
+	const parent = reached.ok ? reached.thing : void 0;
+	const outer = refNodeOf(parent);
 	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()
 	};
@@ -8243,19 +9045,20 @@ const treeDefinition = ({ parts, context, kind, place }) => {
 		type: kind,
 		label: `node ${kind}`,
 		deref: (key) => {
-			if (key === "parent") return context.self;
+			if (key === "parent") return parent;
 			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 {
@@ -8487,6 +9290,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
@@ -8576,7 +9386,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,
@@ -8589,11 +9403,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, {
@@ -8609,6 +9419,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
@@ -11255,6 +12086,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_SYNTAX, STD_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, encodeValue, 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, 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 };
+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, checkWorld, 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