@mark1russell7/coeval 0.7.1 → 0.8.0

package/build/index.js

@@ -357,6 +357,17 @@ function describe(value) {
 //#endregion
 //#region src/world.ts
 /**
+* This function gives the type of a bare equation of a kind (D42). It is the type `of` of the shape of its parts, or
+* else the type `of` of the shape `rest` of a record. The plan, the reference and `check` read it with this one function.
+*
+* @param kind - The kind.
+* @returns The type, or `undefined` when the shape declares none.
+*/
+function equationType(kind) {
+	const parts = kind.parts;
+	return parts?.of ?? parts?.rest?.of;
+}
+/**
 * This function tells if an entry of the world is a kind.
 *
 * @param entry - The entry.
@@ -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",
@@ -2667,6 +2678,75 @@ function pathMatches(path, pattern) {
 	}
 	return true;
 }
+function valueAt(value, path) {
+	let here = value;
+	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
+	else if (isRecord(here) && Object.hasOwn(here, String(key))) here = here[String(key)];
+	else return void 0;
+	return here;
+}
+function headerName(item) {
+	return isEnvelope(item) && typeof item.name === "string" ? item.name : void 0;
+}
+function namesOf(source, value, covered) {
+	if ("fixed" in source) return source.fixed;
+	if ("keysAt" in source) {
+		const at = valueAt(value, source.keysAt);
+		return isRecord(at) ? Object.keys(at) : [];
+	}
+	if ("listAt" in source) {
+		const at = valueAt(value, source.listAt);
+		return Array.isArray(at) ? at.filter((item) => typeof item === "string") : [];
+	}
+	if ("textAt" in source) {
+		const at = valueAt(value, source.textAt);
+		if (typeof at === "string") return [at];
+		return source.otherwise === void 0 ? [] : [source.otherwise];
+	}
+	return covered.map((slot) => headerName(slot.item)).filter((name) => name !== void 0);
+}
+/**
+* This function gives the names that the scope rules of a kind give each part, and the names that only later parts
+* see. `check`, `conforms` and the plan read the scope rules with it.
+*
+* @param rules - The scope rules of the kind.
+* @param value - The value of the document.
+* @param slots - The parts of the value, in order.
+* @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
+*/
+function scopesOf(rules, value, slots) {
+	const sees = slots.map(() => []);
+	const later = slots.map(() => []);
+	for (const rule of rules ?? []) {
+		const covered = slots.map((slot, index) => ({
+			slot,
+			index
+		})).filter(({ slot }) => rule.in.some((pattern) => pathMatches(slot.path, pattern)));
+		if (rule.sequential !== true) {
+			const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+			for (const { index } of covered) sees[index]?.push(...names);
+			continue;
+		}
+		if ("headers" in rule.names) {
+			covered.forEach(({ index }, position) => {
+				const before = covered.slice(0, position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
+				const after = covered.slice(position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
+				sees[index]?.push(...before);
+				later[index]?.push(...after);
+			});
+			continue;
+		}
+		const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+		covered.forEach(({ index }, position) => {
+			if (position > 0) sees[index]?.push(...names);
+			else later[index]?.push(...names);
+		});
+	}
+	return {
+		sees,
+		later
+	};
+}
 //#endregion
 //#region src/evaluate.ts
 /**
@@ -2727,7 +2807,7 @@ function narrow(parent, next) {
 	};
 }
 /** No capabilities. One list serves each masked part. */
-const NO_CAPS$1 = /* @__PURE__ */ Object.freeze([]);
+const NO_CAPS$2 = /* @__PURE__ */ Object.freeze([]);
 /** No capability rules. One list serves each part that no rule narrows. */
 const NO_RULES = /* @__PURE__ */ Object.freeze([]);
 /**
@@ -2755,7 +2835,7 @@ function rulesFor(rules, path) {
 function capsUnder(rules, caps) {
 	let out = caps;
 	for (const rule of rules) {
-		if (rule.rule === "mask") return NO_CAPS$1;
+		if (rule.rule === "mask") return NO_CAPS$2;
 		if (rule.rule === "only") out = intersectCaps(out, rule.caps);
 	}
 	return out;
@@ -2786,7 +2866,7 @@ const GRANT = /* @__PURE__ */ Symbol("coeval.grant");
 function granted(ctx) {
 	const grant = ctx[GRANT];
 	if (grant === ctx.caps) return ctx;
-	const caps = grant === void 0 ? NO_CAPS$1 : ctx.caps.every((cap) => permits(grant, cap)) ? ctx.caps : ctx.caps.filter((cap) => permits(grant, cap));
+	const caps = grant === void 0 ? NO_CAPS$2 : ctx.caps.every((cap) => permits(grant, cap)) ? ctx.caps : ctx.caps.filter((cap) => permits(grant, cap));
 	return {
 		...ctx,
 		caps,
@@ -2952,6 +3032,10 @@ var Session = class {
 	get effects() {
 		return this.list ??= [];
 	}
+	/** `true` when the evaluation records its reads. Then folded code evaluates again, thus each read goes in the list (PLAN.FOLD). */
+	get recording() {
+		return this.reading !== void 0;
+	}
 	resolve(ctx, path, options) {
 		return this.read(ctx, path, void 0, options);
 	}
@@ -3416,6 +3500,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	let meta = meta0;
 	let name;
 	let unknown;
+	let quick;
 	if (c.traced) {
 		const answer = ask(world, envelope ?? {}, c.verb, declared === void 0 ? {} : { declaredType: declared });
 		meta = {
@@ -3426,7 +3511,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		name = answer.evaluator;
 		unknown = answer.error === "unknown-kind";
 	} else {
-		const quick = answerOf(world, envelope?.own, kind ?? null, c.verb);
+		quick = answerOf(world, envelope?.own, kind ?? null, c.verb);
 		name = quick?.name;
 		unknown = quick === void 0 && kind === void 0;
 	}
@@ -3437,9 +3522,11 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	const evaluator = name !== void 0 && Object.hasOwn(c.machine.evaluators, name) ? c.machine.evaluators[name] : void 0;
 	if (name === void 0 || runner === void 0 && evaluator === void 0) return failing(c, meta, place, "#NOEVAL", `No rung gives an evaluator for ${kindText}.`);
 	if (!split.ok) return failing(c, meta, place, "#VALUE!", split.reason);
+	const frees = c.fold ? [] : void 0;
 	const parts = split.parts.map((slot) => {
 		const item = slot.item;
 		const own = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1, slot.address === true);
+		frees?.push(own.free);
 		const rules = rulesFor(kind?.caps, slot.path);
 		const compiled = rules.length === 0 ? own : gated(rules, own);
 		const header = typeof item?.name === "string" && isEnvelope(item) ? item.name : void 0;
@@ -3457,9 +3544,10 @@ function compileNode(c, value, place, declared, depth, address = false) {
 			run
 		};
 	});
+	const typePath = read.typePath ?? [];
 	const input = {
 		kind: kindText,
-		typePath: read.typePath ?? [],
+		typePath,
 		doc,
 		value: split.parts.length === 0 ? doc.value : split.fill(parts),
 		data: split.data,
@@ -3485,7 +3573,238 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	} catch (error) {
 		return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
 	}
-	return finish$1(c, meta, placedCode(inner, place, name), void 0);
+	const done = finish$1(c, meta, placedCode(inner, place, name), void 0);
+	if (frees === void 0 || kind === void 0 || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
+	const free = freeOf(doc, kind, split.parts, frees);
+	if (free === void 0) return done;
+	return free.length === 0 ? folded(c, done) : {
+		code: done.code,
+		run: done.run,
+		free
+	};
+}
+/** The free names of a closed part. */
+const CLOSED = /* @__PURE__ */ Object.freeze([]);
+/**
+* This function tells if the code of a document is pure, by the facts of D24 (FACTS.PURE). It reads the facts as
+* `factsOf` reads them. A kind with a run side, with declared effects or with volatile code is not pure here.
+*/
+function pureCode(c, envelope, kind, typePath, name, quick) {
+	if (kind.side === "run" || kind.effects !== void 0 && kind.effects.length > 0) return false;
+	let answer;
+	try {
+		answer = c.machine.facts?.(typePath, name);
+	} catch {
+		return false;
+	}
+	const described = c.verb === "eval" && (envelope === void 0 || quick?.rung !== "own" || name === answerOf(c.machine.world, void 0, kind, c.verb)?.name);
+	const pure = described ? answer?.pure ?? kind.pure : answer?.pure;
+	const volatile = described ? answer?.volatile ?? kind.volatile : answer?.volatile;
+	return pure === true && volatile !== true;
+}
+/**
+* This function gives the names that a document reads and does not bind, or `undefined` when the document can read
+* other roots. A reference reads the name of its path. Each other document reads the free names of its parts, less
+* the names that its scope rules give each part (STATIC.REFS).
+*/
+function freeOf(doc, kind, slots, frees) {
+	if (isRef(doc)) {
+		const path = doc.value;
+		if (path.length < 2 || path[0] !== "names" || !path.every((step, index) => index === 0 || isKey(step))) return void 0;
+		return [String(path[1])];
+	}
+	let sees;
+	let out;
+	for (let index = 0; index < frees.length; index += 1) {
+		const free = frees[index];
+		if (free === void 0) return void 0;
+		if (free.length === 0) continue;
+		if (sees === void 0) sees = kind.scope === void 0 || kind.scope.length === 0 ? [] : scopesOf(kind.scope, doc.value, slots).sees;
+		const bound = sees[index] ?? CLOSED;
+		for (const name of free) {
+			if (bound.includes(name)) continue;
+			out ??= [];
+			if (!out.includes(name)) out.push(name);
+		}
+	}
+	return out ?? CLOSED;
+}
+/** This class is the runtime of a fold. It reads only the names that the folded part binds, and it causes no effect. */
+var Probe = class {
+	machine;
+	running = false;
+	/** `true` after the part asked for something that a fold cannot give. */
+	refused = false;
+	/** The count of the names that the part read. */
+	reads = 0;
+	/**
+	* The context of the folded part. Its roots `self`, `event` and `names` are traps: a direct read of a field
+	* refuses the fold, as a resolution of these roots does. A copy of the record of the names reads no field.
+	*/
+	root;
+	constructor(machine) {
+		this.machine = machine;
+		const refuse = () => {
+			this.refused = true;
+		};
+		const root = {
+			self: trap(refuse, false),
+			event: trap(refuse, false),
+			names: trap(refuse, true),
+			world: worldThing(machine.world),
+			caps: NO_CAPS$2,
+			[GRANT]: NO_CAPS$2
+		};
+		this.root = root;
+	}
+	resolve(ctx, path) {
+		const name = path[1];
+		if (path[0] === "names" && isKey(name) && Object.hasOwn(ctx.names, String(name))) {
+			this.reads += 1;
+			const found = resolve(this.machine, ctx, path, WITH_HOPS);
+			if (found.hops.some((hop) => hop.by === "collapse" || isRef(hop.thing))) this.refused = true;
+			return found;
+		}
+		this.refused = true;
+		return {
+			ok: false,
+			code: "#REF!",
+			reason: "A folded part reads only the names that it binds.",
+			hops: []
+		};
+	}
+	effect() {
+		this.refused = true;
+		return fail("#CAP!", "A folded part causes no effect.");
+	}
+	*runEffect() {
+		return this.effect();
+	}
+	*all() {
+		this.refused = true;
+		return [];
+	}
+	keepsContext() {
+		this.refused = true;
+	}
+};
+/**
+* This function makes a trap for a root of the context of a fold. Each read of a field calls `refuse`. A trap of the
+* names gives no keys, thus a copy of the names reads no field.
+*/
+function trap(refuse, copies) {
+	const no = () => {
+		refuse();
+	};
+	return new Proxy({}, {
+		get: no,
+		getOwnPropertyDescriptor: no,
+		has: () => (refuse(), false),
+		ownKeys: () => {
+			if (!copies) refuse();
+			return [];
+		},
+		getPrototypeOf: () => (refuse(), null),
+		set: () => (refuse(), false),
+		defineProperty: () => (refuse(), false),
+		deleteProperty: () => (refuse(), false)
+	});
+}
+/**
+* This function folds the code of a closed pure part. The part evaluates one time with the probe. Its result becomes
+* one deeply frozen copy, and the code gives that copy at each evaluation (PLAN.SHARED). A fold that the probe cancels
+* gives the code without free names, thus no parent tries the fold again.
+*/
+function folded(c, done) {
+	const probe = c.probe ??= new Probe(c.machine);
+	probe.refused = false;
+	probe.reads = 0;
+	let constant;
+	try {
+		const result = done.code(probe.root, probe);
+		if (!probe.refused && (result.ok || result.error.code !== "#DEPTH!")) constant = sharedCopy(result);
+	} catch {
+		constant = void 0;
+	}
+	if (constant === void 0) return {
+		code: done.code,
+		run: done.run
+	};
+	const value = constant;
+	if (probe.reads === 0) return {
+		code: () => value,
+		run: void 0,
+		free: CLOSED
+	};
+	const original = done.code;
+	return {
+		code: (ctx, rt) => rt instanceof Session && !rt.traced && !rt.recording ? value : original(ctx, rt),
+		run: void 0,
+		free: CLOSED
+	};
+}
+/** The objects that a fold made. Each one is deeply frozen, thus a later fold uses it again and does not copy it. */
+const SHARED = /* @__PURE__ */ new WeakSet();
+/** The mark of a value that is not plain data. */
+const NOT_PLAIN = /* @__PURE__ */ Symbol("not plain");
+/**
+* This function gives a deeply frozen copy of plain data, or `undefined` for other values. Plain data is a primitive or
+* an array without holes and extra keys. It is also a record of enumerable data fields with the prototype of an object
+* or no prototype. The copy keeps cycles and shared objects. The objects of the host do not change.
+*/
+function sharedCopy(value) {
+	try {
+		const out = copyPlain(value, /* @__PURE__ */ new Map());
+		return out === NOT_PLAIN ? void 0 : out;
+	} catch {
+		return;
+	}
+}
+/** This function copies one value for `sharedCopy`. The map holds the copy of each object that the copy saw. */
+function copyPlain(value, memo) {
+	if (typeof value === "function") return NOT_PLAIN;
+	if (typeof value !== "object" || value === null) return value;
+	if (SHARED.has(value)) return value;
+	const seen = memo.get(value);
+	if (seen !== void 0) return seen;
+	const proto = Object.getPrototypeOf(value);
+	const keys = Reflect.ownKeys(value);
+	let out;
+	if (Array.isArray(value)) {
+		if (proto !== Array.prototype || keys.length !== value.length + 1) return NOT_PLAIN;
+		const list = [];
+		memo.set(value, list);
+		for (let index = 0; index < value.length; index += 1) {
+			const field = Object.getOwnPropertyDescriptor(value, index);
+			if (field === void 0 || !("value" in field) || field.enumerable !== true) return NOT_PLAIN;
+			const item = copyPlain(field.value, memo);
+			if (item === NOT_PLAIN) return NOT_PLAIN;
+			list.push(item);
+		}
+		out = list;
+	} else {
+		if (proto !== Object.prototype && proto !== null) return NOT_PLAIN;
+		const record = proto === null ? Object.create(null) : {};
+		memo.set(value, record);
+		for (const key of keys) {
+			if (typeof key !== "string") return NOT_PLAIN;
+			const field = Object.getOwnPropertyDescriptor(value, key);
+			if (field === void 0 || !("value" in field) || field.enumerable !== true) return NOT_PLAIN;
+			const item = copyPlain(field.value, memo);
+			if (item === NOT_PLAIN) return NOT_PLAIN;
+			if (key === "__proto__") Object.defineProperty(record, key, {
+				value: item,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			else record[key] = item;
+		}
+		out = record;
+	}
+	Object.freeze(out);
+	SHARED.add(out);
+	return out;
 }
 /**
 * This function gives the code of a document: the code of its evaluator, with the place of each error and of each
@@ -3650,12 +3969,14 @@ function prepare(machine, doc, options = {}) {
 		error: "no-answer",
 		steps: []
 	};
+	const traced = options.trace === true;
 	const c = {
 		machine,
-		traced: options.trace === true,
+		traced,
 		maxDepth: machine.maxDepth ?? 1e3,
 		verb,
-		noAnswer
+		noAnswer,
+		fold: !traced && options.fold !== false
 	};
 	let root;
 	try {
@@ -3753,8 +4074,8 @@ function record(s, result) {
 * tells where its parts are. The evaluator gets each part sealed: it can evaluate the part, and it cannot read its
 * value.
 *
-* A failure gives an error value, and the function does not throw. An effect is recorded in its order, and the host
-* does not do it. A mock can answer each effect at once (RUN.MOCK).
+* A failure gives an error value, and the function does not throw. The function records each effect in its order,
+* and the host does not do it. A mock can answer each effect at once (RUN.MOCK).
 *
 * @param machine - The world and the code of the evaluators.
 * @param doc - The document, as JSON.
@@ -4112,6 +4433,56 @@ const STD_EVALUATORS = {
 };
 /** The brand of a node of the decorated tree. Its value is the state that the kit reads. */
 const TREE_NODE = /* @__PURE__ */ Symbol.for("coeval.tree.node");
+/** The rungs of the ladder of an attribute, in their order (TREE.LADDER, D42). */
+const ATTRIBUTE_RUNGS = /* @__PURE__ */ Object.freeze([
+	"own",
+	"kind",
+	"parent",
+	"copy",
+	"default"
+]);
+/** The capabilities of an equation: none (CAP.PURE). */
+const NO_CAPS$1 = /* @__PURE__ */ Object.freeze([]);
+/** The names of an equation of `equations`, of a `unit` and of a `default`. */
+const NO_NAMES$1 = /* @__PURE__ */ Object.freeze({});
+/** The planners of equations, for each machine and each type of a bare equation (TREE.PLAN). */
+const equationPlanners = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives the plan of an equation. Each equation compiles one time for each machine (PLAN.CACHE). The
+* plan of the document does not keep it (PLAN.LEAN).
+*/
+function equationPlan(machine, of, term) {
+	let byType = equationPlanners.get(machine);
+	if (byType === void 0) {
+		byType = /* @__PURE__ */ new Map();
+		equationPlanners.set(machine, byType);
+	}
+	const key = of ?? "";
+	let plans = byType.get(key);
+	if (plans === void 0) {
+		plans = planner(machine, of === void 0 ? {} : { declaredType: of });
+		byType.set(key, plans);
+	}
+	return plans(term);
+}
+/** This function gives the own entry of a table of a tree contract, or `undefined`. */
+function entryOf(table, key) {
+	return table !== void 0 && Object.hasOwn(table, key) ? table[key] : void 0;
+}
+const NO_CONTRACT = /* @__PURE__ */ Object.freeze({
+	tree: void 0,
+	of: void 0
+});
+/** This function finds the tree contract of the kind of a node in the world of the machine. */
+function contractOf$1(machine, typePath) {
+	if (machine === void 0 || typePath.length === 0) return NO_CONTRACT;
+	const found = lookupKind(machine.world, typePath);
+	if (!found.ok || found.kind.tree === void 0) return NO_CONTRACT;
+	return {
+		tree: found.kind.tree,
+		of: equationType(found.kind)
+	};
+}
 const BUSY = /* @__PURE__ */ Object.freeze({ busy: true });
 /** The attributes in evaluation, in the order of their demands. An evaluation does not wait, thus one list serves. */
 const demands = [];
@@ -4179,28 +4550,92 @@ function plainOf(value, path) {
 }
 /**
 * This function makes a node of the decorated tree. A step `parent` gives the self of the context of the node, and a
-* step `type` gives its type. A step with the key of a part reads that attribute. A failed attribute throws `Failure`
-* with its own error, thus a reference to it gives that error.
+* step `type` gives its type. Another step reads an attribute through its ladder (TREE.LADDER). The rungs are a part of
+* the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
+* fold or a default, come last. A failed attribute throws `Failure` with its own error, thus a reference to it gives that error.
 */
-function treeThing(parts, context, type, place, build) {
+function treeThing(input, build) {
+	const { parts, context, kind: type, place, machine } = input;
+	const { tree, of } = contractOf$1(machine, input.typePath);
+	const above = stateOf(context.self);
+	const up = above !== void 0 && above.build === build ? above : void 0;
 	const cells = /* @__PURE__ */ new Map();
+	/** The positions of the items of the list `children`, for the names of the children. */
+	let positions;
+	const fold = (key, declared) => {
+		let acc = state.equation(declared.unit, NO_NAMES$1);
+		if (!acc.ok) return acc;
+		const children = read("children");
+		if (children === void 0) return acc;
+		if (!children.ok) return children;
+		if (!Array.isArray(children.value)) return fail("#VALUE!", `The fold of ${key} needs a list in children.`);
+		for (const item of children.value) {
+			const child = stateOf(item);
+			if (child === void 0 || child.build !== build) continue;
+			const value = child.read(key);
+			if (value === void 0) return fail("#N/A", `No rung gives ${attributeText(key, child.type, child.place)}.`);
+			if (!value.ok) return value;
+			acc = state.equation(declared.combine, {
+				acc: acc.value,
+				item: value.value
+			});
+			if (!acc.ok) return acc;
+		}
+		return acc;
+	};
+	/** This function visits the rungs of the ladder of an attribute in their order, until one answers. */
+	const climb = (key) => {
+		const part = parts.find((item) => item.key === key);
+		if (part !== void 0) return {
+			result: part.evaluate({
+				...context,
+				self: node
+			}),
+			by: "own"
+		};
+		const equation = entryOf(tree?.equations, key);
+		if (equation !== void 0) return {
+			result: state.equation(equation, NO_NAMES$1),
+			by: "kind"
+		};
+		const down = up === void 0 ? void 0 : entryOf(up.tree?.down, key);
+		if (up !== void 0 && down !== void 0) {
+			const names = up.childNames(node);
+			return {
+				result: names.ok ? up.equation(down, names.value) : names,
+				by: "parent"
+			};
+		}
+		const declared = entryOf(tree?.attributes, key);
+		if (declared?.copy === true && up !== void 0) {
+			const copied = up.read(key);
+			if (copied !== void 0) return {
+				result: copied,
+				by: "copy"
+			};
+		}
+		if (declared?.fold !== void 0) return {
+			result: fold(key, declared.fold),
+			by: "default"
+		};
+		if (declared?.default !== void 0) return {
+			result: state.equation(declared.default, NO_NAMES$1),
+			by: "default"
+		};
+	};
 	const read = (key) => {
 		const cell = cells.get(key);
 		if (cell !== void 0) return cell.busy ? cycleAt(cells, key, attributeText(key, type, place)) : cell.result;
-		const part = parts.find((item) => item.key === key);
-		if (part === void 0) return void 0;
+		if (tree === void 0 && up?.tree === void 0 && !parts.some((item) => item.key === key)) return void 0;
 		cells.set(key, BUSY);
 		demands.push({
 			cells,
 			key,
 			text: attributeText(key, type, place)
 		});
-		let result;
+		let answer;
 		try {
-			result = part.evaluate({
-				...context,
-				self: node
-			});
+			answer = climb(key);
 		} catch (error) {
 			cells.delete(key);
 			throw error;
@@ -4209,14 +4644,60 @@ function treeThing(parts, context, type, place, build) {
 		}
 		cells.set(key, {
 			busy: false,
-			result
+			result: answer?.result,
+			by: answer?.by
 		});
-		return result;
+		return answer?.result;
 	};
 	const state = {
 		build,
 		type,
 		place,
+		tree,
+		read,
+		equation(term, names) {
+			if (machine === void 0) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
+			return equationPlan(machine, of, term).evaluate({
+				...context,
+				names,
+				caps: NO_CAPS$1,
+				self: node
+			});
+		},
+		childNames(child) {
+			const children = read("children");
+			if (children !== void 0 && !children.ok) return children;
+			const list = children !== void 0 && Array.isArray(children.value) ? children.value : [];
+			if (positions?.list !== list) {
+				const at = /* @__PURE__ */ new Map();
+				list.forEach((item, index) => {
+					if (!at.has(item)) at.set(item, index);
+				});
+				positions = {
+					list,
+					at
+				};
+			}
+			const index = positions.at.get(child);
+			return ok({
+				child,
+				index: index ?? null,
+				prev: index === void 0 || index === 0 ? null : list[index - 1]
+			});
+		},
+		trace(key) {
+			const cell = cells.get(key);
+			if (cell === void 0 || cell.busy) return void 0;
+			const rungs = cell.by === void 0 ? ATTRIBUTE_RUNGS : ATTRIBUTE_RUNGS.slice(0, ATTRIBUTE_RUNGS.indexOf(cell.by) + 1);
+			return cell.by === void 0 ? {
+				attribute: key,
+				rungs
+			} : {
+				attribute: key,
+				rungs,
+				by: cell.by
+			};
+		},
 		json(path) {
 			path.add(node);
 			try {
@@ -4248,7 +4729,9 @@ function treeThing(parts, context, type, place, build) {
 			return result.value;
 		},
 		has(key) {
-			return key === "parent" || key === "type" || parts.some((part) => part.key === String(key));
+			if (key === "parent" || key === "type" || parts.some((part) => part.key === String(key))) return true;
+			const cell = cells.get(String(key));
+			return cell !== void 0 && !cell.busy && cell.result !== void 0;
 		},
 		toJson() {
 			const result = state.json(/* @__PURE__ */ new Set());
@@ -4259,14 +4742,25 @@ function treeThing(parts, context, type, place, build) {
 	return node;
 }
 /**
+* This function gives the record of the demand of an attribute of a node of the decorated tree (TREE.RUNGS). The
+* record holds the rungs that the demand visited, and the rung that answered. An explorer draws the ladder with it.
+*
+* @param node - The thing of a node.
+* @param attribute - The name of the attribute.
+* @returns The record, or `undefined` for a thing that is not a node or an attribute that no demand reached.
+*/
+function attributeTrace(node, attribute) {
+	return stateOf(node)?.trace(attribute);
+}
+/**
 * This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
 * thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree.
 */
-function treeNode({ parts, context, kind, place }) {
-	const above = stateOf(context.self);
-	if (above !== void 0 && above.build.open) return ok(treeThing(parts, context, kind, place, above.build));
+function treeNode(input) {
+	const above = stateOf(input.context.self);
+	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build));
 	const build = { open: true };
-	const root = treeThing(parts, context, kind, place, build);
+	const root = treeThing(input, build);
 	try {
 		return stateOf(root).json(/* @__PURE__ */ new Set());
 	} finally {
@@ -5009,75 +5503,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 +5847,81 @@ function typeCheck(machine, doc, options = {}) {
 		places: pass.places
 	};
 }
+/** The names that an equation of `down` sees (TREE.DOWN). */
+const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
+	"child",
+	"index",
+	"prev"
+]);
+/** The names that the term `combine` of a fold sees (TREE.FOLD). */
+const FOLD_NAMES = /* @__PURE__ */ Object.freeze(["acc", "item"]);
+/**
+* This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
+* `equations`, a `unit` and a `default` see no names.
+*/
+function equationsOf(kind) {
+	const tree = kind.tree;
+	if (tree === void 0) return [];
+	const out = [];
+	for (const [name, term] of Object.entries(tree.equations ?? {})) out.push({
+		label: `tree.equations.${name}`,
+		term,
+		names: []
+	});
+	for (const [name, term] of Object.entries(tree.down ?? {})) out.push({
+		label: `tree.down.${name}`,
+		term,
+		names: DOWN_NAMES
+	});
+	for (const [name, declared] of Object.entries(tree.attributes ?? {})) {
+		if (declared.fold !== void 0) {
+			out.push({
+				label: `tree.attributes.${name}.fold.unit`,
+				term: declared.fold.unit,
+				names: []
+			});
+			out.push({
+				label: `tree.attributes.${name}.fold.combine`,
+				term: declared.fold.combine,
+				names: FOLD_NAMES
+			});
+		}
+		if (declared.default !== void 0) out.push({
+			label: `tree.attributes.${name}.default`,
+			term: declared.default,
+			names: []
+		});
+	}
+	return out;
+}
+/**
+* This function checks the equations of the tree contract of a kind, each with the names of its rung (TREE.DOWN-NAMES).
+* An equation evaluates without capabilities, thus a check with capabilities gives it none. Each issue gets the place
+* of the document of the kind, and its reason names the equation.
+*/
+function equationIssues(machine, kind, kindText, options, seen) {
+	const of = equationType(kind);
+	const out = [];
+	for (const { label, term, names } of equationsOf(kind)) {
+		const inner = {
+			names,
+			...of === void 0 ? {} : { declaredType: of },
+			...options.caps === void 0 ? {} : { caps: [] }
+		};
+		for (const issue of checkAll(machine, term, inner, void 0, seen)) out.push({
+			code: issue.code,
+			place: [],
+			reason: `In the equation ${label} of the kind ${kindText}: ${issue.reason}`
+		});
+	}
+	return out;
+}
 /**
 * This function finds the issues of `check`. With a list of nodes, it also records each document that it visits for
-* the pass of types. It marks each document with an issue.
+* the pass of types. It marks each document with an issue. The set `seen` holds the kinds whose equations the check
+* walked, thus it walks the equations of each kind one time.
 */
-function checkAll(machine, doc, options, nodes) {
+function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()) {
 	const issues = [];
 	const verb = options.verb ?? "eval";
 	const indices = nodes === void 0 ? void 0 : /* @__PURE__ */ new Map();
@@ -5478,6 +5973,14 @@ function checkAll(machine, doc, options, nodes) {
 			});
 			return "skip";
 		}
+		if (v.kind?.tree !== void 0 && !seen.has(v.kind)) {
+			seen.add(v.kind);
+			for (const issue of equationIssues(machine, v.kind, typeName(v.doc.type), options, seen)) push({
+				...issue,
+				place: v.place,
+				at: v.at
+			});
+		}
 		const name = answer.evaluator;
 		if (current !== void 0) current.evaluator = name;
 		const runner = name !== void 0 && has(machine.runners, name);
@@ -7857,13 +8360,22 @@ function examine$1(env, at) {
 		split
 	};
 }
+/**
+* This function gives the effects that two lists of capabilities both permit (CAP.ONLY). The reference reads the rule
+* from SPEC directly, and not from the intersection of the plan. Thus `agree` finds a bug in either one (D15).
+*/
+function bothPermit(a, b) {
+	const out = [];
+	for (const cap of [...a, ...b]) if (permits(a, cap) && permits(b, cap) && !permits(out, cap)) out.push(cap);
+	return out;
+}
 /** This function gives the capabilities that the rules of a kind give one part (D14, CAP.CONTRACT, CAP.ONLY). */
 function capsOfPart(rules, path, caps) {
 	let out = caps;
 	for (const rule of rules ?? []) {
 		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(path, pattern))) continue;
 		if (rule.rule === "mask") return [];
-		if (rule.rule === "only") out = intersectCaps(out, rule.caps);
+		if (rule.rule === "only") out = bothPermit(out, rule.caps);
 	}
 	return out;
 }
@@ -8135,6 +8647,7 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		...context,
 		world: worldThing(machine.world)
 	} : context;
+	activeEnvs.push(env);
 	try {
 		return evaluateAt(env, {
 			value: doc,
@@ -8146,8 +8659,12 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		});
 	} catch (error) {
 		return placed(thrown(error, "the reference"), []);
+	} finally {
+		activeEnvs.pop();
 	}
 }
+/** The evaluations of the reference that run at this time, the innermost last. */
+const activeEnvs = [];
 const refNodes = /* @__PURE__ */ new WeakMap();
 /** The attributes in evaluation in the reference, in the order of their demands (TREE.CYCLE). */
 const inEvaluation = [];
@@ -8157,28 +8674,109 @@ function nameOfAttribute(node, name) {
 function refNodeOf(thing) {
 	return typeof thing === "object" && thing !== null ? refNodes.get(thing) : void 0;
 }
-/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when the node has no such part. */
-function attributeOf(node, self, name) {
+/**
+* TREE.LADDER: an equation of the kind of a node evaluates in the reference. It gets the node as `self`, the names of
+* its rung and no capabilities. A bare equation gets the type `of` of the parts of the kind.
+*/
+function equationOf(node, term, names) {
+	const env = node.env;
+	if (env === void 0) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
+	const ctx = {
+		...node.ctx,
+		names,
+		caps: [],
+		self: node.thing
+	};
+	return reference(env.machine, term, ctx, {
+		definitions: env.definitions,
+		...node.of === void 0 ? {} : { declaredType: node.of }
+	});
+}
+function termIn(table, name) {
+	return table === void 0 || !Object.hasOwn(table, name) ? void 0 : table[name];
+}
+/** TREE.DOWN: the names of a child for an equation of `down` of its parent: `child`, `index` and `prev`. */
+function namesOfChild(up, child) {
+	const children = attributeOf(up, "children");
+	if (children !== void 0 && !children.ok) return children;
+	const list = children !== void 0 && Array.isArray(children.value) ? children.value : [];
+	const index = list.indexOf(child.thing);
+	return ok({
+		child: child.thing,
+		index: index < 0 ? null : index,
+		prev: index > 0 ? list[index - 1] : null
+	});
+}
+/** TREE.FOLD: the unit, then `combine` with the attribute of each node of this tree in the list `children`. */
+function foldOf(node, name, fold) {
+	let acc = equationOf(node, fold.unit, {});
+	if (!acc.ok) return acc;
+	const children = attributeOf(node, "children");
+	if (children === void 0) return acc;
+	if (!children.ok) return children;
+	if (!Array.isArray(children.value)) return fail("#VALUE!", `The fold of ${name} needs a list in children.`);
+	for (const item of children.value) {
+		const child = refNodeOf(item);
+		if (child === void 0 || child.tree !== node.tree) continue;
+		const value = attributeOf(child, name);
+		if (value === void 0) return fail("#N/A", `No rung gives ${nameOfAttribute(child, name)}.`);
+		if (!value.ok) return value;
+		acc = equationOf(node, fold.combine, {
+			acc: acc.value,
+			item: value.value
+		});
+		if (!acc.ok) return acc;
+	}
+	return acc;
+}
+/**
+* TREE.LADDER: the rungs of the ladder of an attribute, in their order. A rung gives `undefined` when it does not
+* answer, and the next rung then tries.
+*/
+const REF_RUNGS = [
+	["own", (node, name) => node.parts.find((item) => item.key === name)?.evaluate({
+		...node.ctx,
+		self: node.thing
+	})],
+	["kind", (node, name) => {
+		const term = termIn(node.contract?.equations, name);
+		return term === void 0 ? void 0 : equationOf(node, term, {});
+	}],
+	["parent", (node, name) => {
+		const up = node.up;
+		const term = up === void 0 ? void 0 : termIn(up.contract?.down, name);
+		if (up === void 0 || term === void 0) return void 0;
+		const names = namesOfChild(up, node);
+		return names.ok ? equationOf(up, term, names.value) : names;
+	}],
+	["copy", (node, name) => node.up !== void 0 && termIn(node.contract?.attributes, name)?.copy === true ? attributeOf(node.up, name) : void 0],
+	["default", (node, name) => {
+		const declared = termIn(node.contract?.attributes, name);
+		if (declared?.fold !== void 0) return foldOf(node, name, declared.fold);
+		return declared?.default === void 0 ? void 0 : equationOf(node, declared.default, {});
+	}]
+];
+/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when no rung of its ladder answers. */
+function attributeOf(node, name) {
 	const done = node.values.get(name);
 	if (done !== void 0) return done;
 	if (node.pending.has(name)) {
 		const from = inEvaluation.findIndex((entry) => entry.node === node && entry.name === name);
 		return fail("#CYCLE!", `The attributes form a cycle: ${[...from < 0 ? [nameOfAttribute(node, name)] : inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name)), nameOfAttribute(node, name)].join(" -> ")}.`);
 	}
-	const part = node.parts.find((item) => item.key === name);
-	if (part === void 0) return void 0;
 	node.pending.add(name);
 	inEvaluation.push({
 		node,
 		name
 	});
 	try {
-		const result = part.evaluate({
-			...node.ctx,
-			self
-		});
-		node.values.set(name, result);
-		return result;
+		for (const [, rung] of REF_RUNGS) {
+			const result = rung(node, name);
+			if (result === void 0) continue;
+			node.values.set(name, result);
+			return result;
+		}
+		return;
 	} finally {
 		node.pending.delete(name);
 		inEvaluation.pop();
@@ -8188,7 +8786,7 @@ function attributeOf(node, self, name) {
 function jsonOfNode(node, self, open) {
 	const record = {};
 	for (const part of node.parts) {
-		const result = attributeOf(node, self, part.key);
+		const result = attributeOf(node, part.key);
 		if (!result.ok) return result;
 		const value = plainValue(result.value, [...open, self]);
 		if (!value.ok) return value;
@@ -8226,15 +8824,23 @@ function plainValue(value, open) {
 * TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
 * tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error.
 */
-const treeDefinition = ({ parts, context, kind, place }) => {
+const treeDefinition = ({ parts, context, kind, place, machine, typePath }) => {
 	const outer = refNodeOf(context.self);
 	const nested = outer !== void 0 && outer.tree.open;
+	const found = machine === void 0 || typePath.length === 0 ? void 0 : lookupKind(machine.world, typePath);
+	const contract = found?.ok === true ? found.kind.tree : void 0;
+	const of = contract === void 0 || found?.ok !== true ? void 0 : equationType(found.kind);
 	const node = {
 		tree: nested ? outer.tree : { open: true },
 		kind,
 		place,
 		parts,
 		ctx: context,
+		contract,
+		of,
+		up: nested ? outer : void 0,
+		env: activeEnvs[activeEnvs.length - 1],
+		thing: null,
 		values: /* @__PURE__ */ new Map(),
 		pending: /* @__PURE__ */ new Set()
 	};
@@ -8245,17 +8851,18 @@ const treeDefinition = ({ parts, context, kind, place }) => {
 		deref: (key) => {
 			if (key === "parent") return context.self;
 			if (key === "type") return kind;
-			const result = attributeOf(node, self, String(key));
+			const result = attributeOf(node, String(key));
 			if (result === void 0 || result.ok) return result?.ok === true ? result.value : void 0;
 			throw new Failure(result.error);
 		},
-		has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)),
+		has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)) || node.values.has(String(key)),
 		toJson: () => {
 			const result = jsonOfNode(node, self, []);
 			if (result.ok) return result.value;
 			throw new Failure(result.error);
 		}
 	};
+	node.thing = self;
 	refNodes.set(self, node);
 	if (nested) return ok(self);
 	try {
@@ -8487,6 +9094,13 @@ function valuesOfStrict(parts) {
 }
 //#endregion
 //#region src/agree.ts
+/** The tiers that `agree` compares when its options name none. */
+const DEFAULT_TIERS = /* @__PURE__ */ Object.freeze([
+	"reference",
+	"traced",
+	"again",
+	"folds"
+]);
 /**
 * This function tells if two values are the same for `agree`. Lists and plain records compare item by item and field
 * by field, and the order of the fields does not matter. Each other leaf compares with `Object.is`, thus `-0` is not
@@ -8576,7 +9190,11 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 	};
 	const observe = options.observe;
 	observe?.();
-	const plan = prepare(machine, doc, declared);
+	const folds = observe === void 0;
+	const plan = prepare(machine, doc, {
+		...declared,
+		fold: folds
+	});
 	const effects = [];
 	const result = plan.evaluate(context, {
 		effects,
@@ -8589,11 +9207,7 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 		if (why !== void 0 || observe === void 0) return why;
 		return sameValue(saw, observe(), options.equal) ? void 0 : "The host saw other calls in the tier.";
 	};
-	for (const tier of options.tiers ?? [
-		"reference",
-		"traced",
-		"again"
-	]) {
+	for (const tier of options.tiers ?? DEFAULT_TIERS) {
 		let other;
 		let otherEffects = [];
 		if (tier === "reference") other = reference(machine, doc, context, {
@@ -8609,6 +9223,27 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 			});
 			other = traced.result;
 			otherEffects = [...traced.effects];
+		} else if (tier === "folds") {
+			other = prepare(machine, doc, {
+				...declared,
+				fold: !folds
+			}).evaluate(context, {
+				effects: otherEffects,
+				...mock
+			});
+			if (observe !== void 0) {
+				observe();
+				if (overflowed(result) || overflowed(other)) continue;
+				const why = resultDiffers(result, other, options) ?? effectsDiffer(effects, otherEffects, options);
+				if (why !== void 0) return {
+					ok: false,
+					tier,
+					plan: result,
+					other,
+					reason: why
+				};
+				continue;
+			}
 		} else other = plan.evaluate(context, {
 			effects: otherEffects,
 			...mock
@@ -11255,6 +11890,6 @@ function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
 //#endregion
-export { CAPS_TYPE, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_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, 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