@mark1russell7/coeval 0.20.1 → 0.22.0

package/build/index.js

@@ -354,6 +354,11 @@ function describe(value) {
 	}
 }
 // src/world.ts
+/** The rule of the registry of binding names. */
+const NAMES_RULE = /* @__PURE__ */ Object.freeze({
+	ok: true,
+	names: true
+});
 /** The most rounds of a circular attribute without its own `limit` (TREE.CIRCULAR-LIMIT, D113). */
 const CIRCULAR_LIMIT = 100;
 /** This function tells if a value is JSON data: `null`, a truth value, a finite number, a text, or a container of them. */
@@ -403,6 +408,112 @@ function circularOf(declared) {
 	};
 }
 /**
+* This function reads the declaration `collect` of an attribute (D122). The tree kit, the reference, `check` and the
+* graph of attribute instances read it with this one function.
+*
+* @param declared - The value of the field `collect`.
+* @returns The rule of the collection, or the reason when the declaration has no correct form.
+*/
+function collectOf(declared) {
+	if (declared === "names") return NAMES_RULE;
+	if (!isRecord(declared) || !Object.hasOwn(declared, "unit") || !Object.hasOwn(declared, "combine")) return {
+		ok: false,
+		reason: "The declaration collect needs the text \"names\" or a record with the fields unit and combine."
+	};
+	return {
+		ok: true,
+		names: false,
+		unit: field(declared, "unit"),
+		combine: field(declared, "combine")
+	};
+}
+/**
+* This function reads an entry of the table `tree.at` (D124). The tree kit, the reference, `check` and the graph of
+* attribute instances read it with this one function.
+*
+* @param declared - The entry.
+* @returns The rule, or the reason when the entry has no correct form.
+*/
+function atRuleOf(declared) {
+	const params = isRecord(declared) ? field(declared, "params") : void 0;
+	if (!(Array.isArray(params) && params.every((name, index) => typeof name === "string" && params.indexOf(name) === index)) || !Object.hasOwn(declared, "equation")) return {
+		ok: false,
+		reason: "An entry of tree.at needs a list params of different texts and the field equation."
+	};
+	return {
+		ok: true,
+		params,
+		equation: field(declared, "equation")
+	};
+}
+/**
+* This function examines the arguments of a step `tree.at` (D124). The step gives an argument for each parameter, and
+* no other argument. Each argument is JSON data. The key is the text of `argsKey`, thus two equal arguments give one key.
+*
+* @param params - The parameters of the attribute.
+* @param args - The field `args` of the step.
+* @returns The names of the equation and the key, or the reason.
+*/
+function atArgsOf(params, args) {
+	if (!isRecord(args)) return {
+		ok: false,
+		reason: "The arguments are a record."
+	};
+	const extra = Object.keys(args).find((name) => !params.includes(name));
+	if (extra !== void 0) return {
+		ok: false,
+		reason: `The attribute has no parameter ${extra}.`
+	};
+	const names = {};
+	for (const name of params) {
+		if (!Object.hasOwn(args, name)) return {
+			ok: false,
+			reason: `The step gives no argument ${name}.`
+		};
+		const value = field(args, name);
+		if (argsKey(value) === void 0) return {
+			ok: false,
+			reason: `The argument ${name} is not JSON data.`
+		};
+		Object.defineProperty(names, name, {
+			value,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	return {
+		ok: true,
+		names,
+		key: argsKey(names)
+	};
+}
+/**
+* This function gives the key of a JSON value (D124). The fields of a record are in the order of their names. Two
+* values have the same key only when they are equal by DOC.EQUALS, thus `-0` and `0` have different keys.
+*
+* @param value - The value.
+* @returns The JSON text, or `undefined` for a value that is not JSON data: a number that is not finite, a host value or a cycle.
+*/
+function argsKey(value) {
+	return keyOf$1(value, /* @__PURE__ */ new Set());
+}
+function keyOf$1(value, open) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") return !Number.isFinite(value) ? void 0 : Object.is(value, -0) ? "-0" : JSON.stringify(value);
+	if (typeof value !== "object" || open.has(value) || !Array.isArray(value) && !isRecord(value)) return void 0;
+	open.add(value);
+	try {
+		const list = Array.isArray(value);
+		const names = list ? [] : Object.keys(value).sort();
+		const items = list ? value.map((item) => keyOf$1(item, open)) : names.map((name) => keyOf$1(field(value, name), open));
+		if (items.includes(void 0)) return void 0;
+		return list ? `[${items.join(",")}]` : `{${names.map((name, index) => `${JSON.stringify(name)}:${String(items[index])}`).join(",")}}`;
+	} finally {
+		open.delete(value);
+	}
+}
+/**
 * 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.
 *
@@ -1584,8 +1695,10 @@ function valueStep(value, key) {
 *
 * - A record gives the type of its field. A closed record without the field has no such step. An open record gives
 *   `unknown`.
-* - A list gives the type of its items for an index, and `number` for `length`.
-* - A base type reads the steps of its domain, then of each parent (`Domain.steps`).
+* - A list gives the type of its items for an index, and `number` for `length`. Another key has no such step.
+* - A base type reads the steps of its domain, then of each parent (`Domain.steps`). A base type of the kernel
+*   without such a step has no step, because its values are not objects (TYPE.NO-STEP, D120).
+* - A function type has no step, because a step into a function reaches nothing.
 * - A union joins the steps of its types. `one` gives the values that the step reaches.
 * - Each other step gives `unknown`, and `never` gives `never`.
 *
@@ -1604,10 +1717,11 @@ function stepType(type, key, domains, examine, depth = 0) {
 				const found = steps[name];
 				return { type: examine === void 0 ? found : examine(found, `type of the step ${name} of the domain ${each}`) };
 			}
-			return { type: "unknown" };
+			return Object.hasOwn(STD_DOMAINS, form.name) ? NO_STEP : { type: "unknown" };
+		case "fn": return NO_STEP;
 		case "list":
 			if (key === "length") return { type: "number" };
-			return { type: indexOf(key) >= 0 ? form.item : "unknown" };
+			return indexOf(key) >= 0 ? { type: form.item } : NO_STEP;
 		case "record":
 			if (Object.hasOwn(form.fields, name)) return { type: form.fields[name] };
 			return form.closed ? { missing: Object.keys(form.fields) } : { type: "unknown" };
@@ -1634,6 +1748,8 @@ function stepType(type, key, domains, examine, depth = 0) {
 		default: return { type: "unknown" };
 	}
 }
+/** The answer of `stepType` for a type whose members have no step with the key, and no fields to name. */
+const NO_STEP = { missing: [] };
 /**
 * This function lists the problems of a value type (TYPE.ISSUES). A problem is a term that is not a value type, a
 * base type without a domain, or a term that is too deep. `fits` and `member` read each such term as `unknown`.
@@ -3420,6 +3536,34 @@ function pathMatches(path, pattern) {
 	}
 	return true;
 }
+/**
+* This function tells if a list of rules in the form of the lazy rules covers a part (D24, D119). A rule without
+* `in` covers each part. With `after: n`, a rule covers only the parts after the first `n` parts that it matches.
+*
+* @param rules - The rules.
+* @param shape - The shape of the parts of the parent.
+* @param value - The value of the parent.
+* @param slot - The path of the part in the value.
+* @returns `true` when a rule covers the part.
+*/
+function rulesCover(rules, shape, value, slot) {
+	for (const rule of rules) {
+		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(slot, pattern))) continue;
+		const after = rule.after ?? 0;
+		if (after <= 0) return true;
+		const split = splitParts(shape, value);
+		let count = 0;
+		for (const part of split.ok ? split.parts : []) {
+			if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(part.path, pattern))) continue;
+			if (part.path.length === slot.length && pathMatches(part.path, slot)) {
+				if (count >= after) return true;
+				break;
+			}
+			count += 1;
+		}
+	}
+	return false;
+}
 function valueAt(value, path) {
 	let here = value;
 	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
@@ -4583,6 +4727,7 @@ function pureCode(c, envelope, kind, typePath, name, quick) {
 	} catch {
 		return false;
 	}
+	if (answer?.effects !== void 0 && answer.effects.length > 0) 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;
@@ -5425,6 +5570,24 @@ const STD_WORLD = {
 			pure: true,
 			summary: "A step of a path: it follows a key again and again, until it reaches a node of a type."
 		},
+		tree: { kinds: {
+			named: {
+				verbs: {
+					step: "walk.named",
+					view: "view.card"
+				},
+				pure: true,
+				summary: "A step of a path: it goes up to the nearest registry of names, and it gives the node with the name (TREE.NAMED)."
+			},
+			at: {
+				verbs: {
+					step: "walk.tree.at",
+					view: "view.card"
+				},
+				pure: true,
+				summary: "A step of a path: it reads an attribute with parameters of the node before it, with the arguments of the step (TREE.AT)."
+			}
+		} },
 		panel: {
 			verbs: {
 				eval: "tree.node",
@@ -5664,6 +5827,18 @@ const WORLD_SYNTAX = /* @__PURE__ */ Object.freeze({
 					"self"
 				]
 			},
+			{
+				name: "tree.named",
+				kind: "tree.named",
+				args: "named",
+				fields: ["name", "in"]
+			},
+			{
+				name: "tree.at",
+				kind: "tree.at",
+				args: "named",
+				fields: ["attr", "args"]
+			},
 			{
 				name: "add",
 				kind: "add"
@@ -6203,6 +6378,132 @@ function plainOf(value, path) {
 	}
 }
 /**
+* This function gives the collection of an attribute of a node (TREE.COLLECT, D122). It visits the node, then each node
+* of the same tree in each list `children`, in the order of the lists. Each node is visited one time.
+* The registry of names (TREE.NAMED) gives a record from each binding name to its node.
+*/
+function collected(root, key, declared) {
+	const top = stateOf(root);
+	const rule = collectOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${attributeText(key, top.type, top.place)} has a bad declaration collect. ${rule.reason}`);
+	const registry = {};
+	const owners = /* @__PURE__ */ new Map();
+	let acc = rule.names ? ok(registry) : top.equation(rule.unit, NO_NAMES$1);
+	if (!acc.ok) return acc;
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [root];
+	while (stack.length > 0) {
+		const thing = stack.pop();
+		const at = stateOf(thing);
+		if (at === void 0 || at.build !== top.build || seen.has(at)) continue;
+		seen.add(at);
+		if (rule.names) {
+			const name = at.name;
+			const earlier = name === void 0 ? void 0 : owners.get(name);
+			if (earlier !== void 0) {
+				const both = `${earlier.type} at [${earlier.place.join(", ")}] and ${at.type} at [${at.place.join(", ")}]`;
+				return fail("#VALUE!", `Two nodes have the name ${name} in the registry ${attributeText(key, top.type, top.place)}: ${both}.`);
+			}
+			if (name !== void 0) {
+				owners.set(name, at);
+				putField(registry, name, thing);
+			}
+		} else {
+			const term = entryOf(at.tree?.contributes, key);
+			if (term !== void 0) {
+				const item = at.equation(term, NO_NAMES$1);
+				if (!item.ok) return item;
+				acc = top.equation(rule.combine, {
+					acc: acc.value,
+					item: item.value
+				});
+				if (!acc.ok) return acc;
+			}
+		}
+		const children = at.read("children");
+		if (children === void 0) continue;
+		if (!children.ok) return children;
+		if (!Array.isArray(children.value)) return fail("#VALUE!", `The collection of ${key} needs a list in children of ${at.type} at [${at.place.join(", ")}].`);
+		const list = children.value;
+		for (let index = list.length - 1; index >= 0; index -= 1) stack.push(list[index]);
+	}
+	return acc;
+}
+/**
+* The host things that answer the step `tree.at` with their own function (D124). A node of the reference is in it, and
+* its fields do not change. The walker reads the state of a node of the kit.
+*/
+const AT_READERS = /* @__PURE__ */ new WeakMap();
+/** The memo of the instances of the attributes with parameters of each node, without the cells of a host (TREE.AT). */
+const atMemos = /* @__PURE__ */ new WeakMap();
+/** The second key of each key of a node, for the cells of the attributes with parameters (TREE.AT-CELL). */
+const atPlaces = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives an instance of an attribute with parameters of a node (TREE.AT, D124). The equation in
+* `tree.at` of the kind of the node evaluates with the arguments as names. The memo keeps one result for each key of
+* the arguments, and a demand of an instance in evaluation gives `#CYCLE!`. The function is outside the code of
+* `read`, thus a node without such attributes does no new work.
+*/
+function atRead(n, attr, args) {
+	const declared = entryOf(n.tree?.at, attr);
+	if (declared === void 0) return void 0;
+	const rule = atRuleOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${attributeText(attr, n.type, n.place)} has a bad entry tree.at. ${rule.reason}`);
+	const given = atArgsOf(rule.params, args);
+	if (!given.ok) return fail("#VALUE!", `The step tree.at of ${attributeText(attr, n.type, n.place)} has bad arguments. ${given.reason}`);
+	const host = openPoint === void 0 ? n.host : void 0;
+	const place = n.host === void 0 ? n.place : keptAt(atPlaces, n.place, () => Object.freeze([...n.place]));
+	let marks = n.host === void 0 ? atMemos.get(n) : keptAt(marksByPlace, place, () => /* @__PURE__ */ new Map());
+	if (marks === void 0) {
+		marks = /* @__PURE__ */ new Map();
+		atMemos.set(n, marks);
+	}
+	const key = `[${JSON.stringify(attr)},${given.key}]`;
+	const text = attributeText(`${attr} with ${given.key}`, n.type, n.place);
+	const cell = marks.get(key);
+	if (cell !== void 0) return cell.busy ? cycleAt(marks, key, text) : cell.result;
+	const demand = {
+		cells: marks,
+		key,
+		text
+	};
+	const loop = openPoint;
+	const compute = () => ({
+		result: n.equation(rule.equation, given.names),
+		by: "kind"
+	});
+	marks.set(key, BUSY);
+	demands.push(demand);
+	let thrown = NOT_THROWN;
+	let answer;
+	try {
+		answer = host === void 0 ? compute() : host(place, key, () => {
+			try {
+				return compute();
+			} catch (error) {
+				thrown = error;
+				throw error;
+			}
+		});
+	} catch (error) {
+		marks.delete(key);
+		if (host === void 0 || error === thrown) throw error;
+		answer = {
+			result: fail("#CYCLE!", `The cells of the host found a cycle in the demands: ${demands.map((item) => item.text).join(" -> ")}.`, { cause: error }),
+			by: void 0
+		};
+	} finally {
+		demands.pop();
+	}
+	if (n.host !== void 0 || loop?.tentative.has(demand) === true) marks.delete(key);
+	else marks.set(key, {
+		busy: false,
+		result: answer.result,
+		by: answer.by
+	});
+	return answer.result;
+}
+/**
 * 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. 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
@@ -6279,6 +6580,10 @@ function treeThing(input, place, build, outer, host) {
 			result: fold(key, declared.fold),
 			by: "default"
 		};
+		if (declared?.collect !== void 0) return {
+			result: collected(node, key, declared.collect),
+			by: "default"
+		};
 		if (declared?.default !== void 0) return {
 			result: state.equation(declared.default, NO_NAMES$1),
 			by: "default"
@@ -6357,6 +6662,7 @@ function treeThing(input, place, build, outer, host) {
 	};
 	const state = {
 		build,
+		name: input.doc.name,
 		type,
 		place,
 		tree,
@@ -6538,8 +6844,75 @@ function nearestWalker(options = {}) {
 		};
 	};
 }
+const nearest = /* @__PURE__ */ nearestWalker();
+/**
+* The walker of the step `tree.named` (TREE.NAMED, D122). It goes up from the thing before the step through the key
+* `parent`, to the first thing that answers the registry. The field `in` names the registry, and the default is
+* `names`. The walker gives the node with the field `name` in that registry.
+*/
+const named$2 = ({ data, here, deref }) => {
+	const name = isRecord(data) ? field(data, "name") : void 0;
+	if (typeof name !== "string") return {
+		ok: false,
+		code: "#VALUE!",
+		reason: "The step tree.named needs a text name."
+	};
+	const registry = isRecord(data) && typeof field(data, "in") === "string" ? String(field(data, "in")) : "names";
+	let at = here;
+	for (let hops = 0; hops < 256 && at !== void 0 && at !== null; hops += 1) {
+		const found = deref(at, registry);
+		if (found !== void 0) {
+			if (!isRecord(found) || !Object.hasOwn(found, name)) return {
+				ok: false,
+				reason: `The registry ${registry} has no node with the name ${name}.`
+			};
+			return {
+				ok: true,
+				thing: field(found, name)
+			};
+		}
+		at = deref(at, "parent");
+	}
+	return {
+		ok: false,
+		reason: `No registry ${registry} is on the way.`
+	};
+};
+/**
+* The walker of the step `tree.at` (TREE.AT, D124). The field `attr` names an attribute with parameters, and the
+* field `args` gives the arguments. The thing before the step is a node. A failed instance throws its own error.
+*/
+const at = ({ data, here }) => {
+	const attr = isRecord(data) ? field(data, "attr") : void 0;
+	if (typeof attr !== "string") return {
+		ok: false,
+		code: "#VALUE!",
+		reason: "The step tree.at needs a text attr."
+	};
+	const args = isRecord(data) && Object.hasOwn(data, "args") ? field(data, "args") : {};
+	const state = stateOf(here);
+	const reader = state === void 0 && typeof here === "object" && here !== null ? AT_READERS.get(here) : void 0;
+	if (state === void 0 && reader === void 0) return {
+		ok: false,
+		reason: `The step tree.at reads ${attr} of a thing that is not a node of a tree.`
+	};
+	const result = state === void 0 ? reader(attr, args) : atRead(state, attr, args);
+	if (result === void 0) return {
+		ok: false,
+		reason: `No rung gives the attribute ${attr} with parameters.`
+	};
+	if (!result.ok) throw new Failure(result.error);
+	return {
+		ok: true,
+		thing: result.value
+	};
+};
 /** The walkers of the standard world, by name. */
-const STD_WALKERS = { "walk.nearest": /* @__PURE__ */ nearestWalker() };
+const STD_WALKERS = {
+	"walk.nearest": nearest,
+	"walk.named": named$2,
+	"walk.tree.at": at
+};
 /** This function evaluates parts one after the other, and stops at the first error. */
 function* inOrder(parts) {
 	const values = [];
@@ -7524,7 +7897,7 @@ function factsOf(machine, doc, options = {}) {
 					at: tight(place.at)
 				});
 			}
-			const declared = declaredEffects(v, verb);
+			const declared = verb === "eval" && answer?.effects !== void 0 ? effectKeys(v, answer.effects) : declaredEffects(v, verb);
 			if (verb === "eval" ? kind.side === "run" : declared.length > 0) {
 				if (node === void 0) side = "run";
 				else pure = false;
@@ -7996,6 +8369,25 @@ function vertexOf(b, node, attribute) {
 	}
 	return id;
 }
+/**
+* This function gives the vertex of an instance of an attribute with parameters (TREE.AT-CHECK, D124). Its name is the
+* name of a plain vertex with the key of the arguments after the name of the attribute.
+*/
+function atVertexOf(b, node, at) {
+	const id = `${attributeVertexId(node.visit.place, at.attr).slice(0, -1)},${at.key}]`;
+	if (!b.vertices.has(id)) {
+		b.vertices.set(id, {
+			id,
+			place: node.visit.place,
+			attribute: at.attr,
+			type: node.text,
+			args: at.names
+		});
+		b.nodes.set(id, node);
+		b.work.push(id);
+	}
+	return id;
+}
 function edge(b, from, r, lazy = false) {
 	b.edges.push({
 		from,
@@ -8085,6 +8477,14 @@ function follow(b, start, path, from, r) {
 			}
 			continue;
 		}
+		if (isAtStep(b.machine, step)) {
+			const at = atStepOf(node.kind, node.text, step.value);
+			if (at.kind === "unknown") edge(b, void 0, r);
+			if (at.kind !== "exact") return;
+			edge(b, atVertexOf(b, node, at), r);
+			here = "unknown";
+			continue;
+		}
 		if (walkerOf(b.machine, step) !== STD_WALKERS["walk.nearest"]) {
 			edge(b, void 0, r);
 			return;
@@ -8160,7 +8560,10 @@ function termReads(b, refs, self, names, r) {
 		const name = String(ref.path[1]);
 		let start;
 		if (ref.bound.has(name)) start = "unknown";
-		else if (names?.child !== void 0 && name === "child") start = { node: names.child };
+		else if (names?.params !== void 0) {
+			if (!names.params.includes(name)) continue;
+			start = "data";
+		} else if (names?.child !== void 0 && name === "child") start = { node: names.child };
 		else if (names?.prev !== void 0 && name === "prev") start = names.prev;
 		else if (name === "index") start = "data";
 		else if (name === "acc" || name === "item") start = "unknown";
@@ -8184,7 +8587,8 @@ function prevOf(parent, child) {
 */
 function rungReads(b, id) {
 	const node = b.nodes.get(id);
-	const key = b.vertices.get(id).attribute;
+	const vertex = b.vertices.get(id);
+	const key = vertex.attribute;
 	const tree = node.kind.tree;
 	const r = {
 		to: id,
@@ -8192,6 +8596,14 @@ function rungReads(b, id) {
 		place: node.visit.place,
 		at: node.visit.at
 	};
+	if (vertex.args !== void 0) {
+		const at = atStepOf(node.kind, node.text, {
+			attr: key,
+			args: vertex.args
+		});
+		if (at.kind === "exact") termReads(b, termRefs(b, node.kind, `tree.at.${key}`, at.equation), node, { params: at.params }, r);
+		return;
+	}
 	const equation = hasOwnEntry(tree?.equations, key) ? tree?.equations?.[key] : void 0;
 	if (equation !== void 0) {
 		termReads(b, termRefs(b, node.kind, `tree.equations.${key}`, equation), node, void 0, r);
@@ -8245,8 +8657,57 @@ function rungReads(b, id) {
 		});
 		return;
 	}
+	const collect = declared?.collect === void 0 ? void 0 : collectOf(declared.collect);
+	if (collect?.ok === true) {
+		collectReads(b, node, key, collect, later);
+		return;
+	}
 	if (declared?.default !== void 0) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.default`, declared.default), node, void 0, later);
 }
+/** This function gives the list children of a node before the run. A node without a rung for it has no children. */
+function childrenOf(b, at) {
+	const part = at.parts.get("children");
+	if (part !== void 0) return valueOf$1(part);
+	const tree = at.kind.tree;
+	if (hasOwnEntry(tree?.equations, "children") || hasOwnEntry(tree?.attributes, "children")) return "unknown";
+	if (at.up === void 0) return downNames(b.machine.world).has("children") ? "unknown" : "data";
+	return at.up !== null && hasOwnEntry(at.up.kind.tree?.down, "children") ? "unknown" : "data";
+}
+/**
+* This function adds the reads of a collection (TREE.COLLECT, D122), in the order of the run. Each node of the subtree
+* gives the reads of its contribution and of its list `children`. A list that only the run knows gives an edge with an
+* unknown source. The registry of names reads only the lists `children`.
+*/
+function collectReads(b, node, key, rule, later) {
+	if (!rule.names) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.collect.unit`, rule.unit), node, void 0, later);
+	let combined = false;
+	const done = /* @__PURE__ */ new Set();
+	const stack = [node];
+	while (stack.length > 0) {
+		const at = stack.pop();
+		if (done.has(at)) continue;
+		done.add(at);
+		const term = rule.names || !hasOwnEntry(at.kind.tree?.contributes, key) ? void 0 : at.kind.tree?.contributes?.[key];
+		if (term !== void 0) {
+			termReads(b, termRefs(b, at.kind, `tree.contributes.${key}`, term), at, void 0, later);
+			combined = true;
+		}
+		edge(b, vertexOf(b, at, "children"), later);
+		const children = childrenOf(b, at);
+		if (children === "unknown") edge(b, void 0, later);
+		else if (typeof children === "object" && "list" in children) {
+			const items = itemsOf(children.list);
+			for (let index = items.length - 1; index >= 0; index -= 1) {
+				const child = items[index]?.node;
+				if (child !== void 0 && child.up === at) stack.push(child);
+			}
+		}
+	}
+	if (!rule.names) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.collect.combine`, rule.combine), node, void 0, combined ? later : {
+		...later,
+		lazy: true
+	});
+}
 function build(machine, doc, declaredType) {
 	const b = {
 		machine,
@@ -8406,7 +8867,7 @@ function allCircular(b, ids) {
 	return ids.every((id) => b.vertices.get(id)?.circular === true);
 }
 function vertexText(vertex) {
-	return `${vertex.attribute} of ${vertex.type} at [${vertex.place.join(", ")}]`;
+	return `${vertex.args === void 0 ? vertex.attribute : `${vertex.attribute} with ${String(argsKey(vertex.args))}`} of ${vertex.type} at [${vertex.place.join(", ")}]`;
 }
 /**
 * This function finds each certain cycle of the attributes of a document before a run (TREE.GRAPH-CYCLE, D107). A run
@@ -8732,21 +9193,56 @@ function mapRefs(world, doc, change, options = {}) {
 	}
 	return out;
 }
+/**
+* This function gives the parts that the code of a runner evaluates itself, without a wait (RUN.DRIVES, D119). The
+* answer of the hook `facts` for the code wins over the contract. The contract describes only the code of its kind for
+* `eval`. Without a declaration, the runner passes each wait of its parts through.
+*/
+function driveRules(machine, v, kind, name, rung, verb) {
+	if (verb !== "eval") return void 0;
+	const hook = machine.facts?.(v.typePath ?? [], name)?.drives;
+	if (hook !== void 0) return hook;
+	return v.declared || rung !== "own" || name === answerOf(machine.world, void 0, kind, verb)?.name ? kind.drives : void 0;
+}
 /** The least authority: the capability `[]` permits each effect (CAP.KEYS). */
 const EACH$1 = /* @__PURE__ */ Object.freeze([[]]);
 /** No declared effect. One list serves each visit without effects. */
 const NO_EFFECTS = /* @__PURE__ */ Object.freeze([]);
 /**
-* This function gives the effects that the contract of the kind of a visit declares for a verb, as keys
-* (FACTS.EFFECTS, VERB.EFFECTS). The text `"type"` gives the type of the document after each alias. A visit without a
-* kind declares no effect. `check`, `factsOf` and `effectsOf` read the declarations with this one function (D27).
+* This function gives the effects that the code of a visit declares for a verb, as keys (FACTS.EFFECTS, VERB.EFFECTS).
+* The text `"type"` gives the type of the document after each alias. A visit without a kind declares no effect.
+* `check`, `factsOf`, `effectsOf` and `checkLatent` read the declarations with this one function (D27).
+*
+* For `eval`, the answer of the hook `facts` of the machine for the code of the visit wins over the contract of the
+* kind (CAP.OWN-EFFECTS, D118). Thus a language gives the effects of an own entry for another evaluator. Without a
+* machine, or without the field `effects` in the answer, the contract gives the effects.
 *
 * @param v - The visit.
 * @param verb - The verb. The default is `eval`. A kind without a declaration for the verb gives no effect.
-* @returns The keys of each declared effect, in the order of the contract.
+* @param machine - The machine with the hook `facts`, when the caller has it.
+* @param name - The name of the evaluator of the visit, when the caller knows it. Else the ladder gives it.
+* @returns The keys of each declared effect, in the order of the declaration.
+*/
+function declaredEffects(v, verb = "eval", machine, name) {
+	return hookEffects(v, verb, machine, name) ?? verbDeclared(v, verb) ?? NO_EFFECTS;
+}
+/**
+* This function gives the effects that the hook `facts` gives for the code of a visit, as keys (D118). The result is
+* `undefined` for another verb than `eval`, without the hook, or when the answer has no field `effects`.
+*/
+function hookEffects(v, verb, machine, name) {
+	if (verb !== "eval" || machine?.facts === void 0 || v.kind === void 0) return void 0;
+	const code = name ?? answerOf(machine.world, v.declared ? void 0 : v.doc.own, v.kind, "eval")?.name;
+	const effects = code === void 0 ? void 0 : machine.facts(v.typePath ?? [], code)?.effects;
+	return effects === void 0 ? void 0 : effectKeys(v, effects);
+}
+/**
+* This function gives the keys of a declaration of effects at a visit (D27). The text `"type"` gives the type of the
+* document after each alias.
 */
-function declaredEffects(v, verb = "eval") {
-	return verbDeclared(v, verb) ?? NO_EFFECTS;
+function effectKeys(v, effects) {
+	if (effects.length === 0) return NO_EFFECTS;
+	return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
 }
 /**
 * This function gives the effects that the contract of the kind of a visit declares for a verb, as keys. The result
@@ -8757,8 +9253,7 @@ function verbDeclared(v, verb) {
 	if (v.kind === void 0) return verb === "eval" ? NO_EFFECTS : void 0;
 	const effects = effectsOfVerb(v.kind, verb);
 	if (effects === void 0) return void 0;
-	if (effects.length === 0) return NO_EFFECTS;
-	return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
+	return effectKeys(v, effects);
 }
 /**
 * This function gives the rule of a machine for an effect, for the static kit (CAP.PERMITS). The rule is the hook
@@ -8907,7 +9402,8 @@ const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
 const FOLD_NAMES = /* @__PURE__ */ Object.freeze(["acc", "item"]);
 /**
 * This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
-* `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
+* `equations`, a `unit`, a `default` and a contribution see no names. `check` and `factsOf` read the equations with
+* this one function.
 */
 function equationsOf(kind) {
 	const tree = kind.tree;
@@ -8951,6 +9447,42 @@ function equationsOf(kind) {
 			attribute: name,
 			down: false
 		});
+		const collect = declared.collect === void 0 ? void 0 : collectOf(declared.collect);
+		if (collect?.ok === true && !collect.names) {
+			out.push({
+				label: `tree.attributes.${name}.collect.unit`,
+				term: collect.unit,
+				names: [],
+				attribute: name,
+				down: false
+			});
+			out.push({
+				label: `tree.attributes.${name}.collect.combine`,
+				term: collect.combine,
+				names: FOLD_NAMES,
+				attribute: name,
+				down: false
+			});
+		}
+	}
+	for (const [name, term] of Object.entries(tree.contributes ?? {})) out.push({
+		label: `tree.contributes.${name}`,
+		term,
+		names: [],
+		attribute: name,
+		down: false,
+		contributes: true
+	});
+	for (const [name, declared] of Object.entries(tree.at ?? {})) {
+		const rule = atRuleOf(declared);
+		if (rule.ok) out.push({
+			label: `tree.at.${name}`,
+			term: rule.equation,
+			names: rule.params,
+			attribute: name,
+			down: false,
+			at: true
+		});
 	}
 	return out;
 }
@@ -9073,7 +9605,7 @@ function answered(world, node, name) {
 	if (hasEntry(tree?.equations, name)) return true;
 	if (node.parent === void 0 ? downNames(world).has(name) : hasEntry(node.parent.kind.tree?.down, name)) return true;
 	const declared = tree?.attributes !== void 0 && Object.hasOwn(tree.attributes, name) ? tree.attributes[name] : void 0;
-	return declared !== void 0 && (declared.copy === true || declared.fold !== void 0 || declared.default !== void 0);
+	return declared !== void 0 && (declared.copy === true || declared.fold !== void 0 || declared.collect !== void 0 || declared.default !== void 0);
 }
 /**
 * This function checks the equations of the tree contract of a kind, each with the names of its rung (TREE.DOWN-NAMES).
@@ -9097,7 +9629,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 		own: void 0,
 		parent: void 0
 	};
-	for (const { label, term, names, attribute, down } of equationsOf(kind)) {
+	for (const { label, term, names, attribute, down, contributes, at } of equationsOf(kind)) {
 		const inner = {
 			names,
 			...of === void 0 ? {} : { declaredType: of },
@@ -9107,7 +9639,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 			needs.push({
 				name,
 				why: `the equation ${label} reads it`,
-				hidden: down ? void 0 : attribute
+				hidden: down || contributes === true || at === true ? void 0 : attribute
 			});
 		};
 		for (const issue of checkAll(machine, term, inner, void 0, state, {
@@ -9124,7 +9656,8 @@ function equationIssues(machine, kind, kindText, options, state) {
 /**
 * This function finds the issues of the contract of a tree kind (TREE.CHECK-RESERVED). An attribute with the name of a
 * structural step gets no read. A tree kind of the run side contradicts the evaluation on demand of its attributes. A
-* declaration `circular` without a start value or with a bad limit gives `#VALUE!` (TREE.CIRCULAR-CHECK).
+* declaration `circular` without a start value or with a bad limit gives `#VALUE!` (TREE.CIRCULAR-CHECK). A declaration
+* `collect` without its form gives `#VALUE!` too (TREE.COLLECT). So does an entry of `at` without its form (TREE.AT-CHECK).
 */
 function contractIssues(kind, kindText) {
 	const out = [];
@@ -9132,7 +9665,9 @@ function contractIssues(kind, kindText) {
 	for (const table of [
 		"equations",
 		"down",
-		"attributes"
+		"attributes",
+		"contributes",
+		"at"
 	]) for (const name of Object.keys(tree?.[table] ?? {})) {
 		const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : void 0;
 		if (why !== void 0) out.push({
@@ -9148,6 +9683,20 @@ function contractIssues(kind, kindText) {
 			place: [],
 			reason: `The kind ${kindText} has a bad declaration tree.attributes.${name}.circular. ${rule.reason}`
 		});
+		const collect = declared.collect === void 0 ? void 0 : collectOf(declared.collect);
+		if (collect !== void 0 && !collect.ok) out.push({
+			code: "#VALUE!",
+			place: [],
+			reason: `The kind ${kindText} has a bad declaration tree.attributes.${name}.collect. ${collect.reason}`
+		});
+	}
+	for (const [name, declared] of Object.entries(tree?.at ?? {})) {
+		const rule = atRuleOf(declared);
+		if (!rule.ok) out.push({
+			code: "#VALUE!",
+			place: [],
+			reason: `The kind ${kindText} has a bad entry tree.at.${name}. ${rule.reason}`
+		});
 	}
 	if (kind.side === "run") out.push({
 		code: "#CALC!",
@@ -9194,7 +9743,7 @@ function nodeIssues(machine, node, state, v) {
 * This function examines a reference from the root `self` (TREE.CHECK-UNKNOWN). The steps `parent` go up the known
 * nodes. The first other key names an attribute of the node that they reach. When no rung answers the attribute, the
 * function gives the index of the step and the reason. In an equation, a read of the node of the equation goes to the
-* needs of its kind.
+* needs of its kind. A step `tree.at` with literal arguments gets the checks of TREE.AT-CHECK.
 */
 function readIssue(machine, self, path, rootSelf) {
 	let node = self;
@@ -9204,6 +9753,14 @@ function readIssue(machine, self, path, rootSelf) {
 		index += 1;
 	}
 	const step = path[index];
+	if (node !== void 0 && isAtStep(machine, step)) {
+		const at = atStepOf(node.kind, node.text, step.value);
+		return at.kind === "issue" ? {
+			index,
+			reason: at.reason,
+			code: at.code
+		} : void 0;
+	}
 	if (node === void 0 || !isKey(step) || Object.hasOwn(STRUCTURAL, String(step))) return void 0;
 	const name = String(step);
 	if (node.own === void 0) {
@@ -9215,6 +9772,52 @@ function readIssue(machine, self, path, rootSelf) {
 		reason: `No rung gives the attribute ${name} of the kind ${node.text}.`
 	};
 }
+/** This function tells if a step of a path is a step `tree.at` of the standard walker (TREE.AT, D124). */
+function isAtStep(machine, step) {
+	return isEnvelope(step) && walkerOf(machine, step) === STD_WALKERS["walk.tree.at"];
+}
+/**
+* This function examines the data of a step `tree.at` on a node of a known kind (TREE.AT-CHECK, D124). `check` and the
+* graph of attribute instances read the step with this one function.
+*/
+function atStepOf(kind, kindText, data) {
+	if (holdsDocument(data)) return { kind: "unknown" };
+	const attr = isRecord(data) ? field(data, "attr") : void 0;
+	if (typeof attr !== "string") return {
+		kind: "issue",
+		code: "#VALUE!",
+		reason: "The step tree.at needs a text attr."
+	};
+	const table = kind.tree?.at;
+	const declared = table !== void 0 && Object.hasOwn(table, attr) ? table[attr] : void 0;
+	if (declared === void 0) return {
+		kind: "issue",
+		code: "#N/A",
+		reason: `No rung gives the attribute ${attr} with parameters of the kind ${kindText}.`
+	};
+	const rule = atRuleOf(declared);
+	if (!rule.ok) return { kind: "unknown" };
+	const given = atArgsOf(rule.params, isRecord(data) && Object.hasOwn(data, "args") ? field(data, "args") : {});
+	if (!given.ok) return {
+		kind: "issue",
+		code: "#VALUE!",
+		reason: `The step tree.at of ${attr} of the kind ${kindText} has bad arguments. ${given.reason}`
+	};
+	return {
+		kind: "exact",
+		attr,
+		key: given.key,
+		equation: rule.equation,
+		params: rule.params,
+		names: given.names
+	};
+}
+/** This function tells if a value holds a document. A document in the data of a step can be a part, thus only the run knows its value. */
+function holdsDocument(value) {
+	if (isEnvelope(value)) return true;
+	if (Array.isArray(value)) return value.some(holdsDocument);
+	return isRecord(value) && Object.values(value).some(holdsDocument);
+}
 /**
 * 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 state holds the kinds whose equations the check
@@ -9235,6 +9838,7 @@ function checkAll(machine, doc, options, nodes, state = {
 	};
 	const allowed = options.caps === void 0 ? void 0 : permitsOf(machine);
 	const waits = options.run === true ? /* @__PURE__ */ new Map() : void 0;
+	const driven = /* @__PURE__ */ new Map();
 	const drives = [];
 	const maxDepth = machine.maxDepth ?? 1e3;
 	const anyName = options.names === "any";
@@ -9311,7 +9915,7 @@ function checkAll(machine, doc, options, nodes, state = {
 			});
 		}
 		const caps = v.caps;
-		const stated = verbDeclared(v, verb);
+		const stated = hookEffects(v, verb, machine, name) ?? verbDeclared(v, verb);
 		const declared = stated ?? NO_EFFECTS;
 		if (allowed !== void 0 && caps !== void 0) {
 			for (const kind of declared) if (!allowed(caps, kind)) push({
@@ -9322,7 +9926,9 @@ function checkAll(machine, doc, options, nodes, state = {
 			});
 		}
 		if (waits !== void 0 && coded) {
-			const up = v.parent === void 0 ? true : waits.get(v.parent);
+			let up = v.parent === void 0 ? true : waits.get(v.parent);
+			const rules = v.parent === void 0 ? void 0 : driven.get(v.parent);
+			if (up !== false && rules !== void 0 && v.parent !== void 0 && rulesCover(rules, v.parent.kind?.parts, v.parent.doc.value, v.slot)) up = false;
 			let chain = false;
 			if (runner && up === false) {
 				chain = {
@@ -9339,6 +9945,10 @@ function checkAll(machine, doc, options, nodes, state = {
 				drives.push(chain);
 			} else if (runner) chain = up ?? true;
 			waits.set(v, chain);
+			if (runner && v.kind !== void 0) {
+				const own = driveRules(machine, v, v.kind, name, answer.rung, verb);
+				if (own !== void 0 && own.length > 0) driven.set(v, own);
+			}
 			if (typeof chain === "object" && !chain.wait) {
 				const rule = allowed ?? permits;
 				chain.wait = stated === void 0 || declared.some((kind) => caps === void 0 || rule(caps, kind));
@@ -9394,7 +10004,7 @@ function checkAll(machine, doc, options, nodes, state = {
 		if (attributes && root === "self" && v.address !== true && name === "ref.resolve") {
 			const issue = readIssue(machine, self, path, rootSelf);
 			if (issue !== void 0) push({
-				code: "#N/A",
+				code: issue.code ?? "#N/A",
 				place: v.place,
 				reason: issue.reason,
 				at: stepAt(issue.index)
@@ -9444,7 +10054,7 @@ function reaching(machine, doc, options) {
 	const rule = options.caps === void 0 ? permits : permitsOf(machine);
 	walk(machine.world, doc, (v) => {
 		const caps = v.caps ?? EACH;
-		for (const kind of declaredEffects(v)) if (rule(caps, kind)) out.push({
+		for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind)) out.push({
 			kind,
 			visit: v
 		});
@@ -9465,7 +10075,9 @@ function reaching(machine, doc, options) {
 *
 * The result covers each effect that an evaluation or a run gives the host (CAP.EFFECTS-SOUND). A procedure value keeps
 * the capabilities of the document that made it, thus the effects of its body count at the body (CAP.LATENT). The
-* contract describes the code of its kind. The code of an own entry for another evaluator is outside the result.
+* contract describes the code of its kind. The contract does not describe the code of an own entry for another
+* evaluator. The answer of the hook `facts` for that code gives its effects (CAP.OWN-EFFECTS, D118). Without an
+* answer, its effects are outside the result.
 *
 * @param machine - The world and its contracts, and the hook `permits`.
 * @param doc - The document, as JSON.
@@ -9965,6 +10577,30 @@ function paramsOf(value) {
 	const params = isRecord(value) ? value["params"] : void 0;
 	return Array.isArray(params) ? params.filter((param) => typeof param === "string") : [];
 }
+/** This function gives the text of a step of a path: a key, or the kind of a step document in parentheses. */
+function stepText(step) {
+	if (isKey(step)) return String(step);
+	return isRecord(step) ? `(${typeName(step["type"])})` : "(step)";
+}
+/**
+* This function gives the type of what a step document reaches (TYPE.WALKER, D121). The type rule of its walker gives
+* it. A step document with parts gets its data in the run, thus its type is `unknown`, as for a walker without a rule.
+*
+* @param input - The input of the rule of the reference.
+* @param step - The step document.
+* @param here - The type before the step.
+* @returns The type of what the step reaches.
+*/
+function walkType(input, step, here) {
+	const rule = walkerOf(input.machine, step)?.type;
+	if (rule === void 0) return "unknown";
+	const read = partsOf(input.machine.world, step);
+	if (!read.ok || !read.split.ok || read.split.parts.length > 0) return "unknown";
+	return input.contract(rule({
+		data: read.doc.value,
+		here
+	}), `type of the step ${typeName(read.doc.type)}`);
+}
 /**
 * This function makes the type rules of the formula kit for one profile (TYPE.SYNTH, D25). Each evaluator of the kit
 * holds its rule. The rules read the rules of the profile that change a type: `truthy`, `truthType`, `logic`,
@@ -10105,11 +10741,14 @@ function formulaTypes(profile) {
 				if (isUnknown(type, domains) || !plain && holdsEnvelope(type, domains)) return "unknown";
 				if (index >= path.length) return type;
 				const step = path[index];
-				if (!isKey(step)) return "unknown";
+				if (!isKey(step)) {
+					type = walkType(input, step, type);
+					continue;
+				}
 				const next = stepType(type, step, domains, input.contract);
 				if ("missing" in next) {
 					const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
-					report({ reason: `The value at ${path.slice(0, index).map(String).join(".")} has no field ${String(step)}.${fields}` });
+					report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
 					return "unknown";
 				}
 				type = next.type;
@@ -10608,17 +11247,26 @@ function formulaCode(profile) {
 				}
 				return known;
 			};
+			const limit = Math.ceil((machine.maxDepth ?? 1e3) / 4);
 			return (ctx, rt) => {
 				rt.keepsContext?.(ctx, reads);
+				const clock = rt;
 				const closure = (...args) => {
-					const scope = { ...ctx.names };
-					names.forEach((name, index) => setOwn$2(scope, name, args[index]));
-					const result = body.code({
-						...ctx,
-						names: scope
-					}, rt);
-					if (!result.ok) throw new Failure(result.error);
-					return result.value;
+					const level = (clock.applying ?? 0) + 1;
+					if (level > limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+					clock.applying = level;
+					try {
+						const scope = { ...ctx.names };
+						names.forEach((name, index) => setOwn$2(scope, name, args[index]));
+						const result = body.code({
+							...ctx,
+							names: scope
+						}, rt);
+						if (!result.ok) throw new Failure(result.error);
+						return result.value;
+					} finally {
+						clock.applying = level - 1;
+					}
 				};
 				Object.defineProperty(closure, CLOSURE$2, { value: { params: names } });
 				return ok(closure);
@@ -12505,6 +13153,7 @@ function envOf(machine, options, running, root, outer) {
 			alls: 0
 		},
 		held: 0,
+		applying: 0,
 		reading: outer ?? (options.reads === void 0 ? void 0 : {
 			list: options.reads,
 			root
@@ -12638,6 +13287,55 @@ function foldOf(node, name, fold) {
 	return acc;
 }
 /**
+* TREE.COLLECT and TREE.NAMED: the node, then each node of this tree in each list `children`, in the order of the
+* lists. Each node counts one time. The registry `names` maps each binding name to its node.
+*/
+function collectIn(node, name, declared) {
+	const rule = collectOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${nameOfAttribute(node, name)} has a bad declaration collect. ${rule.reason}`);
+	const registry = {};
+	const first = /* @__PURE__ */ new Map();
+	let acc = rule.names ? ok(registry) : equationOf(node, rule.unit, {});
+	if (!acc.ok) return acc;
+	const done = [];
+	const visit = (at) => {
+		if (done.includes(at)) return void 0;
+		done.push(at);
+		if (rule.names && at.name !== void 0) {
+			const earlier = first.get(at.name);
+			if (earlier !== void 0) return fail("#VALUE!", `Two nodes have the name ${at.name} in the registry ${nameOfAttribute(node, name)}: ${earlier.kind} at [${earlier.place.join(", ")}] and ${at.kind} at [${at.place.join(", ")}].`);
+			first.set(at.name, at);
+			Object.defineProperty(registry, at.name, {
+				value: at.thing,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		}
+		const term = rule.names ? void 0 : termIn(at.contract?.contributes, name);
+		if (!rule.names && term !== void 0) {
+			const item = equationOf(at, term, {});
+			if (!item.ok) return item;
+			acc = equationOf(node, rule.combine, {
+				acc: acc.ok ? acc.value : null,
+				item: item.value
+			});
+			if (!acc.ok) return acc;
+		}
+		const children = attributeOf(at, "children");
+		if (children === void 0) return void 0;
+		if (!children.ok) return children;
+		if (!Array.isArray(children.value)) return fail("#VALUE!", `The collection of ${name} needs a list in children of ${at.kind} at [${at.place.join(", ")}].`);
+		for (const item of children.value) {
+			const child = refNodeOf(item);
+			if (child === void 0 || child.tree !== node.tree) continue;
+			const failed = visit(child);
+			if (failed !== void 0) return failed;
+		}
+	};
+	return visit(node) ?? 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.
 */
@@ -12661,6 +13359,7 @@ const REF_RUNGS = [
 	["default", (node, name) => {
 		const declared = termIn(node.contract?.attributes, name);
 		if (declared?.fold !== void 0) return foldOf(node, name, declared.fold);
+		if (declared?.collect !== void 0) return collectIn(node, name, declared.collect);
 		return declared?.default === void 0 ? void 0 : equationOf(node, declared.default, {});
 	}]
 ];
@@ -12805,6 +13504,51 @@ function attributeOf(node, name) {
 	if (!entry.tentative && result !== void 0) node.values.set(name, result);
 	return result;
 }
+/** TREE.AT: the instances of each node of the reference. Two arguments are the same instance by DOC.EQUALS. */
+const refInstances = /* @__PURE__ */ new WeakMap();
+/**
+* TREE.AT: the instance of an attribute with parameters, or `undefined` when the kind has no entry in `tree.at`. The
+* equation sees the arguments as names. A demand of an instance in evaluation gives `#CYCLE!`, also in a fixed point.
+*/
+function instanceOf$1(node, attr, args) {
+	const declared = termIn(node.contract?.at, attr);
+	if (declared === void 0) return void 0;
+	const rule = atRuleOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${nameOfAttribute(node, attr)} has a bad entry tree.at. ${rule.reason}`);
+	const given = atArgsOf(rule.params, args);
+	if (!given.ok) return fail("#VALUE!", `The step tree.at of ${nameOfAttribute(node, attr)} has bad arguments. ${given.reason}`);
+	const name = `${attr} with ${given.key}`;
+	const list = refInstances.get(node) ?? [];
+	refInstances.set(node, list);
+	const found = list.find((item) => item.attr === attr && docEquals(item.names, given.names));
+	if (found?.result !== void 0) return found.result;
+	if (found !== void 0) {
+		const from = inEvaluation.findIndex((entry) => entry.node === node && entry.name === name);
+		return fail("#CYCLE!", `The attributes form a cycle: ${[...inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name)), nameOfAttribute(node, name)].join(" -> ")}.`);
+	}
+	const item = {
+		attr,
+		names: given.names,
+		result: void 0
+	};
+	list.push(item);
+	const entry = {
+		node,
+		name,
+		circular: false,
+		tentative: false
+	};
+	inEvaluation.push(entry);
+	let result;
+	try {
+		result = equationOf(node, rule.equation, given.names);
+	} finally {
+		inEvaluation.pop();
+		if (result === void 0 || entry.tentative) list.splice(list.indexOf(item), 1);
+		else item.result = result;
+	}
+	return result;
+}
 /** TREE.RESULT: the JSON of a node. `open` holds the nodes and the containers whose JSON is in progress. */
 function jsonOfNode(node, self, open) {
 	const record = {};
@@ -12848,7 +13592,7 @@ function plainValue(value, open) {
 * 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, machine, typePath, resolve: walk }) => {
+const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk, doc }) => {
 	const reached = walk(["self"]);
 	const parent = reached.ok ? reached.thing : void 0;
 	const outer = refNodeOf(parent);
@@ -12859,6 +13603,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	const node = {
 		tree: nested ? outer.tree : { open: true },
 		kind,
+		name: doc.name,
 		place,
 		parts,
 		ctx: context,
@@ -12890,6 +13635,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	};
 	node.thing = self;
 	refNodes.set(self, node);
+	AT_READERS.set(self, (attr, args) => instanceOf$1(node, attr, args));
 	if (nested) return ok(self);
 	try {
 		return jsonOfNode(node, self, []);
@@ -13016,16 +13762,27 @@ function formulaDefinitions(profile = {}) {
 		if (!Array.isArray(params) || !params.every((param) => typeof param === "string") || new Set(params).size !== params.length) return fail("#VALUE!", "The params of fn are a list of different texts.");
 		const names = params;
 		const body = partNamed(parts, "body");
+		const clock = activeEnvs[activeEnvs.length - 1] ?? {
+			applying: 0,
+			maxDepth: 1e3
+		};
+		const limit = Math.ceil(clock.maxDepth / 4);
 		const closure = (...args) => {
-			const scope = {};
-			for (const key of Object.keys(context.names)) setField$1(scope, key, context.names[key]);
-			names.forEach((name, index) => setField$1(scope, name, args[index]));
-			const result = body.evaluate({
-				...context,
-				names: scope
-			});
-			if (!result.ok) throw new Failure(result.error);
-			return result.value;
+			if (clock.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+			clock.applying += 1;
+			try {
+				const scope = {};
+				for (const key of Object.keys(context.names)) setField$1(scope, key, context.names[key]);
+				names.forEach((name, index) => setField$1(scope, name, args[index]));
+				const result = body.evaluate({
+					...context,
+					names: scope
+				});
+				if (!result.ok) throw new Failure(result.error);
+				return result.value;
+			} finally {
+				clock.applying -= 1;
+			}
 		};
 		Object.defineProperty(closure, CLOSURE$1, { value: { params: names } });
 		return ok(closure);
@@ -15182,6 +15939,7 @@ var Shot = class {
 	scenario;
 	context;
 	keys;
+	driven;
 	perform;
 	replay;
 	calls = [];
@@ -15195,12 +15953,13 @@ var Shot = class {
 	result = NO_RESULT;
 	afterwards = false;
 	running;
-	constructor(machine, runner, scenario, context, keys, perform, replay) {
+	constructor(machine, runner, scenario, context, keys, driven, perform, replay) {
 		this.machine = machine;
 		this.runner = runner;
 		this.scenario = scenario;
 		this.context = context;
 		this.keys = keys;
+		this.driven = driven;
 		this.perform = perform;
 		this.replay = replay;
 		this.running = scenario.running;
@@ -15224,7 +15983,7 @@ var Shot = class {
 		});
 		const key = this.keys[part] ?? String(part);
 		if (via === "run" && !this.runner) this.problems.push(`The code of an evaluator starts the steps of the part ${key}. Only a runner waits.`);
-		if (via === "code" && this.runner && this.running) this.problems.push(`The runner evaluates the part ${key} with its code, and that code cannot wait. A runner evaluates a part with its steps (K65).`);
+		if (via === "code" && this.runner && this.running && this.driven[part] !== true) this.problems.push(`The runner evaluates the part ${key} with its code, and that code cannot wait. A runner evaluates a part with its steps, or its contract declares the part in drives (D119).`);
 		return this.scenario.results[part] ?? NO_RESULT;
 	}
 	/** This function records a call of a part, and gives the steps of the probe part. In a run, the part can wait. */
@@ -15417,13 +16176,14 @@ function typesNaming(world, name, verb) {
 /** This function gives the facts of the kind of a type. The hook `facts` of the machine wins over the contract. */
 function contractOf(env, kind, typePath, caps) {
 	const facts = env.machine.facts?.(typePath, env.name);
-	const own = effectsOfVerb(kind, env.verb);
+	const own = (env.verb === "eval" ? facts?.effects : void 0) ?? effectsOfVerb(kind, env.verb);
 	const effects = own ?? kind.effects;
 	const declared = effects === void 0 ? [] : effects === "type" ? [typePath] : effects;
 	return {
 		declared,
 		pure: (facts?.pure ?? kind.pure) === true,
 		lazy: facts?.lazy ?? kind.lazy,
+		drives: env.verb === "eval" ? facts?.drives ?? kind.drives : void 0,
 		describes: env.verb === "eval",
 		declares: own !== void 0,
 		caps: caps ?? [...declared, "probe"]
@@ -15571,6 +16331,7 @@ function samplesOf(type, typePath, kind, contract, extra) {
 			},
 			otherSplit,
 			lazy: split.parts.map((_slot, index) => contract.lazy?.some((rule) => covers(rule, split.parts, index)) === true),
+			driven: split.parts.map((_slot, index) => contract.drives?.some((rule) => covers(rule, split.parts, index)) === true),
 			names: scopesOf(kind.scope, value, split.parts).sees
 		});
 	}
@@ -15717,7 +16478,7 @@ function instanceOf(env, under, doc, split, sample) {
 /** This function evaluates a probe document one time in a new shot. */
 function shoot(env, instance, sample, scenario, more = {}) {
 	const context = more.context ?? rootContext(env.machine, makeContext(env.names, scenario.caps));
-	const shot = new Shot(env.machine, env.runner, scenario, context, sample.split.parts.map((slot) => slot.key), env.perform, more.replay);
+	const shot = new Shot(env.machine, env.runner, scenario, context, sample.split.parts.map((slot) => slot.key), sample.driven, env.perform, more.replay);
 	instance(shot);
 	return shot;
 }
@@ -17189,18 +17950,89 @@ const READ = /* @__PURE__ */ new Set([
 	"enum",
 	"const",
 	"anyOf",
-	"oneOf"
+	"oneOf",
+	"allOf",
+	"$ref"
 ]);
 /**
-* The keywords that can permit more values than the other keywords permit. Older drafts ignore each keyword beside
-* `$ref`, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
+* The keywords that can permit more values than the other keywords permit. A dynamic reference can reach a schema
+* outside this schema, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
 */
 const WIDENING = /* @__PURE__ */ new Set([
-	"$ref",
 	"$dynamicRef",
 	"$recursiveRef",
 	"nullable"
 ]);
+/** The keywords of an object without the keyword `type`. They test only the values that are records. */
+const OBJECT_KEYS = [
+	"properties",
+	"required",
+	"additionalProperties"
+];
+/** The form of a local reference: a definition in `$defs` or `definitions` of the root schema. */
+const LOCAL_REF = /^#\/(\$defs|definitions)\/([^/]*)$/;
+/** The most pairs of members that the meet of two unions builds. A larger meet keeps the first type, which is sound. */
+const MAX_MEET_PAIRS = 64;
+/** This function tells if a field of a record type can be absent. */
+function isOptional(type, key) {
+	return type.optional?.includes(key) === true;
+}
+/**
+* This function gives the meet of two types of a reading: a type that holds each value of both types. A schema is
+* the conjunction of its keywords, thus its type is the meet of their types. The meet is exact for the forms that a
+* reading makes: base types, lists, records, unions and `one`. A meet of two different forms is `never`.
+*/
+function meet(a, b, depth) {
+	if (depth > MAX_SCHEMA_DEPTH) return a;
+	if (isUnknown(a, void 0)) return b;
+	if (isUnknown(b, void 0)) return a;
+	if (a === "never" || b === "never") return "never";
+	if (typeof a !== "string" && "one" in a) return { one: a.one.filter((value) => member(value, b)) };
+	if (typeof b !== "string" && "one" in b) return { one: b.one.filter((value) => member(value, a)) };
+	if (typeof b !== "string" && "union" in b && !(typeof a !== "string" && "union" in a)) return meet(b, a, depth);
+	if (typeof a !== "string" && "union" in a) {
+		const others = typeof b !== "string" && "union" in b ? b.union : [b];
+		if (a.union.length * others.length > MAX_MEET_PAIRS) return a;
+		return unionOf(a.union.flatMap((item) => others.map((other) => meet(item, other, depth + 1))));
+	}
+	if (typeof a === "string" || typeof b === "string") return a === b ? a : "never";
+	if ("list" in a && "list" in b) return { list: meet(a.list, b.list, depth + 1) };
+	if ("record" in a && "record" in b) return meetRecords(a, b, depth + 1);
+	return ("list" in a || "record" in a) && ("list" in b || "record" in b) ? "never" : a;
+}
+/**
+* This function gives the meet of two record types. A field of both records gets the meet of its types, and it is
+* optional only when both records permit its absence. A closed record has no other field, thus a field of only the
+* other record is absent. When the other record needs that field, no value fits both records.
+*/
+function meetRecords(a, b, depth) {
+	const fields = {};
+	const optional = [];
+	const keys = [...Object.keys(a.record), ...Object.keys(b.record).filter((key) => !Object.hasOwn(a.record, key))];
+	for (const key of keys) {
+		const inA = Object.hasOwn(a.record, key);
+		const inB = Object.hasOwn(b.record, key);
+		if (!inA && a.closed === true || !inB && b.closed === true) {
+			if (inA && !isOptional(a, key) || inB && !isOptional(b, key)) return "never";
+			continue;
+		}
+		setOwn(fields, key, inA && inB ? meet(a.record[key], b.record[key], depth) : inA ? a.record[key] : b.record[key]);
+		if ((!inA || isOptional(a, key)) && (!inB || isOptional(b, key))) optional.push(key);
+	}
+	const closed = a.closed === true || b.closed === true;
+	return {
+		record: fields,
+		...optional.length === 0 ? {} : { optional },
+		...closed ? { closed: true } : {}
+	};
+}
+/** This function applies a condition to a type: each member of the JSON type of the condition meets its type. */
+function narrow$1(type, condition) {
+	if (typeof type === "string") return type;
+	if ("union" in type) return unionOf(type.union.map((item) => narrow$1(item, condition)));
+	if ("one" in type) return { one: type.one.filter((value) => !(condition.on === "list" ? Array.isArray(value) : isRecord(value)) || member(value, condition.type)) };
+	return condition.on in type ? meet(type, condition.type, 0) : type;
+}
 /** The base type of each name of the keyword `type`. */
 const BASES = {
 	null: "null",
@@ -17223,26 +18055,57 @@ function setOwn(target, key, value) {
 function unionOf(types) {
 	return types.reduce((all, type) => join(all, type), "never");
 }
-/** The state of one reading of a schema: the issues that it found. */
+/** The state of one reading of a schema: the root, the issues and the definitions that it read. */
 var SchemaReader = class {
+	root;
 	issues = [];
+	/** The type of each definition that a reference reached. Each reading of a definition is sound, thus the first stays. */
+	defs = /* @__PURE__ */ new Map();
+	/** The definitions that the reading has not finished. A reference to one of them is a cycle. */
+	open = /* @__PURE__ */ new Set();
+	/** The number of schemas with an own `$id` around the current schema. A reference inside them has another base. */
+	inner = 0;
+	constructor(root) {
+		this.root = root;
+	}
 	issue(at, reason) {
 		this.issues.push({
 			at,
 			reason
 		});
 	}
-	/** This method reads one schema. */
+	/** This method reads one schema: the meet of the types of its keywords, then its conditions. */
 	read(schema, at, depth) {
+		const types = [];
+		const conditions = [];
+		this.parts(schema, at, depth, types, conditions);
+		let type = types.reduce((all, item) => meet(all, item, 0), "unknown");
+		for (const condition of conditions) {
+			if (isUnknown(type, void 0)) {
+				this.issue(condition.at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
+				break;
+			}
+			type = narrow$1(type, condition);
+		}
+		return type;
+	}
+	/**
+	* This method adds the type of each keyword of a schema to `types`, and its conditions to `conditions`. Each type
+	* holds each value that the schema accepts. The parts of `allOf` add their keywords too.
+	*/
+	parts(schema, at, depth, types, conditions) {
 		if (depth > MAX_SCHEMA_DEPTH) {
 			this.issue(at, `The schema is deeper than ${MAX_SCHEMA_DEPTH} levels. The type reads it as unknown.`);
-			return "unknown";
+			return;
+		}
+		if (schema === true) return;
+		if (schema === false) {
+			types.push("never");
+			return;
 		}
-		if (schema === true) return "unknown";
-		if (schema === false) return "never";
 		if (!isRecord(schema)) {
 			this.issue(at, "A schema is a record or a truth value. The type reads this value as unknown.");
-			return "unknown";
+			return;
 		}
 		let widens = false;
 		for (const key of Object.keys(schema)) {
@@ -17252,46 +18115,99 @@ var SchemaReader = class {
 				widens = true;
 			} else this.issue([...at, key], `The type does not read the keyword ${key}. It does not test what the keyword tests.`);
 		}
-		if (widens) return "unknown";
-		const sides = [];
-		if (Object.hasOwn(schema, "type")) sides.push({
-			key: "type",
-			type: this.byType(schema, at, depth)
-		});
-		else if ([
-			"properties",
-			"required",
-			"additionalProperties",
-			"items"
-		].some((key) => Object.hasOwn(schema, key)) && ![
-			"enum",
-			"const",
+		if (widens) return;
+		const nested = schema !== this.root && Object.hasOwn(schema, "$id");
+		if (nested) this.inner += 1;
+		try {
+			this.keywords(schema, at, depth, types, conditions);
+		} finally {
+			if (nested) this.inner -= 1;
+		}
+	}
+	/** This method reads the keywords of a schema that does not permit more values (WIDENING). */
+	keywords(schema, at, depth, types, conditions) {
+		if (Object.hasOwn(schema, "$ref")) {
+			for (const key of Object.keys(schema)) if (READ.has(key) && key !== "$ref") this.issue([...at, key], `The type reads only the target of $ref. It does not test the keyword ${key} beside it.`);
+			const type = this.target(schema["$ref"], [...at, "$ref"], depth);
+			if (type !== void 0) types.push(type);
+			return;
+		}
+		if (Object.hasOwn(schema, "type")) types.push(this.byType(schema, at, depth));
+		else {
+			if (OBJECT_KEYS.some((key) => Object.hasOwn(schema, key))) conditions.push({
+				on: "record",
+				type: this.object(schema, at, depth),
+				at
+			});
+			if (Object.hasOwn(schema, "items")) conditions.push({
+				on: "list",
+				type: this.array(schema, at, depth),
+				at
+			});
+		}
+		for (const key of [
 			"anyOf",
-			"oneOf"
-		].some((key) => Object.hasOwn(schema, key))) this.issue(at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
-		for (const key of ["anyOf", "oneOf"]) {
+			"oneOf",
+			"allOf"
+		]) {
 			if (!Object.hasOwn(schema, key)) continue;
 			const items = schema[key];
 			if (!Array.isArray(items)) {
 				this.issue([...at, key], `The value of ${key} is a list of schemas.`);
 				continue;
 			}
-			sides.push({
+			if (key === "allOf") for (const [index, item] of items.entries()) this.parts(item, [
+				...at,
 				key,
-				type: unionOf(items.map((item, index) => this.read(item, [
-					...at,
-					key,
-					index
-				], depth + 1)))
-			});
+				index
+			], depth + 1, types, conditions);
+			else types.push(unionOf(items.map((item, index) => this.read(item, [
+				...at,
+				key,
+				index
+			], depth + 1))));
 		}
 		const values = this.values(schema, at);
-		if (values !== void 0) return { one: values.filter((value) => sides.every((side) => member(value, side.type))) };
-		const known = sides.filter((side) => !isUnknown(side.type, void 0));
-		const kept = known[0];
-		if (kept === void 0) return "unknown";
-		for (const side of known.slice(1)) this.issue([...at, side.key], `The type reads the keyword ${kept.key}, and not the keyword ${side.key}.`);
-		return kept.type;
+		if (values !== void 0) types.push({ one: values });
+	}
+	/** This method reads the target of a reference: a definition of the root schema, or `undefined` for each value. */
+	target(ref, at, depth) {
+		const match = typeof ref === "string" ? LOCAL_REF.exec(ref) : null;
+		let name;
+		try {
+			name = match === null ? void 0 : decodeURIComponent(match[2] ?? "").replace(/~1/g, "/").replace(/~0/g, "~");
+		} catch {
+			name = void 0;
+		}
+		if (match === null || name === void 0) {
+			this.issue(at, "The type reads only a $ref to #/$defs/<name> or #/definitions/<name> of the same schema. Thus it reads the schema as unknown.");
+			return;
+		}
+		if (this.inner > 0) {
+			this.issue(at, "A $ref inside a schema with its own $id has another base. Thus the type reads the schema as unknown.");
+			return;
+		}
+		const group = match[1];
+		const defs = isRecord(this.root) ? this.root[group] : void 0;
+		if (!isRecord(defs) || !Object.hasOwn(defs, name)) {
+			this.issue(at, `The schema has no definition ${String(ref)}. Thus the type reads the reference as unknown.`);
+			return;
+		}
+		const key = `${group}/${name}`;
+		const known = this.defs.get(key);
+		if (known !== void 0) return known;
+		if (this.open.has(key)) {
+			this.issue(at, `The reference ${String(ref)} is in a cycle. The type reads this reference as unknown.`);
+			return;
+		}
+		this.open.add(key);
+		try {
+			const type = this.read(defs[name], [group, name], depth + 1);
+			this.defs.set(key, type);
+			return type;
+		} finally {
+			this.open.delete(key);
+		}
 	}
 	/** This method reads `enum` and `const`: the values that the schema permits, or `undefined` without them. */
 	values(schema, at) {
@@ -17379,17 +18295,20 @@ var SchemaReader = class {
 * - `properties`, `required` and `additionalProperties` give a record. `false` closes it, and a property that is not
 *   in `required` is optional.
 * - `items` gives a list. `enum` and `const` give `one`. `anyOf` and `oneOf` give a union.
+* - `$ref` reads a definition in `$defs` or `definitions` of the same schema (TYPE.SCHEMA-REF). Another reference, a
+*   missing definition and a reference in a cycle read as `unknown`.
+* - `allOf` and the other keywords of a schema give the meet of their types (TYPE.SCHEMA-ALLOF). Records merge their
+*   fields, and a closed part keeps the merge closed.
 *
 * The type holds each value that the schema accepts. Each keyword that the function does not read tests nothing, as
-* `unknown`, and the issues name it. Examples are `minimum`, `pattern` and `allOf`. A schema with `$ref` or `nullable`
-* reads as `unknown`, because these keywords can permit more values. A schema with more than one of `type`, `anyOf`
-* and `oneOf` gives the type of the first, and an issue for each other. The function does not throw.
+* `unknown`, and the issues name it. Examples are `minimum` and `pattern`. A schema with `nullable` or `$dynamicRef`
+* reads as `unknown`, because these keywords can permit more values. The function does not throw.
 *
 * @param schema - The schema, as JSON.
 * @returns The type, and the problems of the reading with their keys in the schema.
 */
 function typeFromSchema(schema) {
-	const reader = new SchemaReader();
+	const reader = new SchemaReader(schema);
 	try {
 		return {
 			type: reader.read(schema, [], 0),
@@ -17469,6 +18388,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, collectOf, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map