@mark1russell7/coeval 0.18.0 → 0.19.0

package/build/index.js

@@ -415,6 +415,52 @@ function isAlias(entry) {
 function isNamespace(entry) {
 	return entry !== void 0 && !isKind(entry) && !isAlias(entry) && Object.hasOwn(entry, "kinds");
 }
+/**
+* This function visits each kind of a world. These are the kinds of each namespace, at each depth, and the fallback
+* kind of each namespace and of the world. It does not follow an alias, because the kind of an alias has its own place. A
+* fallback kind has the keys of its namespace. It comes after the entries of that namespace. `checkWorld` reads the
+* kinds with this one function.
+*
+* @param world - The world.
+* @param visit - The function that gets each kind, its keys from the root of the world, and `true` for a fallback kind.
+*/
+function eachKind(world, visit) {
+	const way = /* @__PURE__ */ new Set();
+	const entries = (kinds, path) => {
+		for (const key of Object.keys(kinds)) {
+			const entry = kinds[key];
+			const here = [...path, key];
+			if (isKind(entry)) visit(entry, here, false);
+			else if (isNamespace(entry) && !way.has(entry)) {
+				way.add(entry);
+				entries(entry.kinds, here);
+				if (entry.fallback !== void 0) visit(entry.fallback, here, true);
+				way.delete(entry);
+			}
+		}
+	};
+	entries(world.kinds, []);
+	if (world.fallback !== void 0) visit(world.fallback, [], true);
+}
+/**
+* This function gives the kind at a path of a world, without an alias and without a fallback kind. A namespace on the
+* way gives its entries.
+*
+* @param world - The world.
+* @param path - The keys from the root of the world.
+* @returns The kind, or `undefined` when no kind is at the path.
+*/
+function kindAt(world, path) {
+	let entries = world.kinds;
+	let entry;
+	for (let index = 0; index < path.length; index += 1) {
+		entry = entryAt(entries, path[index]);
+		if (index === path.length - 1) break;
+		if (!isNamespace(entry)) return void 0;
+		entries = entry.kinds;
+	}
+	return isKind(entry) ? entry : void 0;
+}
 function entryAt(entries, key) {
 	const name = String(key);
 	return Object.hasOwn(entries, name) ? entries[name] : void 0;
@@ -679,7 +725,11 @@ function formOf(type, domains) {
 		closed
 	};
 }
-/** This function gives each base type that holds the members of a base type: the type itself and each parent, through each level. */
+/**
+* This function gives each base type that holds the members of a base type: the type itself and each parent, through
+* each level. A cycle of parents ends at a name that the line has, and a parent that is not a domain ends its branch.
+* The function is internal: `encodeValue` uses it too (D109).
+*/
 function lineOf(name, domains) {
 	const seen = /* @__PURE__ */ new Set([name]);
 	const queue = [name];
@@ -3580,7 +3630,7 @@ function selfLabel(self) {
 		return describe(self).slice(0, 40);
 	}
 }
-const NO_ANSWER = {
+const NO_ANSWER$1 = {
 	verb: "eval",
 	error: "no-answer",
 	steps: []
@@ -4065,7 +4115,7 @@ function holderNode() {
 			value: null
 		},
 		declared: false,
-		answer: NO_ANSWER,
+		answer: NO_ANSWER$1,
 		side: "derive",
 		names: [],
 		scope: {},
@@ -4219,7 +4269,7 @@ const NO_META = /* @__PURE__ */ Object.freeze({
 		value: null
 	},
 	declared: false,
-	answer: NO_ANSWER,
+	answer: NO_ANSWER$1,
 	side: "derive"
 });
 function compileNode(c, value, place, declared, depth, address = false) {
@@ -4879,7 +4929,7 @@ function rootContext(machine, ctx) {
 */
 function prepare(machine, doc, options = {}) {
 	const verb = options.verb ?? "eval";
-	const noAnswer = verb === "eval" ? NO_ANSWER : {
+	const noAnswer = verb === "eval" ? NO_ANSWER$1 : {
 		verb,
 		error: "no-answer",
 		steps: []
@@ -5500,10 +5550,10 @@ const STD_EVALUATORS = {
 		const found = resolve(data);
 		return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
 	},
-	"tree.node": (input) => treeNode(input)
+	"tree.node": (input) => treeNode(input, void 0)
 };
 /** 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");
+const TREE_NODE$1 = /* @__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",
@@ -5512,6 +5562,17 @@ const ATTRIBUTE_RUNGS = /* @__PURE__ */ Object.freeze([
 	"copy",
 	"default"
 ]);
+/**
+* This function gives the code of the kind of a node of the decorated tree, with the options of the host. A host puts
+* the code at the name `tree.node` of its machine. Without a cell, the code is the standard code.
+*
+* @param options - The options, for example the memo cells of the host.
+* @returns The code.
+*/
+function treeNodeEvaluator(options = {}) {
+	const host = options.cell;
+	return host === void 0 ? STD_EVALUATORS["tree.node"] : (input) => treeNode(input, host);
+}
 /** 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`. */
@@ -5555,6 +5616,29 @@ function contractOf$1(machine, typePath) {
 	};
 }
 const BUSY = /* @__PURE__ */ Object.freeze({ busy: true });
+/** The answer of the ladder when no rung answers. */
+const NO_ANSWER = /* @__PURE__ */ Object.freeze({
+	result: void 0,
+	by: void 0
+});
+/**
+* The marks of the attributes in evaluation, for each place of a plan, with the cells of a host (TREE.CELL). Nodes of
+* two evaluations share their place and their kept cells, thus they share their marks.
+*/
+const marksByPlace = /* @__PURE__ */ new WeakMap();
+/** The trees of the cells of a host, for each place of a root in a plan. Nodes of two evaluations stay in one tree. */
+const buildsByPlace = /* @__PURE__ */ new WeakMap();
+/** This function gives the value of a weak map, or puts a new value in it. */
+function keptAt(map, place, make) {
+	let value = map.get(place);
+	if (value === void 0) {
+		value = make();
+		map.set(place, value);
+	}
+	return value;
+}
+/** A value that no exception has. */
+const NOT_THROWN = /* @__PURE__ */ Symbol("coeval.tree.not-thrown");
 /** The attributes in evaluation, in the order of their demands. An evaluation does not wait, thus one list serves. */
 const demands = [];
 function attributeText(key, type, place) {
@@ -5568,7 +5652,7 @@ function cycleAt(cells, key, text) {
 	return fail("#CYCLE!", `The attributes form a cycle: ${chain.join(" -> ")}.`);
 }
 function stateOf(thing) {
-	return typeof thing === "object" && thing !== null ? thing[TREE_NODE] : void 0;
+	return typeof thing === "object" && thing !== null ? thing[TREE_NODE$1] : void 0;
 }
 /** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
 function putField(target, key, value) {
@@ -5625,14 +5709,17 @@ function plainOf(value, path) {
 * the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
 * fold or a default, come last. A failed attribute throws `Failure` with its own error, thus a reference to it gives that error.
 * The argument `outer` is the self of the context, that `treeNode` resolved. The node reads no root of the context directly (C4).
+*
+* The argument `host` gives the memo cells of the host (TREE.CELL), or `undefined` for the plain memo of the node.
 */
-function treeThing(input, build, outer) {
+function treeThing(input, build, outer, host) {
 	const { parts, context, kind: type, place, machine } = input;
 	const runtime = input[RUNTIME];
 	const { tree, of } = contractOf$1(machine, input.typePath);
 	const above = stateOf(outer);
 	const up = above !== void 0 && above.build === build ? above : void 0;
 	const cells = /* @__PURE__ */ new Map();
+	const marks = host === void 0 ? cells : keptAt(marksByPlace, place, () => /* @__PURE__ */ new Map());
 	/** The positions of the items of the list `children`, for the names of the children. */
 	let positions;
 	const fold = (key, declared) => {
@@ -5696,7 +5783,50 @@ function treeThing(input, build, outer) {
 			by: "default"
 		};
 	};
+	/**
+	* This function gives an attribute through the cell of the host (TREE.CELL). The cell is the memo. The node keeps
+	* the last answer only for `has` and `trace`.
+	*/
+	const through = host === void 0 ? void 0 : (key) => {
+		const text = attributeText(key, type, place);
+		if (marks.has(key)) return cycleAt(marks, key, text);
+		if (tree === void 0 && up?.tree === void 0 && !parts.some((item) => item.key === key)) return void 0;
+		marks.set(key, BUSY);
+		demands.push({
+			cells: marks,
+			key,
+			text
+		});
+		let thrown = NOT_THROWN;
+		let answer;
+		try {
+			answer = host(place, key, () => {
+				try {
+					return climb(key) ?? NO_ANSWER;
+				} catch (error) {
+					thrown = error;
+					throw error;
+				}
+			});
+		} catch (error) {
+			if (error === thrown) throw error;
+			answer = {
+				result: fail("#CYCLE!", `The cells of the host found a cycle in the demands: ${demands.map((demand) => demand.text).join(" -> ")}.`, { cause: error }),
+				by: void 0
+			};
+		} finally {
+			demands.pop();
+			marks.delete(key);
+		}
+		cells.set(key, {
+			busy: false,
+			result: answer.result,
+			by: answer.by
+		});
+		return answer.result;
+	};
 	const read = (key) => {
+		if (through !== void 0) return through(key);
 		const cell = cells.get(key);
 		if (cell !== void 0) return cell.busy ? cycleAt(cells, key, attributeText(key, type, place)) : cell.result;
 		if (tree === void 0 && up?.tree === void 0 && !parts.some((item) => item.key === key)) return void 0;
@@ -5790,7 +5920,7 @@ function treeThing(input, build, outer) {
 	};
 	const node = {
 		[THING]: true,
-		[TREE_NODE]: state,
+		[TREE_NODE$1]: state,
 		type,
 		label: `node ${type}`,
 		deref(key) {
@@ -5844,14 +5974,16 @@ const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
 * This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
 * thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree. The
 * node reads `self` through `resolve` (C4, D44). A machine that closes the root `self` thus gives no nested trees.
+* The argument `host` gives the memo cells of the host (TREE.CELL), or `undefined` for the plain memo of each node.
 */
-function treeNode(input) {
+function treeNode(input, host) {
 	const found = input.resolve(SELF_PATH, NO_HOPS);
 	const outer = found.ok ? found.thing : void 0;
 	const above = stateOf(outer);
-	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build, outer));
-	const build = { open: true };
-	const root = treeThing(input, build, outer);
+	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build, outer, host));
+	const build = host === void 0 ? { open: true } : keptAt(buildsByPlace, input.place, () => ({ open: true }));
+	build.open = true;
+	const root = treeThing(input, build, outer, host);
 	try {
 		return stateOf(root).json(/* @__PURE__ */ new Set());
 	} finally {
@@ -6593,501 +6725,1968 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 		places
 	};
 }
-// src/static.ts
-/** The names of a walk without names. A walk does not change a set at any time: it makes a new set to add names. */
-const NO_NAMES = /* @__PURE__ */ new Set();
-/** This function gives the options of a walk without the names of the host. */
-function withoutNames(options) {
-	const { names: _host, ...rest } = options;
-	return rest;
-}
-/** This function gives the keys of a trail, from its start. It keeps the result in the trail. */
-function keysOf(trail) {
-	if (trail === void 0) return [];
-	if (trail.full !== void 0) return trail.full;
-	const steps = [];
-	let here = trail;
-	while (here !== void 0 && here.full === void 0) {
-		steps.push(here);
-		here = here.up;
-	}
-	const keys = here?.full === void 0 ? [] : [...here.full];
-	for (let index = steps.length - 1; index >= 0; index -= 1) for (const key of steps[index].keys) keys.push(key);
-	trail.full = keys;
-	return keys;
-}
-/** A visit with its paths as trails. It makes the keys of a path only when a reader asks for them. */
-var Visit = class {
-	doc;
-	declared;
-	depth;
-	names;
-	later;
-	slot;
-	parent;
-	kind;
-	typePath;
-	address;
-	caps;
-	#place;
-	#at;
-	#bound;
-	#expect;
-	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps, bound, expect) {
-		this.doc = doc;
-		this.declared = declared;
-		this.depth = depth;
-		this.names = names;
-		this.later = later;
-		this.slot = slot;
-		this.parent = parent;
-		this.kind = kind;
-		this.typePath = typePath;
-		this.address = address;
-		this.caps = caps;
-		this.#place = place;
-		this.#at = at;
-		this.#bound = bound;
-		this.#expect = expect;
-	}
-	/** The names that the scope rules of the parent bind for this document. The check of types reads them. */
-	get bound() {
-		return this.#bound;
-	}
-	/** The type that the shape of the parent declares for this part. The check of types reads it. */
-	get expect() {
-		return this.#expect;
-	}
-	get place() {
-		return keysOf(this.#place);
-	}
-	get at() {
-		return keysOf(this.#at);
-	}
-};
 /**
-* This function visits each document of a document: the root and each part at each depth, by the contracts of the
-* kinds. A part of a kind that the world does not have is not visited. With capabilities in the options, the walk
-* narrows them for each part by the rules of its kind, as a run does. The walk uses no stack of the host for the
-* depth, thus a deep document cannot overflow it. The time and the memory of a walk are linear in the size of the
-* document. A visit makes the keys of its place and of its path only when a reader asks for them.
+* This function examines each value type of a machine before a document exists (TYPE.WORLD, D110). It reads the
+* `result` and each `expect` of each kind, the parents and the steps of each domain, and the declarations of each type
+* rule. Each problem of `typeIssues` gives one issue with the keys of the bad term.
 *
-* @param world - The world of the kinds.
-* @param doc - The document, as JSON.
-* @param visit - The function that gets each document. It gives `"skip"` to not visit the parts of a document.
-* @param options - The type of a bare root value, the names, the capabilities and a function for the problems.
+* A term shape with `kinds` and `expect` also gets an issue for each kind of its list whose `result` does not fit
+* `expect`. A check of types gives `#TYPE!` at each document of that kind there.
+*
+* @param machine - The machine.
+* @returns The issues: the kinds in the order of the world, then the domains, then the type rules.
 */
-function walk(world, doc, visit, options = {}) {
-	const stack = [{
-		value: doc,
-		place: void 0,
-		at: void 0,
-		declared: options.declaredType,
-		depth: 0,
-		names: options.names === void 0 || options.names.length === 0 ? NO_NAMES : new Set(options.names),
-		later: NO_NAMES,
-		address: false,
-		slot: [],
-		parent: void 0,
-		caps: options.caps,
-		bound: [],
-		expect: void 0
-	}];
-	while (stack.length > 0) {
-		const item = stack.pop();
-		const read = partsOf(world, item.value, item.declared);
-		if (!read.ok) {
-			options.problem?.({
-				place: keysOf(item.place),
-				at: keysOf(item.at),
-				code: read.code,
-				reason: read.reason
-			});
+function machineTypeIssues(machine) {
+	const domains = machine.domains;
+	const world = machine.world;
+	const out = [];
+	const add = (owner, at, reason) => {
+		out.push({
+			code: "#TYPE!",
+			...owner,
+			verb: "eval",
+			at,
+			reason
+		});
+	};
+	/** This function examines one value type. It gives `true` when the type has no problem. */
+	const examine = (owner, at, type, what) => {
+		const problems = typeIssues(type, domains);
+		for (const problem of problems) add(owner, [...at, ...problem.at], `The ${what} is not a correct value type. ${problem.reason}`);
+		return problems.length === 0;
+	};
+	/**
+	* This function finds each kind of the list `kinds` of a term whose result does not fit the `expect` of the term.
+	* Only a kind at the path itself counts. A path through an alias or to a fallback kind gives no issue.
+	*/
+	const results = (owner, kinds, at, expect) => {
+		if (isUnknown(expect, domains)) return;
+		kinds.forEach((path, index) => {
+			const result = (Array.isArray(path) ? kindAt(world, path) : void 0)?.result;
+			if (result === void 0 || typeIssues(result, domains).length > 0 || fits(result, expect, domains)) return;
+			const text = path.join(".");
+			add(owner, [
+				...at,
+				"kinds",
+				index
+			], `The kind ${text} has the result ${typeText(result)}, and the part needs the type ${typeText(expect)}. Each document of ${text} here gets #TYPE!.`);
+		});
+	};
+	eachKind(world, (kind, path, fallback) => {
+		const owner = fallback ? {
+			kind: path,
+			fallback: true
+		} : { kind: path };
+		const name = fallback ? path.length === 0 ? "fallback kind of the world" : `fallback kind of ${path.join(".")}` : `kind ${path.join(".")}`;
+		if (kind.result !== void 0) examine(owner, ["result"], kind.result, `result of the ${name}`);
+		const way = /* @__PURE__ */ new Set();
+		const shape = (spec, at) => {
+			if (typeof spec !== "object" || spec === null || way.has(spec)) return;
+			way.add(spec);
+			const expect = spec.expect;
+			const where = [...at, "expect"];
+			if (expect !== void 0 && examine(owner, where, expect, `expected type at ${where.join(".")} of the ${name}`) && spec.shape === "term" && Array.isArray(spec.kinds)) results(owner, spec.kinds, at, expect);
+			if (spec.shape === "list" || spec.shape === "map") shape(spec.item, [...at, "item"]);
+			if (spec.shape === "record") {
+				const fields = spec.fields;
+				if (typeof fields === "object" && fields !== null && !Array.isArray(fields)) for (const key of Object.keys(fields)) shape(fields[key], [
+					...at,
+					"fields",
+					key
+				]);
+				shape(spec.rest, [...at, "rest"]);
+			}
+			way.delete(spec);
+		};
+		shape(kind.parts, ["parts"]);
+	});
+	const table = domains ?? {};
+	for (const name of Object.keys(table)) {
+		if (name === "unknown" || name === "never") continue;
+		const owner = {
+			kind: [],
+			domain: name
+		};
+		const domain = domainOf(name, domains);
+		if (domain === void 0) {
+			add(owner, ["is"], `The domain ${name} has no test is. Each use of the name ${name} reads as unknown.`);
 			continue;
 		}
-		const { doc, kind, split } = read;
-		const here = new Visit(item.place, item.at, doc, read.declared, item.depth, item.names, item.later, item.slot, item.parent, kind, read.typePath, item.address ? true : void 0, item.caps, item.bound, item.expect);
-		if (visit(here) === "skip" || kind === void 0) continue;
-		const base = read.declared ? item.at : {
-			up: item.at,
-			keys: ["value"]
+		const under = domain.under;
+		if (Array.isArray(under)) under.forEach((parent, index) => {
+			if (parent === "unknown" || parent === "never") return;
+			if (typeof parent !== "string" || domainOf(parent, domains) === void 0) add(owner, ["under", index], `The parent ${String(parent)} of the domain ${name} is not a domain of the machine.`);
+		});
+		const steps = domain.steps;
+		if (typeof steps === "object" && steps !== null) for (const key of Object.keys(steps)) examine(owner, ["steps", key], steps[key], `type of the step ${key} of the domain ${name}`);
+	}
+	for (const name of Object.keys(machine.evaluators)) {
+		const declared = ruleOf(machine, name)?.declared;
+		if (typeof declared !== "function") continue;
+		const owner = {
+			kind: [],
+			evaluator: name
 		};
-		if (!split.ok) {
-			options.problem?.({
-				place: keysOf(item.place),
-				at: keysOf({
-					up: base,
-					keys: split.at
-				}),
-				code: "#VALUE!",
-				reason: split.reason
-			});
+		let list;
+		try {
+			list = declared();
+		} catch (error) {
+			add(owner, [], `The type rule of ${name} fails: ${message(error)}`);
 			continue;
 		}
-		const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
-		for (let index = split.parts.length - 1; index >= 0; index -= 1) {
-			const slot = split.parts[index];
-			const extra = sees[index] ?? [];
-			const hidden = later[index] ?? [];
-			stack.push({
-				value: slot.item,
-				place: slot.path.length === 0 ? item.place : {
-					up: item.place,
-					keys: slot.path
-				},
-				at: slot.path.length === 0 ? base : {
-					up: base,
-					keys: slot.path
-				},
-				declared: slot.of,
-				depth: item.depth + 1,
-				names: extra.length === 0 ? item.names : /* @__PURE__ */ new Set([...item.names, ...extra]),
-				later: hidden.length === 0 ? item.later : /* @__PURE__ */ new Set([...item.later, ...hidden]),
-				address: slot.address === true,
-				slot: slot.path,
-				parent: here,
-				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : partCaps(kind.caps, slot.path, item.caps),
-				bound: extra,
-				expect: slot.expect
-			});
-		}
+		for (const item of list) if ("problem" in item) add(owner, item.at, item.problem);
+		else examine(owner, item.at, item.type, item.what);
 	}
+	return out;
 }
+// src/facts.ts
+/** The lazy rules that cover each part: the rules of a document whose evaluator the contract does not describe. */
+const EACH$2 = "each";
+/** An empty list. One frozen list serves each empty list of the facts, thus a store of many facts keeps less (PLAN.LEAN). */
+const NONE = /* @__PURE__ */ Object.freeze([]);
 /**
-* This function finds each reference of a document: each document of the type `ref` that a walk reaches. A
-* reference to a name that a kind around it binds is not free. The others are what the document reads from
-* outside: its dependencies. When the kind `ref` has parts, the walk also finds the references in its step documents.
-*
-* @param world - The world of the kinds.
-* @param doc - The document, as JSON.
-* @param options - The type of a bare root value. The names of the host do not change the result.
-* @returns The references, in the order of the document.
-*/
-function refsOf(world, doc, options = {}) {
-	const out = [];
-	walk(world, doc, (v) => {
-		if (!isRef(v.doc)) return void 0;
-		const path = v.doc.value;
-		const root = typeof path[0] === "string" ? path[0] : "";
-		const first = path[1];
-		const use = {
-			path,
-			root,
-			free: !(root === "names" && isKey(first) && v.names.has(String(first))),
-			address: v.address === true
-		};
-		Object.defineProperty(use, "place", {
-			enumerable: true,
-			get: () => v.place
-		});
-		Object.defineProperty(use, "at", {
-			enumerable: true,
-			get: () => v.at
-		});
-		Object.defineProperty(use, "visit", {
-			enumerable: false,
-			value: v
-		});
-		out.push(use);
-	}, options.names === void 0 ? options : withoutNames(options));
-	return out;
-}
-function setAt(value, path, next) {
-	if (path.length === 0) return next;
-	const [key, ...rest] = path;
-	if (Array.isArray(value)) {
-		const copy = [...value];
-		copy[Number(key)] = setAt(value[Number(key)], rest, next);
-		return copy;
-	}
-	const record = isRecord(value) ? value : {};
-	const copy = {};
-	for (const name of Object.keys(record)) Object.defineProperty(copy, name, {
-		value: record[name],
-		enumerable: true,
-		writable: true,
-		configurable: true
-	});
-	Object.defineProperty(copy, String(key), {
-		value: setAt(record[String(key)], rest, next),
-		enumerable: true,
-		writable: true,
-		configurable: true
-	});
-	return copy;
-}
-/**
-* This function changes the free references of a document. The document is not changed: the function gives a new
-* document that shares each part without a change.
-*
-* @param world - The world of the kinds.
-* @param doc - The document, as JSON.
-* @param change - The function that gives the new document of a reference, or `undefined` to keep it.
-* @param options - The type of a bare root value, and the names that the host binds at the root.
-* @returns The new document.
-*/
-function mapRefs(world, doc, change, options = {}) {
-	let out = doc;
-	for (const use of refsOf(world, doc, options)) {
-		if (!use.free) continue;
-		const next = change(use);
-		if (next !== void 0) out = setAt(out, use.at, next);
-	}
-	return out;
-}
-/** The least authority: the capability `[]` permits each effect (CAP.KEYS). */
-const EACH$2 = /* @__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).
-*
-* @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.
+* This function gives a list of the facts with no free room. A list that grows by `push` keeps room for more items,
+* thus a copy of a short list is smaller.
 */
-function declaredEffects(v, verb = "eval") {
-	return verbDeclared(v, verb) ?? NO_EFFECTS;
+function tight(list) {
+	return list.length === 0 ? NONE : list.slice();
 }
 /**
-* This function gives the effects that the contract of the kind of a visit declares for a verb, as keys. The result
-* is `undefined` when the contract has no declaration for the verb (D49). A visit without a kind declares no effect
-* for `eval` and no declaration for another verb.
+* This function gives the name of the evaluator that the ladder finds for a verb (VERB.LADDER). It also tells if
+* the contract of the kind describes that code. The contract describes the code of its kind for its verb `contract`.
+* An own entry for another evaluator has code that the contract does not describe.
 */
-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("."));
+function codeOf(world, own, kind, verb, contract) {
+	const found = answerOf(world, own, kind, verb);
+	if (verb !== contract) return {
+		name: found?.name,
+		described: false
+	};
+	if (found?.rung !== "own") return {
+		name: found?.name,
+		described: true
+	};
+	return {
+		name: found.name,
+		described: found.name === answerOf(world, void 0, kind, verb)?.name
+	};
 }
-/**
-* This function gives the rule of a machine for an effect, for the static kit (CAP.PERMITS). The rule is the hook
-* `permits` of the machine, as in a run, or else the function `permits`. A check has no values, thus the hook gets a
-* context with the capabilities of the document and the world of the machine. Its names, its self and its event are
-* empty.
-*
-* @param machine - The machine.
-* @returns The rule. It gets the capabilities of a document and the keys of an effect.
-*/
-function permitsOf(machine) {
-	const hook = machine.permits;
-	if (hook === void 0) return permits;
-	let base;
-	return (caps, kind) => hook(caps, kind, {
-		...base ??= context({ world: worldThing(machine.world) }),
-		caps
-	});
+/** This function gives the position of a part among the parts that a rule covers, by the split of its document. */
+function positionOf(above, parent, rule, slot) {
+	const positions = above.positions ??= /* @__PURE__ */ new Map();
+	let table = positions.get(rule);
+	if (table === void 0) {
+		table = /* @__PURE__ */ new Map();
+		const split = splitParts(parent.kind?.parts, parent.doc.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;
+			table.set(JSON.stringify(part.path), count);
+			count += 1;
+		}
+		positions.set(rule, table);
+	}
+	return table.get(JSON.stringify(slot)) ?? 0;
 }
-/**
-* This function gives the reason of a `#CAP!`. When a kind around the document narrowed the capabilities, the
-* reason names the nearest such kind.
-*/
-function capReason(v, kind, allowed) {
-	const text = kind.join(".");
-	for (let up = v.parent; up !== void 0; up = up.parent) if (up.caps !== void 0 && allowed(up.caps, kind)) return `The capabilities do not permit the effect ${text} here. The kind ${typeName(up.doc.type)} around it narrows them for its parts.`;
-	return `The capabilities do not permit the effect ${text}.`;
+/** This function tells if the lazy rules of a document cover one of its parts. */
+function partLazy(above, parent, slot) {
+	const rules = above.rules;
+	if (rules === void 0) return false;
+	if (rules === EACH$2) return true;
+	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 || positionOf(above, parent, rule, slot) >= after) return true;
+	}
+	return false;
 }
 /**
-* This function checks a document before an evaluation, by the contracts of its kinds. It finds the problems
-* that an evaluation finds when it reaches them:
-*
-* - `#KIND?`: a kind that the world does not have.
-* - `#NOEVAL`: no evaluator.
-* - `#VALUE!`: a value without the shape of its kind.
-* - `#PART?`: a value without a type.
-* - `#DEPTH!`: too much nesting.
-* - `#REF!` and `#STEP?`: a bad path.
-* - `#NAME?`: a name that nothing binds. With the hook `known` of the machine, also a name that the language does not
-*   have, for example an operation.
-* - `#CAP!`: an effect that the capabilities of its document do not permit. A kind around the document can narrow them.
-*   The hook `permits` of the machine decides, as in a run (CAP.PERMITS).
-* - `#CALC!`: with the option `run`, a runner under a parent without a runner, when an effect of its runners can reach
-*   the host. Also a kind that declares effects and has no runner (RUN.CAN-WAIT). The issue has the place and the
-*   reason of the run.
-* - `#TYPE!`: with the option `types`, a part whose type does not fit the type that its position needs (TYPE.CHECK).
-*   A run does not always fail there, thus a type issue is a static finding, not an error of a run.
+* This function gives the code of a document of a kind for the facts (FACTS.LAZY). `factsOf` and the graph of
+* attribute instances read the lazy rules with this one function (D107).
 *
-* The check asks the ladder for the verb of the options, `eval` by default (VERB.CHECK). The shapes, the paths and the
-* names follow the contracts, thus they are the same for each verb. The check tests the effects that each contract
-* declares for the verb: `effects` for `eval`, and the entry of `verbEffects` for another verb (VERB.EFFECTS). A kind
-* without a declaration for the verb gives no `#CAP!` and no `#CALC!` for an effect.
-*
-* @param machine - The world and the code of the evaluators.
-* @param doc - The document, as JSON.
-* @param options - The type of a bare root value, the names of the host, the capabilities, the verb, the types and the run.
-* @returns The problems, in the order of the document. The type issues come after the other issues.
-*/
-function check(machine, doc, options = {}) {
-	return options.types === true ? typeCheck(machine, doc, options).issues : checkAll(machine, doc, options, void 0);
+* @param machine - The world and the hook `facts`.
+* @param v - The visit of the document.
+* @param kind - The kind of the document.
+* @param verb - The verb whose code the facts describe.
+* @returns The answer of the hook and the lazy rules.
+*/
+function codeFactsOf(machine, v, kind, verb) {
+	const code = codeOf(machine.world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
+	const answer = code.name === void 0 ? void 0 : machine.facts?.(v.typePath ?? [], code.name);
+	return {
+		described: code.described,
+		answer,
+		rules: code.described ? answer?.lazy ?? kind.lazy : answer?.lazy ?? EACH$2
+	};
 }
 /**
-* This function checks a document, and it also checks the value types (TYPE.CHECK, D25). It finds each issue of
-* `check`. Then it synthesizes the type of each document from the types of its parts. It also checks each part
-* against the type that its position needs. The type rule of the parent, the signature of an operation or the shape
-* of the contract gives that type. A part with an issue gets the type `unknown`, thus one
-* problem does not give a chain of issues.
+* This function gives the static facts of a document, for a schedule (R4 P2, D24). It walks the document one time,
+* by the contracts of its kinds:
 *
-* A type issue has the code `#TYPE!`, the type that the position needs (`expected`) and the type that the check found
-* (`found`). It is a static finding: the evaluation of the document does not change.
+* - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
+*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
+*   declares `reads` adds a read of each of its roots at each document of the kind. The first document of a tree
+*   kind also gets the lazy reads of the equations of its kind (FACTS.EQUATIONS). A read from `self` or from a name
+*   of a rung is not one of them, because it is not free (READS.EQUATION).
+* - `side` and `effects`: from the contract of each kind, for the verb of the facts.
+* - `pure`: each kind declares `pure`, also in an equation, and the document has no effect and is not volatile.
+* - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
 *
-* The option `rootTypes` gives the types of the roots and of the names of the host (TYPE.ROOTS). A reference then gets
-* the type that its path reaches, and a field that a closed record does not have is a type issue (TYPE.CLOSED).
+* The hook `facts` of the machine answers for a name that a fallback kind covers, for example an operation. Its
+* answer wins over the contract of the kind. The contract of a kind does not describe the evaluator of an own
+* entry. Thus a document with an own entry for another evaluator is not pure, and each of its parts is lazy. The
+* hook can still answer for that evaluator.
 *
-* @param machine - The world and the code of the evaluators, with their type rules.
-* @param doc - The document, as JSON.
-* @param options - The options of `check`, the type that the root must have and the types of the roots.
-* @returns The type of the root, each issue, and the type of each document.
-*/
-function typeCheck(machine, doc, options = {}) {
-	const nodes = [];
-	const issues = checkAll(machine, doc, options, nodes);
-	const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
-	return {
-		type: pass.type,
-		issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues],
-		places: pass.places
-	};
-}
-/** This function tells if a table of verbs has an entry for a verb. */
-function hasVerb(table, verb) {
-	return table !== void 0 && Object.hasOwn(table, verb);
-}
-/**
-* This function checks the world of a machine before a document exists. It finds each kind that has no entry for a
-* verb of the list, when the world has no default for that verb (STATIC.COVERAGE). A document of such a kind gets no
-* evaluator for the verb, thus the check gives the same proof of coverage as a type system.
+* The option `verb` names the verb whose code the facts describe (FACTS.VERB). The marks of a contract describe the
+* code of `eval`, thus the rule of an own entry applies to each document for another verb. For another verb, the
+* effects are the effects that the entry of the verb in `verbEffects` declares (FACTS.VERB-EFFECTS, D111). A kind is
+* on the run side for that verb when its entry declares an effect (FACTS.VERB-SIDE). A kind without an entry for the
+* verb adds no effect, as in `check` (FACTS.VERB-UNDECLARED). Its code is still not pure without an answer of the hook.
 *
-* The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
-* world. It does not follow an alias, because the kind of an alias has its own place. The check reads only the world.
+* A read is one resolution of its path. A reference that the resolution reaches and follows is a part of that read
+* (DEREF.COLLAPSE), not a separate read. The facts depend only on the document and the machine. Thus a host computes
+* them again only after an edit of the document or of the machine.
 *
-* @param machine - The machine, for its world.
-* @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
-* @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
-*   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
+* @param machine - The world, the code and the hook `facts`.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value, the verb and the volatile reads of the host.
+* @returns The facts.
 */
-function checkWorld(machine, verbs) {
+function factsOf(machine, doc, options = {}) {
 	const world = machine.world;
-	const open = verbs.filter((verb) => !hasVerb(world.defaults, verb));
-	const out = [];
-	if (open.length === 0) return out;
-	const visit = (kind, path, fallback) => {
-		const text = path.join(".");
-		const name = fallback ? path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}` : `the kind ${text}`;
-		for (const verb of open) {
-			if (hasVerb(kind.verbs, verb)) continue;
-			const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
-			out.push(fallback ? {
-				code: "#NOEVAL",
-				kind: path,
-				fallback: true,
-				verb,
-				reason
-			} : {
-				code: "#NOEVAL",
-				kind: path,
-				verb,
-				reason
-			});
-		}
+	const hook = machine.facts;
+	const reads = [];
+	const effects = [];
+	const above = /* @__PURE__ */ new Map();
+	let side = "derive";
+	let pure = true;
+	let volatile = false;
+	let size = 0;
+	let seen;
+	const note = (isPure, isVolatile) => {
+		if (isPure !== true) pure = false;
+		if (isVolatile === true) volatile = true;
 	};
-	const way = /* @__PURE__ */ new Set();
-	const entries = (kinds, path) => {
-		for (const key of Object.keys(kinds)) {
-			const entry = kinds[key];
-			const here = [...path, key];
-			if (isKind(entry)) visit(entry, here, false);
-			else if (isNamespace(entry) && !way.has(entry)) {
-				way.add(entry);
-				entries(entry.kinds, here);
-				if (entry.fallback !== void 0) visit(entry.fallback, here, true);
-				way.delete(entry);
+	const add = (read) => {
+		reads.push(read);
+		if (options.volatile?.(read) === true) volatile = true;
+	};
+	/**
+	* This function walks a document. Without `node`, it walks the document of the facts. With `node`, it walks an
+	* equation of a tree kind, and each read gets the place of that node: the first document of the kind.
+	*/
+	const scan = (term, walkOptions, verb, node) => {
+		walk(world, term, (v) => {
+			if (node === void 0) size += 1;
+			const up = v.parent === void 0 ? void 0 : above.get(v.parent);
+			const lazy = node !== void 0 || up !== void 0 && v.parent !== void 0 && (up.lazy || partLazy(up, v.parent, v.slot));
+			const place = node ?? v;
+			const kind = v.kind;
+			if (kind === void 0) {
+				pure = false;
+				above.set(v, {
+					lazy,
+					rules: void 0
+				});
+				return;
 			}
-		}
+			const { described, answer, rules } = codeFactsOf(machine, v, kind, verb);
+			above.set(v, {
+				lazy,
+				rules
+			});
+			let roots;
+			if (described) {
+				note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
+				roots = answer?.reads ?? kind.reads;
+			} else {
+				note(answer?.pure, answer?.volatile);
+				roots = answer?.reads;
+			}
+			for (const root of roots ?? NONE) {
+				if (node !== void 0 && root === "self") continue;
+				add({
+					root,
+					keys: NONE,
+					exact: true,
+					lazy,
+					address: false,
+					path: [root],
+					place: tight(place.place),
+					at: tight(place.at)
+				});
+			}
+			const declared = declaredEffects(v, verb);
+			if (verb === "eval" ? kind.side === "run" : declared.length > 0) {
+				if (node === void 0) side = "run";
+				else pure = false;
+			}
+			for (const keys of declared) {
+				if (node !== void 0) {
+					pure = false;
+					continue;
+				}
+				const text = keys.join(".");
+				if (!effects.includes(text)) effects.push(text);
+			}
+			if (kind.tree !== void 0 && !(seen ??= /* @__PURE__ */ new Set()).has(kind)) {
+				seen.add(kind);
+				const of = equationType(kind);
+				for (const { term: equation, names } of equationsOf(kind)) scan(equation, of === void 0 ? { names } : {
+					names,
+					declaredType: of
+				}, "eval", place);
+			}
+			if (!isRef(v.doc)) return void 0;
+			const path = v.doc.value;
+			const root = path[0];
+			if (typeof root !== "string" || !ROOTS.includes(root)) return void 0;
+			if (node !== void 0 && root === "self") return void 0;
+			let exact = true;
+			const keys = [];
+			for (let index = 1; index < path.length; index += 1) {
+				const step = path[index];
+				if (exact && isKey(step)) {
+					keys.push(step);
+					continue;
+				}
+				exact = false;
+				const found = isEnvelope(step) ? lookupKind(world, step.type) : void 0;
+				if (found?.ok !== true) {
+					pure = false;
+					continue;
+				}
+				const walker = codeOf(world, step.own, found.kind, "step", "step");
+				const stepAnswer = walker.name === void 0 ? void 0 : hook?.(found.path, walker.name);
+				if (walker.described) note(stepAnswer?.pure ?? found.kind.pure, stepAnswer?.volatile ?? found.kind.volatile);
+				else note(stepAnswer?.pure, stepAnswer?.volatile);
+			}
+			const first = path[1];
+			if (root === "names" && isKey(first) && v.names.has(String(first))) return void 0;
+			add({
+				root,
+				keys: tight(keys),
+				exact,
+				lazy,
+				address: v.address === true,
+				path,
+				place: tight(place.place),
+				at: tight(place.at)
+			});
+		}, walkOptions);
+	};
+	scan(doc, options.declaredType === void 0 ? {} : { declaredType: options.declaredType }, options.verb ?? "eval", void 0);
+	return {
+		reads: tight(reads),
+		side,
+		effects: tight(effects),
+		pure: pure && !volatile && effects.length === 0 && side === "derive",
+		volatile,
+		size
 	};
-	entries(world.kinds, []);
-	if (world.fallback !== void 0) visit(world.fallback, [], true);
-	return out;
 }
-/** The names that an equation of `down` sees (TREE.DOWN). */
-const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
-	"child",
-	"index",
-	"prev"
-]);
-/** The names that the term `combine` of a fold sees (TREE.FOLD). */
-const FOLD_NAMES = /* @__PURE__ */ Object.freeze(["acc", "item"]);
-/**
-* This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
-* `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
-*/
-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
+// src/graph.ts
+/** This function gives the indexed form of a graph, with the edges that the options keep. */
+function indexed(graph, options) {
+	const eager = options.eager === true;
+	const ids = [...graph.keys()];
+	const count = ids.length;
+	const numbers = /* @__PURE__ */ new Map();
+	const sink = new Uint8Array(count);
+	ids.forEach((id, index) => {
+		numbers.set(id, index);
+		if (graph.get(id)?.side === "run") sink[index] = 1;
 	});
-	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
-			});
+	const start = new Int32Array(count + 2);
+	const targets = [];
+	let unknown = false;
+	let from = 0;
+	for (const node of graph.values()) {
+		start[from] = targets.length;
+		for (const edge of node.edges) {
+			if (eager && edge.lazy) continue;
+			if (edge.to === void 0) {
+				if (eager) continue;
+				unknown = true;
+				targets.push(count);
+				continue;
+			}
+			const to = numbers.get(edge.to);
+			if (to !== void 0 && sink[to] === 0) targets.push(to);
 		}
-		if (declared.default !== void 0) out.push({
-			label: `tree.attributes.${name}.default`,
-			term: declared.default,
-			names: []
-		});
+		from += 1;
 	}
-	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}`
-		});
+	start[count] = targets.length;
+	if (unknown) {
+		for (let to = 0; to < count; to += 1) if (sink[to] === 0) targets.push(to);
 	}
-	return out;
+	start[count + 1] = targets.length;
+	return {
+		ids,
+		size: unknown ? count + 1 : count,
+		start,
+		targets: Int32Array.from(targets),
+		all: unknown ? count : -1
+	};
 }
 /**
-* 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 set `seen` holds the kinds whose equations the check
-* walked, thus it walks the equations of each kind one time.
+* This function finds the strongly connected components with the algorithm of Tarjan. It keeps its own stack of
+* calls in two arrays, thus a long chain does not overflow the stack of the host. Each component comes after each
+* component that its nodes reach: the deepest component comes first.
 */
-function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()) {
-	const issues = [];
-	const verb = options.verb ?? "eval";
+function strong(graph) {
+	const { size, start, targets } = graph;
+	const order = new Int32Array(size).fill(-1);
+	const low = new Int32Array(size);
+	const of = new Int32Array(size).fill(-1);
+	const open = new Int32Array(size);
+	const onOpen = new Uint8Array(size);
+	const calls = new Int32Array(size);
+	const next = new Int32Array(size);
+	const list = [];
+	let top = 0;
+	let count = 0;
+	const enter = (node, depth) => {
+		order[node] = count;
+		low[node] = count;
+		count += 1;
+		open[top] = node;
+		top += 1;
+		onOpen[node] = 1;
+		calls[depth] = node;
+		next[depth] = start[node];
+	};
+	for (let root = 0; root < size; root += 1) {
+		if (order[root] !== -1) continue;
+		enter(root, 0);
+		let depth = 1;
+		while (depth > 0) {
+			const node = calls[depth - 1];
+			const edge = next[depth - 1];
+			if (edge < start[node + 1]) {
+				next[depth - 1] = edge + 1;
+				const to = targets[edge];
+				if (order[to] === -1) {
+					enter(to, depth);
+					depth += 1;
+				} else if (onOpen[to] === 1 && order[to] < low[node]) low[node] = order[to];
+				continue;
+			}
+			depth -= 1;
+			if (low[node] === order[node]) {
+				const members = [];
+				let member;
+				do {
+					top -= 1;
+					member = open[top];
+					onOpen[member] = 0;
+					of[member] = list.length;
+					members.push(member);
+				} while (member !== node);
+				list.push(members.sort((a, b) => a - b));
+			}
+			if (depth > 0) {
+				const reader = calls[depth - 1];
+				if (low[node] < low[reader]) low[reader] = low[node];
+			}
+		}
+	}
+	return {
+		of,
+		list
+	};
+}
+/** This function tells if a component has a cycle: two or more nodes, or one node with an edge to itself. */
+function cyclic(graph, members) {
+	if (members.length > 1) return true;
+	const node = members[0];
+	for (let edge = graph.start[node]; edge < graph.start[node + 1]; edge += 1) if (graph.targets[edge] === node) return true;
+	return false;
+}
+/** This function gives the names of the nodes of a component, without the node `all`. */
+function named$1(graph, members) {
+	const out = [];
+	for (const member of members) if (member !== graph.all) out.push(graph.ids[member]);
+	return out;
+}
+/** This function gives the height of each component, in the order of `strong`. The node `all` adds no height. */
+function heightsOf(graph, found) {
+	const { start, targets } = graph;
+	const heights = new Int32Array(found.list.length);
+	found.list.forEach((members, component) => {
+		let highest = -1;
+		let real = false;
+		for (const node of members) {
+			if (node !== graph.all) real = true;
+			for (let edge = start[node]; edge < start[node + 1]; edge += 1) {
+				const other = found.of[targets[edge]];
+				if (other !== component && heights[other] > highest) highest = heights[other];
+			}
+		}
+		heights[component] = real ? highest + 1 : highest;
+	});
+	return heights;
+}
+/**
+* This function gives the strongly connected components of a graph of nodes (GRAPH.SCC), with the algorithm of
+* Tarjan. It keeps its own stack, thus a chain of 100000 nodes does not overflow the stack of the host.
+*
+* - Each component comes after each component that it reads: the deepest component comes first.
+* - A node that is on no cycle is a component of one node.
+* - The nodes of a component are in the order of the graph.
+*
+* @param graph - The nodes, each with its edges.
+* @param options - The option `eager` keeps only the eager edges with a target node.
+* @returns The components, deepest first.
+*/
+function components(graph, options = {}) {
+	const index = indexed(graph, options);
+	const out = [];
+	for (const members of strong(index).list) {
+		const names = named$1(index, members);
+		if (names.length > 0) out.push(names);
+	}
+	return out;
+}
+/**
+* This function gives the height of each node: the order of a push schedule (GRAPH.ORDER). A schedule that evaluates
+* the nodes from the lowest height up evaluates each node after each node that it reads, except on a cycle.
+*
+* - A node that reads no node outside its component has the height 0.
+* - Each other node is one higher than the highest node that it reads outside its component.
+* - The nodes of one component have one height.
+* - An edge without a target reads each node that is not a sink (GRAPH.UNKNOWN).
+*
+* @param graph - The nodes, each with its edges.
+* @param options - The option `eager` keeps only the eager edges with a target node.
+* @returns The height of each node, in the order of the graph.
+*/
+function heights(graph, options = {}) {
+	const index = indexed(graph, options);
+	const found = strong(index);
+	const levels = heightsOf(index, found);
+	const out = /* @__PURE__ */ new Map();
+	index.ids.forEach((id, node) => out.set(id, levels[found.of[node]]));
+	return out;
+}
+/**
+* This function puts the nodes in layers by their heights, in linear time (GRAPH.LAYERS). The first layer has the
+* height 0. Two nodes of one layer read each other only inside one component. Thus a push schedule can evaluate the
+* components of one layer at the same time.
+*
+* @param graph - The nodes, each with its edges.
+* @param options - The option `eager` keeps only the eager edges with a target node.
+* @returns The layers, from the height 0 up. Each layer keeps the order of the graph.
+*/
+function nodeLayers(graph, options = {}) {
+	const out = [];
+	for (const [id, height] of heights(graph, options)) {
+		while (out.length <= height) out.push([]);
+		out[height]?.push(id);
+	}
+	return out;
+}
+/**
+* This function gives the nodes that a set of observed nodes needs (GRAPH.NECESSARY). These are the observed nodes,
+* and each node with a path of edges from them. A push schedule evaluates only these nodes. An observed name that is
+* not a node of the graph adds nothing.
+*
+* @param graph - The nodes, each with its edges.
+* @param observed - The nodes that the host shows or reads.
+* @param options - The option `eager` keeps only the eager edges with a target node.
+* @returns The necessary nodes, in the order of the graph.
+*/
+function necessary(graph, observed, options = {}) {
+	const index = indexed(graph, options);
+	const numbers = /* @__PURE__ */ new Map();
+	index.ids.forEach((id, node) => numbers.set(id, node));
+	const seen = new Uint8Array(index.size);
+	const work = [];
+	for (const id of observed) {
+		const node = numbers.get(id);
+		if (node === void 0 || seen[node] === 1) continue;
+		seen[node] = 1;
+		work.push(node);
+	}
+	while (work.length > 0) {
+		const node = work.pop();
+		for (let edge = index.start[node]; edge < index.start[node + 1]; edge += 1) {
+			const to = index.targets[edge];
+			if (seen[to] === 1) continue;
+			seen[to] = 1;
+			work.push(to);
+		}
+	}
+	const out = /* @__PURE__ */ new Set();
+	index.ids.forEach((id, node) => {
+		if (seen[node] === 1) out.add(id);
+	});
+	return out;
+}
+/**
+* This function gives the static cycles of a graph (GRAPH.CYCLE): each component with two or more nodes, and each
+* node with an edge to itself. A cycle of the eager edges with a target is certain, and `check` or a host can report
+* it before a run. Another cycle is possible: an evaluation can skip a lazy read.
+*
+* - A component of all the edges that is also a component of the eager edges is one certain cycle.
+* - Each other component of all the edges is one possible cycle, and each certain cycle in it comes after it.
+* - A read can still fail before it occurs. Thus the demand of D31, not a static cycle, gives the value of each node.
+*
+* @param graph - The nodes, each with its edges.
+* @returns The cycles, deepest first.
+*/
+function cycles(graph) {
+	const every = indexed(graph, {});
+	const found = strong(every);
+	const eager = indexed(graph, { eager: true });
+	const inside = /* @__PURE__ */ new Map();
+	for (const members of strong(eager).list) {
+		if (!cyclic(eager, members)) continue;
+		const component = found.of[members[0]];
+		const list = inside.get(component);
+		if (list === void 0) inside.set(component, [members]);
+		else list.push(members);
+	}
+	const out = [];
+	found.list.forEach((members, component) => {
+		if (!cyclic(every, members)) return;
+		const nodes = named$1(every, members);
+		const certain = inside.get(component) ?? [];
+		if (certain.length === 1 && certain[0]?.length === nodes.length) {
+			out.push({
+				nodes,
+				certain: true
+			});
+			return;
+		}
+		out.push({
+			nodes,
+			certain: false
+		});
+		for (const part of certain) out.push({
+			nodes: named$1(eager, part),
+			certain: true
+		});
+	});
+	return out;
+}
+/**
+* This function gives the nodes that a demand of a node needs first, deepest first (SCHED.LONG-CHAIN). It follows the
+* eager edges with a target from the node, with its own stack. Each node comes after each node that it reads, except
+* on a cycle, as in an order by heights. The walk costs only the nodes that it enters.
+*
+* @param from - The node of the demand. It is not in the answer.
+* @param edgesOf - This function gives the edges of a node, or `undefined` for a node that the walk does not enter.
+* @returns The nodes, deepest first.
+*/
+function deepestFirst(from, edgesOf) {
+	const out = [];
+	const first = edgesOf(from);
+	if (first === void 0) return out;
+	const seen = /* @__PURE__ */ new Set([from]);
+	const nodes = [from];
+	const lists = [first];
+	const positions = [0];
+	while (nodes.length > 0) {
+		const top = nodes.length - 1;
+		const edges = lists[top];
+		let position = positions[top];
+		let entered = false;
+		while (position < edges.length) {
+			const edge = edges[position];
+			position += 1;
+			const to = edge.to;
+			if (edge.lazy || to === void 0 || seen.has(to)) continue;
+			seen.add(to);
+			const more = edgesOf(to);
+			if (more === void 0) continue;
+			positions[top] = position;
+			nodes.push(to);
+			lists.push(more);
+			positions.push(0);
+			entered = true;
+			break;
+		}
+		if (entered) continue;
+		const done = nodes.pop();
+		lists.pop();
+		positions.pop();
+		if (nodes.length > 0) out.push(done);
+	}
+	return out;
+}
+// src/instances.ts
+/**
+* This function gives the name of a vertex of the graph of attribute instances. The name is the JSON text of the
+* place of the node, with the name of the attribute after it.
+*
+* @param place - The place of the document of the node.
+* @param attribute - The name of the attribute.
+* @returns The name of the vertex.
+*/
+function attributeVertexId(place, attribute) {
+	return JSON.stringify([...place, attribute]);
+}
+/** The standard code whose value is the plain data of its document. */
+const DATA$1 = /* @__PURE__ */ new Set([
+	"data.number",
+	"data.text",
+	"data.bool"
+]);
+/** The standard code of a list. Its value holds the value of each item, in the order of the items. */
+const LIST$1 = "list.all";
+/** The self of the root of a walk: the self of the context, outside each tree of the document. */
+const OUTSIDE = {
+	kind: { verbs: {} },
+	text: "",
+	own: void 0,
+	parent: void 0
+};
+/** The self of an equation, for the references of the equation. */
+const EQUATION_SELF = {
+	kind: { verbs: {} },
+	text: "",
+	own: void 0,
+	parent: void 0
+};
+const NO_BOUND = /* @__PURE__ */ new Set();
+/** This function gives the name of an own part from the slot of its document. */
+function slotKey(slot) {
+	return slot.map(String).join(".");
+}
+/** This function gives the value of a document before the run. */
+function valueOf$1(info) {
+	if (info === void 0) return "unknown";
+	if (info.node !== void 0) return { node: info.node };
+	if (info.evaluator === LIST$1) return { list: info };
+	return info.evaluator !== void 0 && DATA$1.has(info.evaluator) ? "data" : "unknown";
+}
+/** This function tells if a table of a tree contract has its own entry for a name. */
+function hasOwnEntry(table, name) {
+	return table !== void 0 && Object.hasOwn(table, name);
+}
+/** This function gives the vertex of an attribute of a node. A new vertex goes on the work list for its rungs. */
+function vertexOf(b, node, attribute) {
+	const id = attributeVertexId(node.visit.place, attribute);
+	if (!b.vertices.has(id)) {
+		b.vertices.set(id, {
+			id,
+			place: node.visit.place,
+			attribute,
+			type: node.text
+		});
+		b.nodes.set(id, node);
+		if (!node.parts.has(attribute)) b.work.push(id);
+	}
+	return id;
+}
+function edge(b, from, r, lazy = false) {
+	b.edges.push({
+		from,
+		to: r.to,
+		lazy: r.lazy || lazy,
+		place: r.place
+	});
+	b.ats.push(r.at);
+}
+/** This function gives the items of a list document, in the order of their indices. */
+function itemsOf(list) {
+	return [...list.items].sort(([x], [y]) => x - y).map(([, item]) => item);
+}
+/**
+* This function gives the attributes that the JSON of a value reads, in their order (TREE.RESULT). A node reads each
+* own part, with the JSON of each node in its value after it. A list gives the JSON of each item.
+*/
+function jsonOrder(value, out, done) {
+	if (typeof value !== "object") return;
+	if ("list" in value) {
+		for (const item of itemsOf(value.list)) jsonOrder(valueOf$1(item), out, done);
+		return;
+	}
+	const node = value.node;
+	if (done.has(node)) return;
+	done.add(node);
+	for (const key of node.own) {
+		out.push([node, key]);
+		jsonOrder(valueOf$1(node.parts.get(key)), out, done);
+	}
+}
+/** This function adds the reads of the JSON of a value. */
+function jsonReads(b, value, r) {
+	const order = [];
+	jsonOrder(value, order, /* @__PURE__ */ new Set());
+	for (const [node, key] of order) edge(b, vertexOf(b, node, key), r);
+}
+/** This function gives the node that a walker `nearest` with the key `parent` reaches before the run. */
+function nearestOf(start, data) {
+	if ((isRecord(data) && typeof field(data, "follow") === "string" ? String(field(data, "follow")) : "parent") !== "parent") return "unknown";
+	const wanted = isRecord(data) ? field(data, "type") : void 0;
+	let at = isRecord(data) && field(data, "self") === true ? start : start.up;
+	while (at !== null && at !== void 0) {
+		if (at.text === wanted) return { node: at };
+		at = at.up;
+	}
+	return at === null ? "outside" : "unknown";
+}
+/**
+* This function follows the steps of a path from a value, and it adds each read on the way (TREE.GRAPH). A step
+* `parent` goes to the parent node, and a step `type` gives data. Another key reads an attribute. A walker `nearest`
+* with the key `parent` depends only on the structure. A step after a value that only the run knows gives an edge with
+* an unknown source. A path that ends at a node reads the JSON of the node.
+*/
+function follow(b, start, path, from, r) {
+	let here = start;
+	for (let index = from; index < path.length; index += 1) {
+		const step = path[index];
+		if (here === "unknown") {
+			edge(b, void 0, r);
+			return;
+		}
+		if (here === "data" || here === "outside") return;
+		if ("list" in here) {
+			if (!isKey(step)) {
+				edge(b, void 0, r);
+				return;
+			}
+			if (step === "length") {
+				here = "data";
+				continue;
+			}
+			const at = typeof step === "number" ? step : /^\d+$/.test(step) ? Number(step) : -1;
+			const item = here.list.items.get(at);
+			if (item === void 0) return;
+			here = valueOf$1(item);
+			continue;
+		}
+		const node = here.node;
+		if (isKey(step)) {
+			const key = String(step);
+			if (key === "parent") here = node.up === null ? "outside" : node.up === void 0 ? "unknown" : { node: node.up };
+			else if (isStructural(key)) here = "data";
+			else {
+				edge(b, vertexOf(b, node, key), r);
+				here = valueOf$1(node.parts.get(key));
+			}
+			continue;
+		}
+		if (walkerOf(b.machine, step) !== STD_WALKERS["walk.nearest"]) {
+			edge(b, void 0, r);
+			return;
+		}
+		here = nearestOf(node, isRecord(step) ? field(step, "value") : void 0);
+	}
+	if (typeof here === "object" && "node" in here) jsonReads(b, here, r);
+}
+/**
+* This function gives the references of an equation of a kind, with the self and the lazy mark of each (D107). It walks
+* the equation with the rules of `check`, thus a reference keeps the self of the equation only through standard code.
+*/
+function termRefs(b, kind, label, term) {
+	let byLabel = b.terms.get(kind);
+	if (byLabel === void 0) {
+		byLabel = /* @__PURE__ */ new Map();
+		b.terms.set(kind, byLabel);
+	}
+	const known = byLabel.get(label);
+	if (known !== void 0) return known;
+	const out = [];
+	const of = equationType(kind);
+	const selves = selvesOf(b.machine, "eval", EQUATION_SELF);
+	const above = /* @__PURE__ */ new Map();
+	walk(b.machine.world, term, (v) => {
+		const answer = ask(b.machine.world, v.declared ? {} : v.doc, "eval", v.declared ? { declaredType: typeName(v.doc.type) } : {});
+		if (answer.error === "unknown-kind") return "skip";
+		const up = v.parent === void 0 ? void 0 : above.get(v.parent);
+		const lazy = up !== void 0 && v.parent !== void 0 && (up.lazy || partLazy(up, v.parent, v.slot));
+		above.set(v, {
+			lazy,
+			rules: v.kind === void 0 ? void 0 : codeFactsOf(b.machine, v, v.kind, "eval").rules
+		});
+		const { self } = selves.enter(v, answer.evaluator);
+		const evaluator = answer.evaluator;
+		if (evaluator === "ref.resolve" && isRef(v.doc)) {
+			if (v.address !== true) out.push({
+				path: v.doc.value,
+				lazy,
+				self: self === EQUATION_SELF,
+				bound: v.names,
+				opaque: false
+			});
+		} else if (self === EQUATION_SELF && evaluator !== "tree.node" && !keepsSelf(evaluator)) out.push({
+			path: [],
+			lazy,
+			self: true,
+			bound: NO_BOUND,
+			opaque: true
+		});
+	}, of === void 0 ? {} : { declaredType: of });
+	byLabel.set(label, out);
+	return out;
+}
+/** This function adds the reads of an equation of a rung: self is a node, and the names of the rung have their values. */
+function termReads(b, refs, self, names, r) {
+	for (const ref of refs) {
+		const read = ref.lazy ? {
+			...r,
+			lazy: true
+		} : r;
+		if (ref.opaque) {
+			edge(b, void 0, read);
+			continue;
+		}
+		const root = ref.path[0];
+		if (root === "self") {
+			if (ref.self) follow(b, { node: self }, ref.path, 1, read);
+			else if (ref.path.length > 1) edge(b, void 0, read);
+			continue;
+		}
+		if (root !== "names" || ref.path.length < 2) continue;
+		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?.prev !== void 0 && name === "prev") start = names.prev;
+		else if (name === "index") start = "data";
+		else if (name === "acc" || name === "item") start = "unknown";
+		else continue;
+		follow(b, start, ref.path, 2, read);
+	}
+}
+/** This function gives the previous sibling of a node in the list `children` of its parent, before the run. */
+function prevOf(parent, child) {
+	const list = parent.parts.get("children");
+	if (list === void 0 || list.evaluator !== LIST$1) return "unknown";
+	for (const [index, item] of list.items) {
+		if (item.node !== child) continue;
+		return index === 0 ? "data" : valueOf$1(list.items.get(index - 1));
+	}
+	return "data";
+}
+/**
+* This function adds the reads of the rungs of an attribute that is not an own part, in the order of the ladder
+* (TREE.LADDER). After a rung that can fail to answer, the reads of the later rungs are lazy.
+*/
+function rungReads(b, id) {
+	const node = b.nodes.get(id);
+	const key = b.vertices.get(id).attribute;
+	const tree = node.kind.tree;
+	const r = {
+		to: id,
+		lazy: false,
+		place: node.visit.place,
+		at: node.visit.at
+	};
+	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);
+		return;
+	}
+	let later = r;
+	const up = node.up;
+	if (up === void 0) {
+		if (downNames(b.machine.world).has(key)) {
+			edge(b, void 0, r);
+			later = {
+				...r,
+				lazy: true
+			};
+		}
+	} else if (up !== null) {
+		const down = hasOwnEntry(up.kind.tree?.down, key) ? up.kind.tree?.down?.[key] : void 0;
+		if (down !== void 0) {
+			edge(b, vertexOf(b, up, "children"), r);
+			termReads(b, termRefs(b, up.kind, `tree.down.${key}`, down), up, {
+				child: node,
+				prev: prevOf(up, node)
+			}, r);
+			return;
+		}
+	}
+	const declared = hasOwnEntry(tree?.attributes, key) ? tree?.attributes?.[key] : void 0;
+	if (declared?.copy === true && up !== null) {
+		edge(b, up === void 0 ? void 0 : vertexOf(b, up, key), later);
+		later = {
+			...later,
+			lazy: true
+		};
+	}
+	const fold = declared?.fold;
+	if (fold !== void 0) {
+		termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.fold.unit`, fold.unit), node, void 0, later);
+		edge(b, vertexOf(b, node, "children"), later);
+		const children = valueOf$1(node.parts.get("children"));
+		let combined = false;
+		if (children === "unknown") edge(b, void 0, later);
+		else if (typeof children === "object" && "list" in children) for (const item of itemsOf(children.list)) {
+			const child = item.node;
+			if (child === void 0) continue;
+			edge(b, vertexOf(b, child, key), later);
+			combined = true;
+		}
+		termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.fold.combine`, fold.combine), node, void 0, combined ? later : {
+			...later,
+			lazy: true
+		});
+		return;
+	}
+	if (declared?.default !== void 0) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.default`, declared.default), node, void 0, later);
+}
+function build(machine, doc, declaredType) {
+	const b = {
+		machine,
+		vertices: /* @__PURE__ */ new Map(),
+		nodes: /* @__PURE__ */ new Map(),
+		edges: [],
+		ats: [],
+		work: [],
+		terms: /* @__PURE__ */ new Map()
+	};
+	const roots = [];
+	const all = [];
+	const reads = [];
+	const states = /* @__PURE__ */ new Map();
+	const nodes = /* @__PURE__ */ new Map();
+	const selves = selvesOf(machine, "eval", OUTSIDE);
+	walk(machine.world, doc, (v) => {
+		const answer = ask(machine.world, v.declared ? {} : v.doc, "eval", v.declared ? { declaredType: typeName(v.doc.type) } : {});
+		if (answer.error === "unknown-kind") return "skip";
+		const evaluator = answer.evaluator;
+		const parent = v.parent === void 0 ? void 0 : states.get(v.parent);
+		const { self, node: seen } = selves.enter(v, evaluator);
+		let owner;
+		let lazy = false;
+		if (parent?.info.node !== void 0) owner = {
+			node: parent.info.node,
+			key: slotKey(v.slot)
+		};
+		else if (parent !== void 0 && v.parent !== void 0) {
+			owner = parent.owner;
+			lazy = parent.lazy || partLazy(parent.above, v.parent, v.slot);
+		}
+		let node;
+		if (seen !== void 0 && v.kind !== void 0) {
+			const up = self === OUTSIDE ? null : self === void 0 ? void 0 : nodes.get(self);
+			node = {
+				visit: v,
+				kind: v.kind,
+				text: seen.text,
+				own: [...seen.own ?? []],
+				parts: /* @__PURE__ */ new Map(),
+				up
+			};
+			nodes.set(seen, node);
+			all.push(node);
+			if (up === null && !lazy) roots.push(node);
+		}
+		const info = {
+			visit: v,
+			evaluator,
+			node,
+			items: /* @__PURE__ */ new Map()
+		};
+		if (parent?.info.node !== void 0) parent.info.node.parts.set(slotKey(v.slot), info);
+		else if (parent?.info.evaluator === LIST$1 && v.slot.length === 1 && typeof v.slot[0] === "number") parent.info.items.set(v.slot[0], info);
+		states.set(v, {
+			info,
+			owner,
+			lazy,
+			above: {
+				lazy,
+				rules: v.kind === void 0 ? void 0 : codeFactsOf(machine, v, v.kind, "eval").rules
+			}
+		});
+		if (owner === void 0 || node !== void 0) return void 0;
+		const value = self === OUTSIDE ? "outside" : self === void 0 ? "unknown" : { node: nodes.get(self) };
+		if (evaluator === "ref.resolve" && isRef(v.doc)) {
+			if (v.address !== true) reads.push({
+				owner,
+				v,
+				lazy,
+				self: value,
+				opaque: false
+			});
+		} else if (value !== "unknown" && evaluator !== "ref.resolve" && !keepsSelf(evaluator)) reads.push({
+			owner,
+			v,
+			lazy,
+			self: value,
+			opaque: true
+		});
+	}, declaredType === void 0 ? {} : { declaredType });
+	for (const node of all) for (const key of node.own) vertexOf(b, node, key);
+	for (const { owner, v, lazy, self, opaque } of reads) {
+		const r = {
+			to: vertexOf(b, owner.node, owner.key),
+			lazy,
+			place: v.place,
+			at: v.at
+		};
+		if (opaque) {
+			edge(b, void 0, r);
+			continue;
+		}
+		const path = v.doc.value;
+		const root = path[0];
+		if (root === "self") {
+			if (self === "unknown") edge(b, void 0, r);
+			else follow(b, self, path, 1, r);
+		} else if (root === "names" && path.length >= 2 && v.names.has(String(path[1]))) edge(b, void 0, r);
+	}
+	for (let next = b.work.shift(); next !== void 0; next = b.work.shift()) rungReads(b, next);
+	return {
+		b,
+		roots
+	};
+}
+/** This function gives the graph for `graph.ts`: each vertex with the vertices that it reads. */
+function nodeGraph(b) {
+	const reads = /* @__PURE__ */ new Map();
+	for (const id of b.vertices.keys()) reads.set(id, []);
+	for (const e of b.edges) reads.get(e.to)?.push({
+		to: e.from,
+		lazy: e.lazy
+	});
+	return new Map([...reads].map(([id, edges]) => [id, { edges }]));
+}
+/**
+* This function gives the graph of attribute instances of a document (TREE.GRAPH, R3 P5, D107). It has one vertex for
+* each attribute of each node of the decorated tree. It has one edge for each read of the code of an attribute.
+*
+* - A path from `self` reads the attribute of the node. `self.parent` goes to the parent node.
+* - The step `nearest` with the key `parent` depends only on the structure, thus it goes to a node of the document.
+* - The rungs of the ladder read too: `names.prev` of `down` reads the previous sibling, and a fold reads each child.
+* - A read that depends on the value of an attribute gets an edge with an unknown source.
+*
+* The walk is the walk of `check`, with its rules for the self of each document (D106). The evaluator of the kernel
+* does not use the graph (D3).
+*
+* @param machine - The world and the code of the evaluators.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value.
+* @returns The vertices, the edges, the graph for the analysis, the reads that only the run knows and the cycles.
+*/
+function attributeGraph(machine, doc, options = {}) {
+	const { b } = build(machine, doc, options.declaredType);
+	const graph = nodeGraph(b);
+	return {
+		vertices: b.vertices,
+		edges: b.edges,
+		graph,
+		unknown: b.edges.filter((e) => e.from === void 0),
+		cycles: cycles(graph).map((cycle) => ({
+			vertices: cycle.nodes,
+			certain: cycle.certain
+		}))
+	};
+}
+function vertexText(vertex) {
+	return `${vertex.attribute} 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
+* that gives a value reads each own part of each tree root, and each eager read of each attribute that it reads. Thus a
+* certain cycle that these reads reach always gives `#CYCLE!`. The issue gets the place of the read that closes the
+* cycle in the order of the run, and the reason of the run. A cycle through a lazy read or an unknown read is not an issue.
+*
+* @param machine - The world and the code of the evaluators.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value.
+* @returns One issue for each certain cycle that the run reaches.
+*/
+function cycleIssues(machine, doc, options) {
+	const { b, roots } = build(machine, doc, options.declaredType);
+	const graph = nodeGraph(b);
+	const certain = /* @__PURE__ */ new Map();
+	cycles(graph).forEach((cycle, index) => {
+		if (cycle.certain) for (const id of cycle.nodes) certain.set(id, index);
+	});
+	if (certain.size === 0) return [];
+	const eager = /* @__PURE__ */ new Map();
+	b.edges.forEach((e, index) => {
+		if (e.lazy || e.from === void 0) return;
+		const list = eager.get(e.to);
+		if (list === void 0) eager.set(e.to, [index]);
+		else list.push(index);
+	});
+	const demands = [];
+	const done = /* @__PURE__ */ new Set();
+	for (const root of roots) jsonOrder({ node: root }, demands, done);
+	const order = demands.map(([node, key]) => attributeVertexId(node.visit.place, key));
+	const state = /* @__PURE__ */ new Map();
+	const reported = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const start of order) {
+		if (state.has(start)) continue;
+		const stack = [{
+			id: start,
+			next: 0
+		}];
+		state.set(start, "busy");
+		while (stack.length > 0) {
+			const top = stack[stack.length - 1];
+			const list = eager.get(top.id) ?? [];
+			if (top.next >= list.length) {
+				state.set(top.id, "done");
+				stack.pop();
+				continue;
+			}
+			const index = list[top.next];
+			top.next += 1;
+			const e = b.edges[index];
+			const from = e.from;
+			const seen = state.get(from);
+			if (seen === void 0) {
+				state.set(from, "busy");
+				stack.push({
+					id: from,
+					next: 0
+				});
+				continue;
+			}
+			if (seen === "done") continue;
+			const cycle = certain.get(from);
+			if (cycle === void 0 || reported.has(cycle)) continue;
+			reported.add(cycle);
+			const first = stack.findIndex((frame) => frame.id === from);
+			const chain = [...stack.slice(first).map((frame) => frame.id), from].map((id) => vertexText(b.vertices.get(id)));
+			out.push({
+				code: "#CYCLE!",
+				place: e.place,
+				reason: `The attributes form a cycle: ${chain.join(" -> ")}.`,
+				at: b.ats[index]
+			});
+		}
+	}
+	return out;
+}
+// src/static.ts
+/** The names of a walk without names. A walk does not change a set at any time: it makes a new set to add names. */
+const NO_NAMES = /* @__PURE__ */ new Set();
+/** This function gives the options of a walk without the names of the host. */
+function withoutNames(options) {
+	const { names: _host, ...rest } = options;
+	return rest;
+}
+/** This function gives the keys of a trail, from its start. It keeps the result in the trail. */
+function keysOf(trail) {
+	if (trail === void 0) return [];
+	if (trail.full !== void 0) return trail.full;
+	const steps = [];
+	let here = trail;
+	while (here !== void 0 && here.full === void 0) {
+		steps.push(here);
+		here = here.up;
+	}
+	const keys = here?.full === void 0 ? [] : [...here.full];
+	for (let index = steps.length - 1; index >= 0; index -= 1) for (const key of steps[index].keys) keys.push(key);
+	trail.full = keys;
+	return keys;
+}
+/** A visit with its paths as trails. It makes the keys of a path only when a reader asks for them. */
+var Visit = class {
+	doc;
+	declared;
+	depth;
+	names;
+	later;
+	slot;
+	parent;
+	kind;
+	typePath;
+	address;
+	caps;
+	#place;
+	#at;
+	#bound;
+	#expect;
+	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps, bound, expect) {
+		this.doc = doc;
+		this.declared = declared;
+		this.depth = depth;
+		this.names = names;
+		this.later = later;
+		this.slot = slot;
+		this.parent = parent;
+		this.kind = kind;
+		this.typePath = typePath;
+		this.address = address;
+		this.caps = caps;
+		this.#place = place;
+		this.#at = at;
+		this.#bound = bound;
+		this.#expect = expect;
+	}
+	/** The names that the scope rules of the parent bind for this document. The check of types reads them. */
+	get bound() {
+		return this.#bound;
+	}
+	/** The type that the shape of the parent declares for this part. The check of types reads it. */
+	get expect() {
+		return this.#expect;
+	}
+	get place() {
+		return keysOf(this.#place);
+	}
+	get at() {
+		return keysOf(this.#at);
+	}
+};
+/**
+* This function visits each document of a document: the root and each part at each depth, by the contracts of the
+* kinds. A part of a kind that the world does not have is not visited. With capabilities in the options, the walk
+* narrows them for each part by the rules of its kind, as a run does. The walk uses no stack of the host for the
+* depth, thus a deep document cannot overflow it. The time and the memory of a walk are linear in the size of the
+* document. A visit makes the keys of its place and of its path only when a reader asks for them.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param visit - The function that gets each document. It gives `"skip"` to not visit the parts of a document.
+* @param options - The type of a bare root value, the names, the capabilities and a function for the problems.
+*/
+function walk(world, doc, visit, options = {}) {
+	const stack = [{
+		value: doc,
+		place: void 0,
+		at: void 0,
+		declared: options.declaredType,
+		depth: 0,
+		names: options.names === void 0 || options.names.length === 0 ? NO_NAMES : new Set(options.names),
+		later: NO_NAMES,
+		address: false,
+		slot: [],
+		parent: void 0,
+		caps: options.caps,
+		bound: [],
+		expect: void 0
+	}];
+	while (stack.length > 0) {
+		const item = stack.pop();
+		const read = partsOf(world, item.value, item.declared);
+		if (!read.ok) {
+			options.problem?.({
+				place: keysOf(item.place),
+				at: keysOf(item.at),
+				code: read.code,
+				reason: read.reason
+			});
+			continue;
+		}
+		const { doc, kind, split } = read;
+		const here = new Visit(item.place, item.at, doc, read.declared, item.depth, item.names, item.later, item.slot, item.parent, kind, read.typePath, item.address ? true : void 0, item.caps, item.bound, item.expect);
+		if (visit(here) === "skip" || kind === void 0) continue;
+		const base = read.declared ? item.at : {
+			up: item.at,
+			keys: ["value"]
+		};
+		if (!split.ok) {
+			options.problem?.({
+				place: keysOf(item.place),
+				at: keysOf({
+					up: base,
+					keys: split.at
+				}),
+				code: "#VALUE!",
+				reason: split.reason
+			});
+			continue;
+		}
+		const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
+		for (let index = split.parts.length - 1; index >= 0; index -= 1) {
+			const slot = split.parts[index];
+			const extra = sees[index] ?? [];
+			const hidden = later[index] ?? [];
+			stack.push({
+				value: slot.item,
+				place: slot.path.length === 0 ? item.place : {
+					up: item.place,
+					keys: slot.path
+				},
+				at: slot.path.length === 0 ? base : {
+					up: base,
+					keys: slot.path
+				},
+				declared: slot.of,
+				depth: item.depth + 1,
+				names: extra.length === 0 ? item.names : /* @__PURE__ */ new Set([...item.names, ...extra]),
+				later: hidden.length === 0 ? item.later : /* @__PURE__ */ new Set([...item.later, ...hidden]),
+				address: slot.address === true,
+				slot: slot.path,
+				parent: here,
+				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : partCaps(kind.caps, slot.path, item.caps),
+				bound: extra,
+				expect: slot.expect
+			});
+		}
+	}
+}
+/**
+* This function finds each reference of a document: each document of the type `ref` that a walk reaches. A
+* reference to a name that a kind around it binds is not free. The others are what the document reads from
+* outside: its dependencies. When the kind `ref` has parts, the walk also finds the references in its step documents.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value. The names of the host do not change the result.
+* @returns The references, in the order of the document.
+*/
+function refsOf(world, doc, options = {}) {
+	const out = [];
+	walk(world, doc, (v) => {
+		if (!isRef(v.doc)) return void 0;
+		const path = v.doc.value;
+		const root = typeof path[0] === "string" ? path[0] : "";
+		const first = path[1];
+		const use = {
+			path,
+			root,
+			free: !(root === "names" && isKey(first) && v.names.has(String(first))),
+			address: v.address === true
+		};
+		Object.defineProperty(use, "place", {
+			enumerable: true,
+			get: () => v.place
+		});
+		Object.defineProperty(use, "at", {
+			enumerable: true,
+			get: () => v.at
+		});
+		Object.defineProperty(use, "visit", {
+			enumerable: false,
+			value: v
+		});
+		out.push(use);
+	}, options.names === void 0 ? options : withoutNames(options));
+	return out;
+}
+function setAt(value, path, next) {
+	if (path.length === 0) return next;
+	const [key, ...rest] = path;
+	if (Array.isArray(value)) {
+		const copy = [...value];
+		copy[Number(key)] = setAt(value[Number(key)], rest, next);
+		return copy;
+	}
+	const record = isRecord(value) ? value : {};
+	const copy = {};
+	for (const name of Object.keys(record)) Object.defineProperty(copy, name, {
+		value: record[name],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	Object.defineProperty(copy, String(key), {
+		value: setAt(record[String(key)], rest, next),
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return copy;
+}
+/**
+* This function changes the free references of a document. The document is not changed: the function gives a new
+* document that shares each part without a change.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param change - The function that gives the new document of a reference, or `undefined` to keep it.
+* @param options - The type of a bare root value, and the names that the host binds at the root.
+* @returns The new document.
+*/
+function mapRefs(world, doc, change, options = {}) {
+	let out = doc;
+	for (const use of refsOf(world, doc, options)) {
+		if (!use.free) continue;
+		const next = change(use);
+		if (next !== void 0) out = setAt(out, use.at, next);
+	}
+	return out;
+}
+/** 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).
+*
+* @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.
+*/
+function declaredEffects(v, verb = "eval") {
+	return verbDeclared(v, verb) ?? NO_EFFECTS;
+}
+/**
+* This function gives the effects that the contract of the kind of a visit declares for a verb, as keys. The result
+* is `undefined` when the contract has no declaration for the verb (D49). A visit without a kind declares no effect
+* for `eval` and no declaration for another verb.
+*/
+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("."));
+}
+/**
+* This function gives the rule of a machine for an effect, for the static kit (CAP.PERMITS). The rule is the hook
+* `permits` of the machine, as in a run, or else the function `permits`. A check has no values, thus the hook gets a
+* context with the capabilities of the document and the world of the machine. Its names, its self and its event are
+* empty.
+*
+* @param machine - The machine.
+* @returns The rule. It gets the capabilities of a document and the keys of an effect.
+*/
+function permitsOf(machine) {
+	const hook = machine.permits;
+	if (hook === void 0) return permits;
+	let base;
+	return (caps, kind) => hook(caps, kind, {
+		...base ??= context({ world: worldThing(machine.world) }),
+		caps
+	});
+}
+/**
+* This function gives the reason of a `#CAP!`. When a kind around the document narrowed the capabilities, the
+* reason names the nearest such kind.
+*/
+function capReason(v, kind, allowed) {
+	const text = kind.join(".");
+	for (let up = v.parent; up !== void 0; up = up.parent) if (up.caps !== void 0 && allowed(up.caps, kind)) return `The capabilities do not permit the effect ${text} here. The kind ${typeName(up.doc.type)} around it narrows them for its parts.`;
+	return `The capabilities do not permit the effect ${text}.`;
+}
+/**
+* This function checks a document before an evaluation, by the contracts of its kinds. It finds the problems
+* that an evaluation finds when it reaches them:
+*
+* - `#KIND?`: a kind that the world does not have.
+* - `#NOEVAL`: no evaluator.
+* - `#VALUE!`: a value without the shape of its kind.
+* - `#PART?`: a value without a type.
+* - `#DEPTH!`: too much nesting.
+* - `#REF!` and `#STEP?`: a bad path.
+* - `#NAME?`: a name that nothing binds. With the hook `known` of the machine, also a name that the language does not
+*   have, for example an operation.
+* - `#CAP!`: an effect that the capabilities of its document do not permit. A kind around the document can narrow them.
+*   The hook `permits` of the machine decides, as in a run (CAP.PERMITS).
+* - `#CALC!`: with the option `run`, a runner under a parent without a runner, when an effect of its runners can reach
+*   the host. Also a kind that declares effects and has no runner (RUN.CAN-WAIT). The issue has the place and the
+*   reason of the run.
+* - `#TYPE!`: with the option `types`, a part whose type does not fit the type that its position needs (TYPE.CHECK).
+*   A run does not always fail there, thus a type issue is a static finding, not an error of a run.
+*
+* The check asks the ladder for the verb of the options, `eval` by default (VERB.CHECK). The shapes, the paths and the
+* names follow the contracts, thus they are the same for each verb. The check tests the effects that each contract
+* declares for the verb: `effects` for `eval`, and the entry of `verbEffects` for another verb (VERB.EFFECTS). A kind
+* without a declaration for the verb gives no `#CAP!` and no `#CALC!` for an effect.
+*
+* @param machine - The world and the code of the evaluators.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value, the names of the host, the capabilities, the verb, the types and the run.
+* @returns The problems, in the order of the document. The type issues come after the other issues.
+*/
+function check(machine, doc, options = {}) {
+	return options.types === true ? typeCheck(machine, doc, options).issues : checkAll(machine, doc, options, void 0);
+}
+/**
+* This function checks a document, and it also checks the value types (TYPE.CHECK, D25). It finds each issue of
+* `check`. Then it synthesizes the type of each document from the types of its parts. It also checks each part
+* against the type that its position needs. The type rule of the parent, the signature of an operation or the shape
+* of the contract gives that type. A part with an issue gets the type `unknown`, thus one
+* problem does not give a chain of issues.
+*
+* A type issue has the code `#TYPE!`, the type that the position needs (`expected`) and the type that the check found
+* (`found`). It is a static finding: the evaluation of the document does not change.
+*
+* The option `rootTypes` gives the types of the roots and of the names of the host (TYPE.ROOTS). A reference then gets
+* the type that its path reaches, and a field that a closed record does not have is a type issue (TYPE.CLOSED).
+*
+* @param machine - The world and the code of the evaluators, with their type rules.
+* @param doc - The document, as JSON.
+* @param options - The options of `check`, the type that the root must have and the types of the roots.
+* @returns The type of the root, each issue, and the type of each document.
+*/
+function typeCheck(machine, doc, options = {}) {
+	const nodes = [];
+	const issues = checkAll(machine, doc, options, nodes);
+	const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
+	return {
+		type: pass.type,
+		issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues],
+		places: pass.places
+	};
+}
+/** This function tells if a table of verbs has an entry for a verb. */
+function hasVerb(table, verb) {
+	return table !== void 0 && Object.hasOwn(table, verb);
+}
+/**
+* This function checks the world of a machine before a document exists. It finds each kind that has no entry for a
+* verb of the list, when the world has no default for that verb (STATIC.COVERAGE). A document of such a kind gets no
+* evaluator for the verb, thus the check gives the same proof of coverage as a type system.
+*
+* The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
+* world. It does not follow an alias, because the kind of an alias has its own place. Without the option `types`, the
+* check reads only the world.
+*
+* With the option `types`, the check also examines each value type of the machine (TYPE.WORLD, D110). These issues
+* have the code `#TYPE!`, and they come after the issues of the verbs.
+*
+* @param machine - The machine, for its world.
+* @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
+* @param options - The option `types`.
+* @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
+*   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
+*/
+function checkWorld(machine, verbs, options = {}) {
+	const world = machine.world;
+	const open = verbs.filter((verb) => !hasVerb(world.defaults, verb));
+	const out = [];
+	if (open.length > 0) eachKind(world, (kind, path, fallback) => {
+		const text = path.join(".");
+		const name = fallback ? path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}` : `the kind ${text}`;
+		for (const verb of open) {
+			if (hasVerb(kind.verbs, verb)) continue;
+			const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
+			out.push(fallback ? {
+				code: "#NOEVAL",
+				kind: path,
+				fallback: true,
+				verb,
+				reason
+			} : {
+				code: "#NOEVAL",
+				kind: path,
+				verb,
+				reason
+			});
+		}
+	});
+	if (options.types === true) out.push(...machineTypeIssues(machine));
+	return out;
+}
+/** The names that an equation of `down` sees (TREE.DOWN). */
+const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
+	"child",
+	"index",
+	"prev"
+]);
+/** The names that the term `combine` of a fold sees (TREE.FOLD). */
+const FOLD_NAMES = /* @__PURE__ */ Object.freeze(["acc", "item"]);
+/**
+* This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
+* `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
+*/
+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: [],
+		attribute: name,
+		down: false
+	});
+	for (const [name, term] of Object.entries(tree.down ?? {})) out.push({
+		label: `tree.down.${name}`,
+		term,
+		names: DOWN_NAMES,
+		attribute: name,
+		down: true
+	});
+	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: [],
+				attribute: name,
+				down: false
+			});
+			out.push({
+				label: `tree.attributes.${name}.fold.combine`,
+				term: declared.fold.combine,
+				names: FOLD_NAMES,
+				attribute: name,
+				down: false
+			});
+		}
+		if (declared.default !== void 0) out.push({
+			label: `tree.attributes.${name}.default`,
+			term: declared.default,
+			names: [],
+			attribute: name,
+			down: false
+		});
+	}
+	return out;
+}
+/**
+* The steps that a node of the decorated tree answers before its ladder: `parent` and `type` (D106). An attribute with
+* one of these names gets no read.
+*/
+const STRUCTURAL = /* @__PURE__ */ Object.freeze({
+	parent: "the step parent gives the parent of the node",
+	type: "the step type gives the type of the node"
+});
+/**
+* The standard code that gives its parts the self of its own context (D106). `check` knows the self of a document only
+* through this code and the nodes of the decorated tree.
+*/
+const KEEPS_SELF = /* @__PURE__ */ new Set([
+	"data.number",
+	"data.text",
+	"data.bool",
+	"math.add",
+	"math.multiply",
+	"math.greater",
+	"control.seq",
+	"control.pure",
+	"control.if",
+	"list.all",
+	"effect.log",
+	"effect.write"
+]);
+/** This function tells if standard code gives its parts the self of its own context (D106). */
+function keepsSelf(evaluator) {
+	return evaluator !== void 0 && KEEPS_SELF.has(evaluator);
+}
+/**
+* This function makes the selves of one walk (D106). Only `eval` reads attributes, and only when the root `self` is
+* open. A node gets the self of its code as its parent. The standard code that keeps self gives its parts its own self.
+* Other code gives its parts a self that the walk does not know.
+*
+* @param machine - The machine.
+* @param verb - The verb of the walk.
+* @param root - The self of the root document: the node of an equation, or `undefined`.
+* @returns The selves.
+*/
+function selvesOf(machine, verb, root) {
+	const roots = machine.roots ?? ROOTS;
+	const on = verb === "eval" && roots.includes("self") && hasEntry(machine.evaluators, "tree.node") && !hasEntry(machine.runners, "tree.node");
+	const selves = /* @__PURE__ */ new Map();
+	const isNode = (v, evaluator) => on && evaluator === "tree.node" && v.kind !== void 0;
+	return {
+		isNode,
+		enter(v, evaluator) {
+			const self = v.parent === void 0 ? root : selves.get(v.parent);
+			if (!isNode(v, evaluator) || v.kind === void 0) {
+				selves.set(v, keepsSelf(evaluator) ? self : void 0);
+				return {
+					self,
+					node: void 0
+				};
+			}
+			const read = partsOf(machine.world, v.declared ? v.doc.value : v.doc, v.declared ? typeName(v.doc.type) : void 0);
+			const own = read.ok && read.split.ok ? new Set(read.split.parts.map((part) => part.key)) : void 0;
+			const node = {
+				kind: v.kind,
+				text: typeName(v.doc.type),
+				own,
+				parent: self
+			};
+			selves.set(v, node);
+			return {
+				self,
+				node
+			};
+		}
+	};
+}
+/**
+* This function tells if a name is a structural step of a node of the decorated tree: `parent` or `type` (D106). An
+* attribute with such a name gets no read.
+*/
+function isStructural(name) {
+	return Object.hasOwn(STRUCTURAL, name);
+}
+/** The names of `down` in the world of each machine, for a parent that `check` does not know (D106). */
+const DOWNS = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives each name that an equation of `down` of a kind of the world gives. The kinds include the kinds
+* of the namespaces and each fallback kind (WORLD.OPEN). A parent that `check` does not know has one of these kinds.
+*/
+function downNames(world) {
+	const known = DOWNS.get(world);
+	if (known !== void 0) return known;
+	const out = /* @__PURE__ */ new Set();
+	const done = /* @__PURE__ */ new Set();
+	const add = (kind) => {
+		for (const name of Object.keys(kind?.tree?.down ?? {})) out.add(name);
+	};
+	const visit = (entries, fallback) => {
+		if (done.has(entries)) return;
+		done.add(entries);
+		add(fallback);
+		for (const entry of Object.values(entries)) if (isKind(entry)) add(entry);
+		else if (isNamespace(entry)) visit(entry.kinds, entry.fallback);
+	};
+	visit(world.kinds, world.fallback);
+	DOWNS.set(world, out);
+	return out;
+}
+/** This function tells if a table of a tree contract has its own entry for a name. */
+function hasEntry(table, name) {
+	return table !== void 0 && Object.hasOwn(table, name);
+}
+/**
+* This function tells if a rung of the ladder can answer an attribute of a node (TREE.LADDER). An unknown parent can
+* be a node of each kind of the world, thus each name of `down` in the world can answer. A copy can always answer,
+* because `check` does not know a node without a parent.
+*/
+function answered(world, node, name) {
+	if (node.own?.has(name) === true) return true;
+	const tree = node.kind.tree;
+	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);
+}
+/**
+* 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. The function also records the needs of the kind:
+* each declared attribute, and each attribute of the node that an equation reads (TREE.CHECK-COMPLETE).
+*/
+function equationIssues(machine, kind, kindText, options, state) {
+	const of = equationType(kind);
+	const out = [];
+	const needs = [];
+	state.needs.set(kind, needs);
+	for (const name of Object.keys(kind.tree?.attributes ?? {})) needs.push({
+		name,
+		why: "the kind declares it",
+		hidden: void 0
+	});
+	const self = {
+		kind,
+		text: kindText,
+		own: void 0,
+		parent: void 0
+	};
+	for (const { label, term, names, attribute, down } of equationsOf(kind)) {
+		const inner = {
+			names,
+			...of === void 0 ? {} : { declaredType: of },
+			...options.caps === void 0 ? {} : { caps: [] }
+		};
+		const read = (name) => {
+			needs.push({
+				name,
+				why: `the equation ${label} reads it`,
+				hidden: down ? void 0 : attribute
+			});
+		};
+		for (const issue of checkAll(machine, term, inner, void 0, state, {
+			node: self,
+			read
+		})) 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 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.
+*/
+function contractIssues(kind, kindText) {
+	const out = [];
+	const tree = kind.tree;
+	for (const table of [
+		"equations",
+		"down",
+		"attributes"
+	]) for (const name of Object.keys(tree?.[table] ?? {})) {
+		const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : void 0;
+		if (why !== void 0) out.push({
+			code: "#NAME?",
+			place: [],
+			reason: `The kind ${kindText} gives the reserved attribute tree.${table}.${name}: ${why}.`
+		});
+	}
+	if (kind.side === "run") out.push({
+		code: "#CALC!",
+		place: [],
+		reason: `The tree kind ${kindText} is on the run side: a node evaluates its attributes on demand, thus in no fixed order.`
+	});
+	return out;
+}
+/**
+* This function finds the issues of a node of a document (D106). An own part with the name of a structural step is
+* not read at any time (TREE.CHECK-RESERVED). Each need of the kind gets an answer from a rung (TREE.CHECK-COMPLETE).
+*/
+function nodeIssues(machine, node, state, v) {
+	const out = [];
+	const at = (key) => [
+		...v.at,
+		...v.declared ? [] : ["value"],
+		key
+	];
+	for (const name of node.own ?? []) {
+		const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : void 0;
+		if (why !== void 0) out.push({
+			code: "#NAME?",
+			place: v.place,
+			reason: `The part ${name} of the kind ${node.text} has a reserved name: ${why}.`,
+			at: at(name)
+		});
+	}
+	const done = /* @__PURE__ */ new Set();
+	for (const need of state.needs.get(node.kind) ?? []) {
+		if (done.has(need.name) || need.hidden !== void 0 && node.own?.has(need.hidden) === true) continue;
+		done.add(need.name);
+		if (answered(machine.world, node, need.name)) continue;
+		out.push({
+			code: "#N/A",
+			place: v.place,
+			reason: `No rung gives the attribute ${need.name} of the kind ${node.text}, and ${need.why}.`,
+			at: v.at
+		});
+	}
+	return out;
+}
+/**
+* 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.
+*/
+function readIssue(machine, self, path, rootSelf) {
+	let node = self;
+	let index = 1;
+	while (node !== void 0 && index < path.length && path[index] === "parent") {
+		node = node.parent;
+		index += 1;
+	}
+	const step = path[index];
+	if (node === void 0 || !isKey(step) || Object.hasOwn(STRUCTURAL, String(step))) return void 0;
+	const name = String(step);
+	if (node.own === void 0) {
+		if (node === rootSelf?.node) rootSelf.read(name);
+		return;
+	}
+	return answered(machine.world, node, name) ? void 0 : {
+		index,
+		reason: `No rung gives the attribute ${name} of the kind ${node.text}.`
+	};
+}
+/**
+* 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
+* walked, thus it walks the equations of each kind one time. In an equation, `rootSelf` is the node of the equation.
+*/
+function checkAll(machine, doc, options, nodes, state = {
+	seen: /* @__PURE__ */ new Set(),
+	needs: /* @__PURE__ */ new Map()
+}, rootSelf) {
+	const seen = state.seen;
+	const issues = [];
+	const verb = options.verb ?? "eval";
 	const indices = nodes === void 0 ? void 0 : /* @__PURE__ */ new Map();
 	let current;
 	const push = (issue) => {
@@ -7101,6 +8700,9 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 	const anyName = options.names === "any";
 	const roots = machine.roots ?? ROOTS;
 	const has = (table, name) => table !== void 0 && Object.hasOwn(table, name);
+	const attributes = verb === "eval" && roots.includes("self");
+	const selves = selvesOf(machine, verb, rootSelf?.node);
+	let trees = false;
 	walk(machine.world, doc, (v) => {
 		if (nodes !== void 0 && indices !== void 0) {
 			current = {
@@ -7136,14 +8738,19 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 			});
 			return "skip";
 		}
-		if (v.kind?.tree !== void 0 && !seen.has(v.kind)) {
+		const node = selves.isNode(v, answer.evaluator);
+		if (v.kind !== void 0 && (v.kind.tree !== void 0 || node) && !seen.has(v.kind)) {
 			seen.add(v.kind);
-			for (const issue of equationIssues(machine, v.kind, typeName(v.doc.type), options, seen)) push({
+			const kindText = typeName(v.doc.type);
+			for (const issue of [...contractIssues(v.kind, kindText), ...equationIssues(machine, v.kind, kindText, options, state)]) push({
 				...issue,
 				place: v.place,
 				at: v.at
 			});
 		}
+		const { self, node: here } = selves.enter(v, answer.evaluator);
+		if (here !== void 0) trees = true;
+		if (here?.own !== void 0) for (const issue of nodeIssues(machine, here, state, v)) push(issue);
 		const name = answer.evaluator;
 		if (current !== void 0) current.evaluator = name;
 		const runner = name !== void 0 && has(machine.runners, name);
@@ -7244,6 +8851,15 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 				at: stepAt(1)
 			});
 		}
+		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",
+				place: v.place,
+				reason: issue.reason,
+				at: stepAt(issue.index)
+			});
+		}
 		path.forEach((step, index) => {
 			if (index === 0 || isKey(step)) return;
 			if (walkerOf(machine, step) === void 0) push({
@@ -7256,7 +8872,7 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 	}, {
 		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
 		...Array.isArray(options.names) ? { names: options.names } : {},
-		...options.caps === void 0 ? waits === void 0 ? {} : { caps: EACH$2 } : { caps: options.caps },
+		...options.caps === void 0 ? waits === void 0 ? {} : { caps: EACH$1 } : { caps: options.caps },
 		problem: (problem) => {
 			issues.push({
 				code: problem.code,
@@ -7273,237 +8889,9 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 		issues.splice(drive.index, 0, drive.issue);
 		if (drive.node !== void 0) drive.node.marked = true;
 	}
+	if (trees && rootSelf === void 0) for (const issue of cycleIssues(machine, doc, options)) issues.push(issue);
 	return issues;
 }
-// src/facts.ts
-/** The lazy rules that cover each part: the rules of a document whose evaluator the contract does not describe. */
-const EACH$1 = "each";
-/** An empty list. One frozen list serves each empty list of the facts, thus a store of many facts keeps less (PLAN.LEAN). */
-const NONE = /* @__PURE__ */ Object.freeze([]);
-/**
-* This function gives a list of the facts with no free room. A list that grows by `push` keeps room for more items,
-* thus a copy of a short list is smaller.
-*/
-function tight(list) {
-	return list.length === 0 ? NONE : list.slice();
-}
-/**
-* This function gives the name of the evaluator that the ladder finds for a verb (VERB.LADDER). It also tells if
-* the contract of the kind describes that code. The contract describes the code of its kind for its verb `contract`.
-* An own entry for another evaluator has code that the contract does not describe.
-*/
-function codeOf(world, own, kind, verb, contract) {
-	const found = answerOf(world, own, kind, verb);
-	if (verb !== contract) return {
-		name: found?.name,
-		described: false
-	};
-	if (found?.rung !== "own") return {
-		name: found?.name,
-		described: true
-	};
-	return {
-		name: found.name,
-		described: found.name === answerOf(world, void 0, kind, verb)?.name
-	};
-}
-/** This function gives the position of a part among the parts that a rule covers, by the split of its document. */
-function positionOf(above, parent, rule, slot) {
-	const positions = above.positions ??= /* @__PURE__ */ new Map();
-	let table = positions.get(rule);
-	if (table === void 0) {
-		table = /* @__PURE__ */ new Map();
-		const split = splitParts(parent.kind?.parts, parent.doc.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;
-			table.set(JSON.stringify(part.path), count);
-			count += 1;
-		}
-		positions.set(rule, table);
-	}
-	return table.get(JSON.stringify(slot)) ?? 0;
-}
-/** This function tells if the lazy rules of a document cover one of its parts. */
-function partLazy(above, parent, slot) {
-	const rules = above.rules;
-	if (rules === void 0) return false;
-	if (rules === EACH$1) return true;
-	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 || positionOf(above, parent, rule, slot) >= after) return true;
-	}
-	return false;
-}
-/**
-* This function gives the static facts of a document, for a schedule (R4 P2, D24). It walks the document one time,
-* by the contracts of its kinds:
-*
-* - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
-*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
-*   declares `reads` adds a read of each of its roots at each document of the kind. The first document of a tree
-*   kind also gets the lazy reads of the equations of its kind (FACTS.EQUATIONS). A read from `self` or from a name
-*   of a rung is not one of them, because it is not free (READS.EQUATION).
-* - `side` and `effects`: from the contract of each kind.
-* - `pure`: each kind declares `pure`, also in an equation, and the document has no effect and is not volatile.
-* - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
-*
-* The hook `facts` of the machine answers for a name that a fallback kind covers, for example an operation. Its
-* answer wins over the contract of the kind. The contract of a kind does not describe the evaluator of an own
-* entry. Thus a document with an own entry for another evaluator is not pure, and each of its parts is lazy. The
-* hook can still answer for that evaluator.
-*
-* The option `verb` names the verb whose code the facts describe (FACTS.VERB). A contract describes the code of
-* `eval`, thus the rule of an own entry applies to each document for another verb. The side and the effects come
-* from the contracts for each verb.
-*
-* A read is one resolution of its path. A reference that the resolution reaches and follows is a part of that read
-* (DEREF.COLLAPSE), not a separate read. The facts depend only on the document and the machine. Thus a host computes
-* them again only after an edit of the document or of the machine.
-*
-* @param machine - The world, the code and the hook `facts`.
-* @param doc - The document, as JSON.
-* @param options - The type of a bare root value, the verb and the volatile reads of the host.
-* @returns The facts.
-*/
-function factsOf(machine, doc, options = {}) {
-	const world = machine.world;
-	const hook = machine.facts;
-	const reads = [];
-	const effects = [];
-	const above = /* @__PURE__ */ new Map();
-	let side = "derive";
-	let pure = true;
-	let volatile = false;
-	let size = 0;
-	let seen;
-	const note = (isPure, isVolatile) => {
-		if (isPure !== true) pure = false;
-		if (isVolatile === true) volatile = true;
-	};
-	const add = (read) => {
-		reads.push(read);
-		if (options.volatile?.(read) === true) volatile = true;
-	};
-	/**
-	* This function walks a document. Without `node`, it walks the document of the facts. With `node`, it walks an
-	* equation of a tree kind, and each read gets the place of that node: the first document of the kind.
-	*/
-	const scan = (term, walkOptions, verb, node) => {
-		walk(world, term, (v) => {
-			if (node === void 0) size += 1;
-			const up = v.parent === void 0 ? void 0 : above.get(v.parent);
-			const lazy = node !== void 0 || up !== void 0 && v.parent !== void 0 && (up.lazy || partLazy(up, v.parent, v.slot));
-			const place = node ?? v;
-			const kind = v.kind;
-			if (kind === void 0) {
-				pure = false;
-				above.set(v, {
-					lazy,
-					rules: void 0
-				});
-				return;
-			}
-			const code = codeOf(world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
-			const answer = code.name === void 0 ? void 0 : hook?.(v.typePath ?? [], code.name);
-			let roots;
-			if (code.described) {
-				note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
-				above.set(v, {
-					lazy,
-					rules: answer?.lazy ?? kind.lazy
-				});
-				roots = answer?.reads ?? kind.reads;
-			} else {
-				note(answer?.pure, answer?.volatile);
-				above.set(v, {
-					lazy,
-					rules: answer?.lazy ?? EACH$1
-				});
-				roots = answer?.reads;
-			}
-			for (const root of roots ?? NONE) {
-				if (node !== void 0 && root === "self") continue;
-				add({
-					root,
-					keys: NONE,
-					exact: true,
-					lazy,
-					address: false,
-					path: [root],
-					place: tight(place.place),
-					at: tight(place.at)
-				});
-			}
-			if (kind.side === "run") {
-				if (node === void 0) side = "run";
-				else pure = false;
-			}
-			for (const keys of declaredEffects(v)) {
-				if (node !== void 0) {
-					pure = false;
-					continue;
-				}
-				const text = keys.join(".");
-				if (!effects.includes(text)) effects.push(text);
-			}
-			if (kind.tree !== void 0 && !(seen ??= /* @__PURE__ */ new Set()).has(kind)) {
-				seen.add(kind);
-				const of = equationType(kind);
-				for (const { term: equation, names } of equationsOf(kind)) scan(equation, of === void 0 ? { names } : {
-					names,
-					declaredType: of
-				}, "eval", place);
-			}
-			if (!isRef(v.doc)) return void 0;
-			const path = v.doc.value;
-			const root = path[0];
-			if (typeof root !== "string" || !ROOTS.includes(root)) return void 0;
-			if (node !== void 0 && root === "self") return void 0;
-			let exact = true;
-			const keys = [];
-			for (let index = 1; index < path.length; index += 1) {
-				const step = path[index];
-				if (exact && isKey(step)) {
-					keys.push(step);
-					continue;
-				}
-				exact = false;
-				const found = isEnvelope(step) ? lookupKind(world, step.type) : void 0;
-				if (found?.ok !== true) {
-					pure = false;
-					continue;
-				}
-				const walker = codeOf(world, step.own, found.kind, "step", "step");
-				const stepAnswer = walker.name === void 0 ? void 0 : hook?.(found.path, walker.name);
-				if (walker.described) note(stepAnswer?.pure ?? found.kind.pure, stepAnswer?.volatile ?? found.kind.volatile);
-				else note(stepAnswer?.pure, stepAnswer?.volatile);
-			}
-			const first = path[1];
-			if (root === "names" && isKey(first) && v.names.has(String(first))) return void 0;
-			add({
-				root,
-				keys: tight(keys),
-				exact,
-				lazy,
-				address: v.address === true,
-				path,
-				place: tight(place.place),
-				at: tight(place.at)
-			});
-		}, walkOptions);
-	};
-	scan(doc, options.declaredType === void 0 ? {} : { declaredType: options.declaredType }, options.verb ?? "eval", void 0);
-	return {
-		reads: tight(reads),
-		side,
-		effects: tight(effects),
-		pure: pure && !volatile && effects.length === 0 && side === "derive",
-		volatile,
-		size
-	};
-}
 // src/effects.ts
 /** Each capability: one capability with no keys. It permits each effect, because each kind starts with no keys (CAP.KEYS). */
 const EACH = /* @__PURE__ */ Object.freeze([[]]);
@@ -7721,7 +9109,8 @@ function encodeTerm(value, encoder) {
 *
 * - A value that JSON writes exactly stays as it is. A literal with the shape of an envelope goes into `lit`.
 * - `NaN`, an infinity and `-0` become `ext.number`, and `undefined` becomes `ext.undefined`.
-* - A member of a domain with a codec becomes `ext.domain`. The domains go in the order of their names.
+* - A member of a domain with a codec becomes `ext.domain`. The codec of a domain under another domain comes first
+*   (EXT.SPECIFIC, D109). The order of the names decides between unrelated domains.
 * - A list or a plain record with such a value becomes the construct `list` or `record`.
 *
 * @param machine - The machine, or only its domains.
@@ -7731,20 +9120,38 @@ function encodeTerm(value, encoder) {
 */
 function encodeValue(machine, value) {
 	const domains = machine.domains;
-	const codecs = [];
-	if (domains !== void 0) for (const name of Object.keys(domains).sort()) {
-		const domain = domainOf(name, domains);
-		const codec = domain === void 0 ? void 0 : codecOf(domain);
-		if (codec !== void 0) codecs.push([name, codec]);
-	}
 	return encodeTerm(value, {
 		domains,
-		codecs,
+		codecs: codecOrder(domains),
 		json: /* @__PURE__ */ new WeakMap(),
 		open: /* @__PURE__ */ new Set()
 	});
 }
 /**
+* This function gives the domains with a codec in the order of `encodeValue` (EXT.SPECIFIC, D109). The depth of a
+* domain is the count of the other domains with a codec in its line. A deeper domain comes first, and the order of the
+* names decides between domains of the same depth (EXT.TIE). Thus a domain comes before each domain with a codec above it.
+*/
+function codecOrder(domains) {
+	const codecs = [];
+	if (domains === void 0) return codecs;
+	let parents = false;
+	for (const name of Object.keys(domains).sort()) {
+		const domain = domainOf(name, domains);
+		const codec = domain === void 0 ? void 0 : codecOf(domain);
+		if (domain === void 0 || codec === void 0) continue;
+		codecs.push([name, codec]);
+		if (Array.isArray(domain.under)) parents = true;
+	}
+	if (!parents) return codecs;
+	const depth = /* @__PURE__ */ new Map();
+	for (const [name] of codecs) {
+		const line = lineOf(name, domains);
+		depth.set(name, codecs.filter(([other]) => other !== name && line.has(other)).length);
+	}
+	return codecs.sort(([a], [b]) => depth.get(b) - depth.get(a));
+}
+/**
 * This function reads a document of `encodeValue` again: it evaluates the document as a term, in an empty context.
 * A bare root value is a literal.
 *
@@ -7981,6 +9388,11 @@ function valueType(value) {
 function isSignature(value) {
 	return typeof value === "object" && value !== null && Array.isArray(value.params) && Object.hasOwn(value, "to");
 }
+/** This function tells if two signatures have the same parameters and the same rest parameter. */
+function sameParams(a, b) {
+	if (!docEquals(a.params, b.params)) return false;
+	return a.rest === void 0 ? b.rest === void 0 : b.rest !== void 0 && docEquals(a.rest, b.rest);
+}
 /** This function gives the text of a signature, for the reason of an issue. */
 function signatureText(sig) {
 	const params = sig.params.map(typeText);
@@ -8071,6 +9483,58 @@ function formulaTypes(profile) {
 			bad: sigs.length !== raw.length
 		};
 	};
+	/**
+	* The declarations of the signatures, for `checkWorld` (TYPE.WORLD, D110). Only a record of signatures lists them.
+	* An overload with the parameters of an earlier overload is a problem: the earlier one always fits first.
+	*/
+	const sigsDeclared = () => {
+		const sigs = profile.sigs;
+		if (sigs === void 0 || typeof sigs === "function") return [];
+		const out = [];
+		for (const name of Object.keys(sigs)) {
+			const raw = sigs[name];
+			const list = Array.isArray(raw) ? raw : [raw];
+			list.forEach((sig, index) => {
+				const at = Array.isArray(raw) ? [
+					"sigs",
+					name,
+					index
+				] : ["sigs", name];
+				if (!isSignature(sig)) {
+					out.push({
+						at,
+						problem: `A signature of ops.${name} is not a record with params and to. The check does not read it.`
+					});
+					return;
+				}
+				sig.params.forEach((param, position) => out.push({
+					at: [
+						...at,
+						"params",
+						position
+					],
+					type: param,
+					what: `parameter ${position + 1} of a signature of ops.${name}`
+				}));
+				if (sig.rest !== void 0) out.push({
+					at: [...at, "rest"],
+					type: sig.rest,
+					what: `rest parameter of a signature of ops.${name}`
+				});
+				out.push({
+					at: [...at, "to"],
+					type: sig.to,
+					what: `result of a signature of ops.${name}`
+				});
+				const earlier = list.slice(0, index).findIndex((other) => isSignature(other) && sameParams(other, sig));
+				if (earlier >= 0) out.push({
+					at,
+					problem: `The overload ${index + 1} of ops.${name} has the parameters of the overload ${earlier + 1}. Thus the check never selects it.`
+				});
+			});
+		}
+		return out;
+	};
 	const logic = (word) => ({
 		part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
 		synth: (input) => {
@@ -8215,6 +9679,11 @@ function formulaTypes(profile) {
 			return want.to;
 		} },
 		"formula.if": {
+			declared: () => declared ? [{
+				at: ["truthType"],
+				type: truth,
+				what: "truth type of the profile"
+			}] : [],
 			part: (input, path) => {
 				if (path[0] === "test") return truthPart(input, "test of if");
 				return isUnknown(input.expected, input.machine.domains) ? {} : {
@@ -8231,6 +9700,7 @@ function formulaTypes(profile) {
 		"formula.and": logic("and"),
 		"formula.or": logic("or"),
 		"formula.op": {
+			declared: sigsDeclared,
 			part: (input, path) => {
 				const read = signatures(input);
 				if (read === void 0 || read.sigs.length !== 1) return {};
@@ -8268,19 +9738,31 @@ function formulaTypes(profile) {
 				return fitting.every((sig) => docEquals(sig.to, first.to)) ? first.to : "unknown";
 			}
 		},
-		"formula.ext": { synth: (input) => {
-			const name = nameOf(input);
-			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) {
+		"formula.ext": {
+			declared: () => {
 				const types = profile.extTypes;
-				const declared = types !== void 0 && Object.hasOwn(types, name) ? types[name] : void 0;
-				if (declared === void 0) return "unknown";
-				const type = input.contract(declared, `type of ext.${name} in extTypes`);
-				return typeIssues(type, input.machine.domains).length > 0 ? "unknown" : type;
+				const own = profile.ext;
+				if (types === void 0 || own === void 0) return [];
+				return Object.keys(types).filter((name) => Object.hasOwn(own, name)).map((name) => ({
+					at: ["extTypes", name],
+					type: types[name],
+					what: `type of ext.${name} in extTypes`
+				}));
+			},
+			synth: (input) => {
+				const name = nameOf(input);
+				if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) {
+					const types = profile.extTypes;
+					const declared = types !== void 0 && Object.hasOwn(types, name) ? types[name] : void 0;
+					if (declared === void 0) return "unknown";
+					const type = input.contract(declared, `type of ext.${name} in extTypes`);
+					return typeIssues(type, input.machine.domains).length > 0 ? "unknown" : type;
+				}
+				if (name === "undefined") return "undefined";
+				if (name === "number") return "number";
+				return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
 			}
-			if (name === "undefined") return "undefined";
-			if (name === "number") return "number";
-			return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
-		} }
+		}
 	};
 }
 /**
@@ -13803,707 +15285,532 @@ function checkTruth(env, code, probe) {
 	const truth = declaredTruthOf(code);
 	if (truth === void 0) return;
 	const domains = env.machine.domains;
-	if (typeIssues(truth.truthType, domains).length > 0) return;
-	const samples = env.results.flatMap((result) => result.ok ? [result.value] : []);
-	const of = (value) => `the member ${valueText(value)} of the truth type ${typeText(truth.truthType)}`;
-	for (const value of membersOf(truth.truthType, domains, samples)) {
-		let given;
-		try {
-			given = truth.truthy(value);
-		} catch (error) {
-			report(env, "truth", `The function truthy of the profile throws for ${of(value)}: ${describe(error)}`, () => probe(value));
-			return;
-		}
-		if (typeof given === "boolean") continue;
-		report(env, "truth", `The function truthy of the profile gives ${given === void 0 ? "no truth" : valueText(given)} for ${of(value)}. A truth is true or false.`, () => probe(value));
-		return;
-	}
-}
-/**
-* This function checks the covers of the domains of the machine from samples (D94). Each sample of a covered domain
-* must be in one domain of each valid cover. The samples of a domain come from its list `values`. A domain without
-* that list gets its members from the palette and from the samples of the domains, as for the check `truth`.
-*/
-function checkCovers(env, probe) {
-	const domains = env.machine.domains;
-	if (domains === void 0) return;
-	const palette = env.results.flatMap((result) => result.ok ? [result.value] : []);
-	const samples = {};
-	for (const [name, domain] of Object.entries(domains)) if (domain.covers !== void 0) samples[name] = membersOf(name, domains, palette);
-	const found = falseCovers(domains, samples)[0];
-	if (found === void 0) return;
-	report(env, "cover", `The member ${valueText(found.value)} of the domain ${found.domain} is in no domain of its cover ${found.cover.join(", ")}. The check of types trusts the cover, thus it is unsound for ${found.domain}.`, () => probe(found.value));
-}
-/**
-* This function examines one evaluator or runner of a machine against the obligations of host code (K92, D36). It
-* starts the code directly, without the kernel, with probe parts and a probe runtime. It generates probe documents from
-* the contract of each kind that names the code, and it gives the probe parts chosen and random results.
-*
-* The checks follow the obligations C1 to C8 of `docs/SEMANTICS.md`. Two more checks follow the premises of the
-* simulation of the plan. The check `local` finds state that stays from one call to the next. The check `agree` compares
-* compiled code with its definition. The finding of an obligation names the first probe that breaks it. An empty list
-* means that each probe conforms.
-*
-* The check `truth` tests the declared truth of a formula profile (D86). The check `cover` tests the covers of the
-* domains of the machine from samples (D94).
-*
-* @param machine - The machine with the code and the world of the kinds.
-* @param name - The name of the evaluator or of the runner. A runner wins over an evaluator of the same name.
-* @param options - The verb, the types and the values of the probe documents, and the results of the probe parts. Also
-*   the definitions, the capabilities, the names, the seed, the mock and the rule of equality.
-* @returns The first finding of each obligation that the code breaks, in the order of the obligations.
-* @throws {Error} The machine has no code with the name, or no kind names it and the options give no types.
-*/
-function conforms(machine, name, options = {}) {
-	const verb = options.verb ?? "eval";
-	const runnerCode = own(machine.runners, name);
-	const code = runnerCode ?? own(machine.evaluators, name);
-	if (code === void 0) throw new Error(`The machine has no evaluator and no runner with the name ${name}.`);
-	const runner = runnerCode !== void 0;
-	const env = {
-		machine,
-		name,
-		verb,
-		under: underOf(code, runner),
-		definition: definitionOf(machine, name, runner, options.definitions),
-		runner,
-		results: options.results ?? RESULTS,
-		names: options.names ?? NAMES,
-		runs: options.runs ?? 12,
-		random: random(options.seed ?? 1),
-		perform: options.perform,
-		equal: options.equal,
-		found: /* @__PURE__ */ new Map()
-	};
-	const types = options.types ?? typesNaming(machine.world, name, verb);
-	let first;
-	if (types.length === 0) throw new Error(`No kind of the world names ${name} for the verb ${verb}. Give the types of the probe documents in the option types.`);
-	for (const type of types) {
-		const found = lookupKind(machine.world, type);
-		if (!found.ok) throw new Error(`The world has no kind for the type ${typeName(type)}.`);
-		const contract = contractOf(env, found.kind, found.path, options.caps);
-		const extra = own(options.values, typeName(type)) ?? own(options.values, found.path.join(".")) ?? [];
-		for (const sample of samplesOf(type, found.path, found.kind, contract, extra)) {
-			first ??= sample;
-			examine(env, sample, contract);
-		}
-	}
-	const probeWith = (value) => first === void 0 ? {
-		type: typeName(types[0]),
-		doc: {
-			type: types[0],
-			value: null
-		},
-		results: {},
-		waits: [],
-		caps: NO_CAPS,
-		running: runner
-	} : probeOf(first, {
-		results: first.split.parts.map(() => ok(value)),
-		waits: [],
-		caps: NO_CAPS,
-		running: runner
-	});
-	checkTruth(env, code, probeWith);
-	checkCovers(env, probeWith);
-	return ORDER.filter((obligation) => env.found.has(obligation)).map((obligation) => env.found.get(obligation));
-}
-// src/same.ts
-/**
-* This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
-* work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
-* only costs work. Thus each rule gives `false` when it is not sure.
-*
-* - Two values compare by the rules of `docEquals`. Lists and plain records compare by their items and fields. Each
-*   other value compares with `Object.is`.
-* - Thus `-0` is not `0`, and `NaN` is `NaN`. A date, a map and a closure of `fn` are the same only as themselves.
-* - Two errors are the same when they have the same code, reason and place (RESULT.SAME-ERROR). The cause is not
-*   compared. A `Held` value compares its error by the same rule.
-* - A value and an error are not the same.
-*
-* `sameValue` of `agree` uses the same walk, with rules for two tiers (D20). It compares two closures by their
-* parameters, and two errors by their code and place.
-*
-* @param a - The earlier result.
-* @param b - The new result.
-* @param equal - The rule of the host for two values, for example two dates. It answers first, and `undefined` gives the rules above.
-* @returns `true` when the results are the same.
-*/
-function sameResult(a, b, equal) {
-	if (a.ok && b.ok) return equalWith(a.value, b.value, equal === void 0 ? sameHeld : (x, y) => equal(x, y) ?? sameHeld(x, y));
-	if (!a.ok && !b.ok) return sameError(a.error, b.error);
-	return false;
-}
-/** The rule of `sameResult` for held errors. Two `Held` values are the same when their errors are the same. */
-function sameHeld(x, y) {
-	if (x instanceof Held || y instanceof Held) return x instanceof Held && y instanceof Held && sameError(x.error, y.error);
-}
-/** Two errors are the same when they have the same code, reason and place. An error without a place has no place in both. */
-function sameError(a, b) {
-	if (a.code !== b.code || a.reason !== b.reason) return false;
-	if (a.place === void 0 || b.place === void 0) return a.place === b.place;
-	return docEquals(a.place, b.place);
-}
-// src/reads.ts
-/** One answer serves each list whose reads are all the same. */
-const SAME = /* @__PURE__ */ Object.freeze({ same: true });
-/** This function tells if two lists of hops are the same: the same steps, rungs and things, in order. */
-function sameHops(a, b, equal) {
-	if (b === void 0 || a.length !== b.length) return false;
-	for (let index = 0; index < a.length; index += 1) {
-		const x = a[index];
-		const y = b[index];
-		if (x.by !== y.by || !docEquals(x.step, y.step) || !sameResult(ok(x.thing), ok(y.thing), equal)) return false;
-	}
-	return true;
-}
-/**
-* This function gives the error of a name that holds a held error and stops a longer path, or `undefined`. A
-* reference of the formula kit tests the binding of its first name before it resolves the rest of the path
-* (FORMULA.LET). The resolution of the whole path does not show that test.
-*/
-function heldStop(root, path) {
-	const name = path[1];
-	if (path.length <= 2 || path[0] !== "names" || typeof name !== "string" || !Object.hasOwn(root.names, name)) return void 0;
-	const bound = root.names[name];
-	return bound instanceof Held ? {
-		ok: false,
-		error: bound.error
-	} : void 0;
-}
-/**
-* This function tells if an old result stays valid in a new context (READS.VERIFY, D26). It resolves the path of
-* each free read again, in the order of the list, and it compares what the path reaches with `sameResult`. It stops at
-* the first read that reaches another thing, and it gives that read (READS.CHANGED).
-*
-* - A read that is not free reads a binding that a kind made from earlier reads, for example a name of `let`. The
-*   function does not resolve it again.
-* - A thing compares as in `sameResult`. Thus a host thing or a date is the same only as itself. A host gives a new
-*   object for a new state, or the option `equal`.
-* - A longer path through a name that holds a `Held` in the new context is a changed read. A reference of the formula
-*   kit gives the error of that binding, and the resolution of the path does not show it.
-* - The answer is sound only for a pure document (FACTS.PURE). A document with an effect, a volatile operation or an
-*   extension of a profile can read outside `resolve`. The schedule asks `factsOf` first.
-*
-* The values of the context must not change in place, as PLAN.CACHE says for the documents. A value that changed in
-* place is the same object, thus the function cannot see the change.
-*
-* @param target - The machine of the evaluation, or its plan.
-* @param reads - The reads of the evaluation, from the option `reads`.
-* @param context - The new context.
-* @param options - The rule of the host for two things.
-* @returns `{ same: true }` when each free read reaches the same thing, or else the first changed read.
-*/
-function verifyReads(target, reads, context, options = {}) {
-	const machine = "evaluators" in target ? target : target.machine;
-	const root = rootContext(machine, context);
-	const equal = options.equal;
-	for (let index = 0; index < reads.length; index += 1) {
-		const read = reads[index];
-		if (!read.free) continue;
-		const stop = heldStop(root, read.path);
-		if (stop !== void 0) return {
-			same: false,
-			index,
-			read,
-			now: stop
-		};
-		if (read.kept === true) {
-			const now = keptAgain(machine, root, read.path);
-			if (now === void 0) return {
-				same: false,
-				index,
-				read,
-				now: fail("#N/A", "The host does not know the value of the kept read yet.")
-			};
-			if (!sameResult(read.reached, now, equal)) return {
-				same: false,
-				index,
-				read,
-				now
-			};
-			continue;
-		}
-		const asked = read.hops !== void 0;
-		const now = readAgain(machine, root, read.path, asked);
-		if (!sameResult(read.reached, now.reached, equal) || read.hops !== void 0 && !sameHops(read.hops, now.hops, equal)) return {
-			same: false,
-			index,
-			read,
-			now: now.reached
-		};
-	}
-	return SAME;
-}
-// src/durable.ts
-/** The most values that a cache of value documents keeps, as in `planner`. */
-const MAX_VALUES = 1e3;
-/** No reads. One frozen list serves each result of a pure document without reads. */
-const NO_READS = /* @__PURE__ */ Object.freeze([]);
-/** The key of the document `-0` in a cache of value documents. A `Map` finds the entry of `0` for `-0`. */
-const NEGATIVE_ZERO = /* @__PURE__ */ Symbol("coeval.negative-zero");
-/** This function makes a cache by document. A document object gives its value one time, as PLAN.CACHE says. */
-function byDocument(make) {
-	const objects = /* @__PURE__ */ new WeakMap();
-	const values = /* @__PURE__ */ new Map();
-	return (doc) => {
-		if (typeof doc === "object" && doc !== null) {
-			if (objects.has(doc)) return objects.get(doc);
-			const made = make(doc);
-			objects.set(doc, made);
-			return made;
+	if (typeIssues(truth.truthType, domains).length > 0) return;
+	const samples = env.results.flatMap((result) => result.ok ? [result.value] : []);
+	const of = (value) => `the member ${valueText(value)} of the truth type ${typeText(truth.truthType)}`;
+	for (const value of membersOf(truth.truthType, domains, samples)) {
+		let given;
+		try {
+			given = truth.truthy(value);
+		} catch (error) {
+			report(env, "truth", `The function truthy of the profile throws for ${of(value)}: ${describe(error)}`, () => probe(value));
+			return;
 		}
-		const key = Object.is(doc, -0) ? NEGATIVE_ZERO : doc;
-		if (values.has(key)) return values.get(key);
-		const made = make(doc);
-		if (values.size >= MAX_VALUES) values.clear();
-		values.set(key, made);
-		return made;
-	};
+		if (typeof given === "boolean") continue;
+		report(env, "truth", `The function truthy of the profile gives ${given === void 0 ? "no truth" : valueText(given)} for ${of(value)}. A truth is true or false.`, () => probe(value));
+		return;
+	}
 }
 /**
-* This function makes a cache with two levels of durability for a host or a schedule (R4 P7, D30). The structure is
-* the machine and the documents. The data is each value that a context gives: the names, `self`, `event`, the
-* capabilities and the world of the host.
+* This function checks the covers of the domains of the machine from samples (D94). Each sample of a covered domain
+* must be in one domain of each valid cover. The samples of a domain come from its list `values`. A domain without
+* that list gets its members from the palette and from the samples of the domains, as for the check `truth`.
+*/
+function checkCovers(env, probe) {
+	const domains = env.machine.domains;
+	if (domains === void 0) return;
+	const palette = env.results.flatMap((result) => result.ok ? [result.value] : []);
+	const samples = {};
+	for (const [name, domain] of Object.entries(domains)) if (domain.covers !== void 0) samples[name] = membersOf(name, domains, palette);
+	const found = falseCovers(domains, samples)[0];
+	if (found === void 0) return;
+	report(env, "cover", `The member ${valueText(found.value)} of the domain ${found.domain} is in no domain of its cover ${found.cover.join(", ")}. The check of types trusts the cover, thus it is unsound for ${found.domain}.`, () => probe(found.value));
+}
+/**
+* This function examines one evaluator or runner of a machine against the obligations of host code (K92, D36). It
+* starts the code directly, without the kernel, with probe parts and a probe runtime. It generates probe documents from
+* the contract of each kind that names the code, and it gives the probe parts chosen and random results.
 *
-* - A plan and the facts depend only on the structure. A document object compiles one time for a machine, thus a
-*   change of data compiles nothing (DURABLE.DATA).
-* - A result depends on the data too. It stays in its data epoch. After a change of data, a pure document verifies
-*   its reads with `verifyReads`, and each other document evaluates again.
-* - An edit gives a new document object, thus only that document compiles. A new machine drops each plan, each fact
-*   and each result (DURABLE.STRUCTURE).
+* The checks follow the obligations C1 to C8 of `docs/SEMANTICS.md`. Two more checks follow the premises of the
+* simulation of the plan. The check `local` finds state that stays from one call to the next. The check `agree` compares
+* compiled code with its definition. The finding of an obligation names the first probe that breaks it. An empty list
+* means that each probe conforms.
 *
-* The host keeps two promises. In one data epoch, the context of a key gives the same data. The values of a
-* context and the documents do not change in place, as PLAN.CACHE and `verifyReads` say.
+* The check `truth` tests the declared truth of a formula profile (D86). The check `cover` tests the covers of the
+* domains of the machine from samples (D94).
 *
-* @param machine - The machine of the first structure epoch.
-* @param options - The type of a bare root value, the verb, the volatile reads and the rule of the host for two things.
-* @returns The cache.
+* @param machine - The machine with the code and the world of the kinds.
+* @param name - The name of the evaluator or of the runner. A runner wins over an evaluator of the same name.
+* @param options - The verb, the types and the values of the probe documents, and the results of the probe parts. Also
+*   the definitions, the capabilities, the names, the seed, the mock and the rule of equality.
+* @returns The first finding of each obligation that the code breaks, in the order of the obligations.
+* @throws {Error} The machine has no code with the name, or no kind names it and the options give no types.
 */
-function durable(machine, options = {}) {
-	const prepareOptions = {
-		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
-		...options.verb === void 0 ? {} : { verb: options.verb }
-	};
-	const factsOptions = {
-		...prepareOptions,
-		...options.volatile === void 0 ? {} : { volatile: options.volatile }
-	};
-	const verifyOptions = options.equal === void 0 ? {} : { equal: options.equal };
-	const counts = {
-		compiles: 0,
-		facts: 0,
-		evaluations: 0,
-		verifications: 0,
-		reuses: 0
-	};
-	const results = /* @__PURE__ */ new Map();
-	let current = machine;
-	let epochs = {
-		structure: 0,
-		data: 0
-	};
-	const plansOf = (m) => byDocument((doc) => {
-		counts.compiles += 1;
-		return prepare(m, doc, prepareOptions);
-	});
-	const factsFor = (m) => byDocument((doc) => {
-		counts.facts += 1;
-		return factsOf(m, doc, factsOptions);
-	});
-	let plans = plansOf(machine);
-	let facts = factsFor(machine);
-	return {
-		get machine() {
-			return current;
-		},
-		get epochs() {
-			return epochs;
-		},
-		get counts() {
-			return { ...counts };
-		},
-		plan: (doc) => plans(doc),
-		facts: (doc) => facts(doc),
-		evaluate(key, doc, context) {
-			const plan = plans(doc);
-			const entry = results.get(key);
-			if (entry !== void 0 && entry.plan === plan) {
-				if (entry.data === epochs.data) {
-					counts.reuses += 1;
-					return entry.result;
-				}
-				if (entry.reads !== void 0) {
-					counts.verifications += 1;
-					if (verifyReads(plan, entry.reads, context, verifyOptions).same) {
-						entry.data = epochs.data;
-						counts.reuses += 1;
-						return entry.result;
-					}
-				}
-			}
-			const reads = facts(doc).pure ? [] : void 0;
-			counts.evaluations += 1;
-			const result = plan.evaluate(context, reads === void 0 ? void 0 : { reads });
-			results.set(key, {
-				plan,
-				result,
-				reads: reads === void 0 ? void 0 : reads.length === 0 ? NO_READS : reads.slice(),
-				data: epochs.data
-			});
-			return result;
-		},
-		changeData() {
-			epochs = {
-				structure: epochs.structure,
-				data: epochs.data + 1
-			};
-		},
-		changeStructure(next) {
-			epochs = {
-				structure: epochs.structure + 1,
-				data: epochs.data + 1
-			};
-			if (next === void 0 || next === current) return;
-			current = next;
-			plans = plansOf(next);
-			facts = factsFor(next);
-			results.clear();
-		},
-		forget(key) {
-			results.delete(key);
-		}
+function conforms(machine, name, options = {}) {
+	const verb = options.verb ?? "eval";
+	const runnerCode = own(machine.runners, name);
+	const code = runnerCode ?? own(machine.evaluators, name);
+	if (code === void 0) throw new Error(`The machine has no evaluator and no runner with the name ${name}.`);
+	const runner = runnerCode !== void 0;
+	const env = {
+		machine,
+		name,
+		verb,
+		under: underOf(code, runner),
+		definition: definitionOf(machine, name, runner, options.definitions),
+		runner,
+		results: options.results ?? RESULTS,
+		names: options.names ?? NAMES,
+		runs: options.runs ?? 12,
+		random: random(options.seed ?? 1),
+		perform: options.perform,
+		equal: options.equal,
+		found: /* @__PURE__ */ new Map()
 	};
-}
-// src/graph.ts
-/** This function gives the indexed form of a graph, with the edges that the options keep. */
-function indexed(graph, options) {
-	const eager = options.eager === true;
-	const ids = [...graph.keys()];
-	const count = ids.length;
-	const numbers = /* @__PURE__ */ new Map();
-	const sink = new Uint8Array(count);
-	ids.forEach((id, index) => {
-		numbers.set(id, index);
-		if (graph.get(id)?.side === "run") sink[index] = 1;
-	});
-	const start = new Int32Array(count + 2);
-	const targets = [];
-	let unknown = false;
-	let from = 0;
-	for (const node of graph.values()) {
-		start[from] = targets.length;
-		for (const edge of node.edges) {
-			if (eager && edge.lazy) continue;
-			if (edge.to === void 0) {
-				if (eager) continue;
-				unknown = true;
-				targets.push(count);
-				continue;
-			}
-			const to = numbers.get(edge.to);
-			if (to !== void 0 && sink[to] === 0) targets.push(to);
+	const types = options.types ?? typesNaming(machine.world, name, verb);
+	let first;
+	if (types.length === 0) throw new Error(`No kind of the world names ${name} for the verb ${verb}. Give the types of the probe documents in the option types.`);
+	for (const type of types) {
+		const found = lookupKind(machine.world, type);
+		if (!found.ok) throw new Error(`The world has no kind for the type ${typeName(type)}.`);
+		const contract = contractOf(env, found.kind, found.path, options.caps);
+		const extra = own(options.values, typeName(type)) ?? own(options.values, found.path.join(".")) ?? [];
+		for (const sample of samplesOf(type, found.path, found.kind, contract, extra)) {
+			first ??= sample;
+			examine(env, sample, contract);
 		}
-		from += 1;
-	}
-	start[count] = targets.length;
-	if (unknown) {
-		for (let to = 0; to < count; to += 1) if (sink[to] === 0) targets.push(to);
 	}
-	start[count + 1] = targets.length;
-	return {
-		ids,
-		size: unknown ? count + 1 : count,
-		start,
-		targets: Int32Array.from(targets),
-		all: unknown ? count : -1
-	};
+	const probeWith = (value) => first === void 0 ? {
+		type: typeName(types[0]),
+		doc: {
+			type: types[0],
+			value: null
+		},
+		results: {},
+		waits: [],
+		caps: NO_CAPS,
+		running: runner
+	} : probeOf(first, {
+		results: first.split.parts.map(() => ok(value)),
+		waits: [],
+		caps: NO_CAPS,
+		running: runner
+	});
+	checkTruth(env, code, probeWith);
+	checkCovers(env, probeWith);
+	return ORDER.filter((obligation) => env.found.has(obligation)).map((obligation) => env.found.get(obligation));
+}
+// src/same.ts
+/**
+* This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
+* work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
+* only costs work. Thus each rule gives `false` when it is not sure.
+*
+* - Two values compare by the rules of `docEquals`. Lists and plain records compare by their items and fields. Each
+*   other value compares with `Object.is`.
+* - Thus `-0` is not `0`, and `NaN` is `NaN`. A date, a map and a closure of `fn` are the same only as themselves.
+* - Two errors are the same when they have the same code, reason and place (RESULT.SAME-ERROR). The cause is not
+*   compared. A `Held` value compares its error by the same rule.
+* - A value and an error are not the same.
+*
+* `sameValue` of `agree` uses the same walk, with rules for two tiers (D20). It compares two closures by their
+* parameters, and two errors by their code and place.
+*
+* @param a - The earlier result.
+* @param b - The new result.
+* @param equal - The rule of the host for two values, for example two dates. It answers first, and `undefined` gives the rules above.
+* @returns `true` when the results are the same.
+*/
+function sameResult(a, b, equal) {
+	if (a.ok && b.ok) return equalWith(a.value, b.value, equal === void 0 ? sameHeld : (x, y) => equal(x, y) ?? sameHeld(x, y));
+	if (!a.ok && !b.ok) return sameError(a.error, b.error);
+	return false;
 }
-/**
-* This function finds the strongly connected components with the algorithm of Tarjan. It keeps its own stack of
-* calls in two arrays, thus a long chain does not overflow the stack of the host. Each component comes after each
-* component that its nodes reach: the deepest component comes first.
+/** The rule of `sameResult` for held errors. Two `Held` values are the same when their errors are the same. */
+function sameHeld(x, y) {
+	if (x instanceof Held || y instanceof Held) return x instanceof Held && y instanceof Held && sameError(x.error, y.error);
+}
+/** Two errors are the same when they have the same code, reason and place. An error without a place has no place in both. */
+function sameError(a, b) {
+	if (a.code !== b.code || a.reason !== b.reason) return false;
+	if (a.place === void 0 || b.place === void 0) return a.place === b.place;
+	return docEquals(a.place, b.place);
+}
+// src/reads.ts
+/** One answer serves each list whose reads are all the same. */
+const SAME = /* @__PURE__ */ Object.freeze({ same: true });
+/** The default limit of the entries in the print of one value. */
+const PRINT_LIMIT = 1e4;
+/** The marks of a print. Each mark is a private object, thus no value of a host is the same as a mark. */
+const OBJECT = /* @__PURE__ */ Object.freeze({ mark: "object" });
+const LIST = /* @__PURE__ */ Object.freeze({ mark: "list" });
+const DATE = /* @__PURE__ */ Object.freeze({ mark: "date" });
+const MAP = /* @__PURE__ */ Object.freeze({ mark: "map" });
+const SET = /* @__PURE__ */ Object.freeze({ mark: "set" });
+const SEEN = /* @__PURE__ */ Object.freeze({ mark: "seen" });
+const STAMP = /* @__PURE__ */ Object.freeze({ mark: "stamp" });
+/** The print of a value that the walk cannot finish: it is too large, or the host threw. It is not the same as any print. */
+const NO_PRINT = /* @__PURE__ */ Object.freeze([]);
+/**
+* This function gives the print of a value: a flat list of its parts, in the order of a walk (D112). Two prints are
+* the same when they have the same length, and each entry is the same by `Object.is`.
+*
+* - An object starts with a mark and its prototype. A list adds its length, a date its time, and a map or a set
+*   its size and its entries. Then come the count of the own enumerable fields, each name and the kind of each field.
+* - A field with a getter gives the getter function. The walk does not start host code of a field.
+* - A primitive value and a function are entries. A function compares by its identity.
+* - An object that the walk already visited gives the mark `SEEN` and its number. Thus a cycle ends.
+* - A value with more than `limit` entries, or an exception of the host, gives `NO_PRINT`.
+*
+* @param value - The value of a read.
+* @param options - The limit and the stamp of the host.
+* @returns The print.
 */
-function strong(graph) {
-	const { size, start, targets } = graph;
-	const order = new Int32Array(size).fill(-1);
-	const low = new Int32Array(size);
-	const of = new Int32Array(size).fill(-1);
-	const open = new Int32Array(size);
-	const onOpen = new Uint8Array(size);
-	const calls = new Int32Array(size);
-	const next = new Int32Array(size);
-	const list = [];
-	let top = 0;
-	let count = 0;
-	const enter = (node, depth) => {
-		order[node] = count;
-		low[node] = count;
-		count += 1;
-		open[top] = node;
-		top += 1;
-		onOpen[node] = 1;
-		calls[depth] = node;
-		next[depth] = start[node];
-	};
-	for (let root = 0; root < size; root += 1) {
-		if (order[root] !== -1) continue;
-		enter(root, 0);
-		let depth = 1;
-		while (depth > 0) {
-			const node = calls[depth - 1];
-			const edge = next[depth - 1];
-			if (edge < start[node + 1]) {
-				next[depth - 1] = edge + 1;
-				const to = targets[edge];
-				if (order[to] === -1) {
-					enter(to, depth);
-					depth += 1;
-				} else if (onOpen[to] === 1 && order[to] < low[node]) low[node] = order[to];
+function printOf(value, options) {
+	const limit = options.limit ?? PRINT_LIMIT;
+	const stamp = options.stamp;
+	const out = [];
+	const ids = /* @__PURE__ */ new Map();
+	const stack = [value];
+	try {
+		while (stack.length > 0) {
+			if (out.length > limit) return NO_PRINT;
+			const x = stack.pop();
+			if (typeof x !== "object" || x === null) {
+				out.push(x);
 				continue;
 			}
-			depth -= 1;
-			if (low[node] === order[node]) {
-				const members = [];
-				let member;
-				do {
-					top -= 1;
-					member = open[top];
-					onOpen[member] = 0;
-					of[member] = list.length;
-					members.push(member);
-				} while (member !== node);
-				list.push(members.sort((a, b) => a - b));
+			const id = ids.get(x);
+			if (id !== void 0) {
+				out.push(SEEN, id);
+				continue;
 			}
-			if (depth > 0) {
-				const reader = calls[depth - 1];
-				if (low[node] < low[reader]) low[reader] = low[node];
+			ids.set(x, ids.size);
+			const stamped = stamp?.(x);
+			if (stamped !== void 0) {
+				out.push(STAMP, stamped);
+				continue;
+			}
+			const children = [];
+			out.push(OBJECT, Object.getPrototypeOf(x));
+			if (Array.isArray(x)) out.push(LIST, x.length);
+			else if (x instanceof Date) out.push(DATE, Date.prototype.getTime.call(x));
+			else if (x instanceof Map) {
+				out.push(MAP, x.size);
+				if (out.length + 2 * x.size > limit) return NO_PRINT;
+				for (const [key, item] of Map.prototype.entries.call(x)) children.push(key, item);
+			} else if (x instanceof Set) {
+				out.push(SET, x.size);
+				if (out.length + x.size > limit) return NO_PRINT;
+				for (const item of Set.prototype.values.call(x)) children.push(item);
+			}
+			const keys = Object.keys(x);
+			if (out.length + 3 * keys.length > limit) return NO_PRINT;
+			out.push(keys.length);
+			for (const key of keys) {
+				const field = Object.getOwnPropertyDescriptor(x, key);
+				const data = field === void 0 || "value" in field;
+				out.push(key, data);
+				children.push(field === void 0 ? void 0 : "value" in field ? field.value : field.get);
 			}
+			for (let index = children.length - 1; index >= 0; index -= 1) stack.push(children[index]);
 		}
+	} catch {
+		return NO_PRINT;
 	}
-	return {
-		of,
-		list
-	};
-}
-/** This function tells if a component has a cycle: two or more nodes, or one node with an edge to itself. */
-function cyclic(graph, members) {
-	if (members.length > 1) return true;
-	const node = members[0];
-	for (let edge = graph.start[node]; edge < graph.start[node + 1]; edge += 1) if (graph.targets[edge] === node) return true;
-	return false;
+	return out.length > limit ? NO_PRINT : out;
 }
-/** This function gives the names of the nodes of a component, without the node `all`. */
-function named$1(graph, members) {
-	const out = [];
-	for (const member of members) if (member !== graph.all) out.push(graph.ids[member]);
-	return out;
+/** This function tells if two prints are the same. `NO_PRINT` is not the same as any print, also not as itself. */
+function samePrint(a, b) {
+	if (a === NO_PRINT || b === NO_PRINT || a.length !== b.length) return false;
+	for (let index = 0; index < a.length; index += 1) if (!Object.is(a[index], b[index])) return false;
+	return true;
 }
-/** This function gives the height of each component, in the order of `strong`. The node `all` adds no height. */
-function heightsOf(graph, found) {
-	const { start, targets } = graph;
-	const heights = new Int32Array(found.list.length);
-	found.list.forEach((members, component) => {
-		let highest = -1;
-		let real = false;
-		for (const node of members) {
-			if (node !== graph.all) real = true;
-			for (let edge = start[node]; edge < start[node + 1]; edge += 1) {
-				const other = found.of[targets[edge]];
-				if (other !== component && heights[other] > highest) highest = heights[other];
-			}
-		}
-		heights[component] = real ? highest + 1 : highest;
-	});
-	return heights;
+/** This function gives the print of the value of a result, or `undefined` when the value holds no object. */
+function printOfResult(result, options, cache) {
+	if (!result.ok || typeof result.value !== "object" || result.value === null) return void 0;
+	const value = result.value;
+	let print = cache.get(value);
+	if (print === void 0) {
+		print = printOf(value, options);
+		cache.set(value, print);
+	}
+	return print;
 }
 /**
-* This function gives the strongly connected components of a graph of nodes (GRAPH.SCC), with the algorithm of
-* Tarjan. It keeps its own stack, thus a chain of 100000 nodes does not overflow the stack of the host.
+* This function gives the prints of the values of a list of reads (READS.IN-PLACE, D112). A host starts it after
+* the evaluation, and it gives the prints to `verifyReads` with the option `prints`.
 *
-* - Each component comes after each component that it reads: the deepest component comes first.
-* - A node that is on no cycle is a component of one node.
-* - The nodes of a component are in the order of the graph.
+* - The print of a value walks its lists, its plain records and the own enumerable fields of each other object. A
+*   date adds its time, and a map or a set adds its entries.
+* - A read that is not free, a read that reached an error and a read with a primitive value get no print.
+* - A cycle ends, because the walk visits each object one time.
+* - A value with more entries than the limit gets no print. `verifyReads` then gives that read as changed.
 *
-* @param graph - The nodes, each with its edges.
-* @param options - The option `eager` keeps only the eager edges with a target node.
-* @returns The components, deepest first.
+* The walk does not see the state in a closure or a private field. It does not see a field with a symbol name, a
+* field that is not enumerable or the value of a getter. A host gives a stamp for such an object, for example its version.
+*
+* @param reads - The reads of the evaluation, from the option `reads`.
+* @param options - The limit and the stamp of the host.
+* @returns The prints, for the option `prints` of `verifyReads`.
 */
-function components(graph, options = {}) {
-	const index = indexed(graph, options);
-	const out = [];
-	for (const members of strong(index).list) {
-		const names = named$1(index, members);
-		if (names.length > 0) out.push(names);
+function printReads(reads, options = {}) {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		prints: reads.map((read) => read.free ? printOfResult(read.reached, options, cache) : void 0),
+		options
+	};
+}
+/** This function tells if the print of a read changed, when the read has a print. */
+function changedInPlace(prints, index, now, cache) {
+	const old = prints.prints[index];
+	if (old === void 0) return false;
+	const print = printOfResult(now, prints.options, cache);
+	return print === void 0 || !samePrint(old, print);
+}
+/** This function tells if two lists of hops are the same: the same steps, rungs and things, in order. */
+function sameHops(a, b, equal) {
+	if (b === void 0 || a.length !== b.length) return false;
+	for (let index = 0; index < a.length; index += 1) {
+		const x = a[index];
+		const y = b[index];
+		if (x.by !== y.by || !docEquals(x.step, y.step) || !sameResult(ok(x.thing), ok(y.thing), equal)) return false;
 	}
-	return out;
+	return true;
 }
 /**
-* This function gives the height of each node: the order of a push schedule (GRAPH.ORDER). A schedule that evaluates
-* the nodes from the lowest height up evaluates each node after each node that it reads, except on a cycle.
-*
-* - A node that reads no node outside its component has the height 0.
-* - Each other node is one higher than the highest node that it reads outside its component.
-* - The nodes of one component have one height.
-* - An edge without a target reads each node that is not a sink (GRAPH.UNKNOWN).
-*
-* @param graph - The nodes, each with its edges.
-* @param options - The option `eager` keeps only the eager edges with a target node.
-* @returns The height of each node, in the order of the graph.
+* This function gives the error of a name that holds a held error and stops a longer path, or `undefined`. A
+* reference of the formula kit tests the binding of its first name before it resolves the rest of the path
+* (FORMULA.LET). The resolution of the whole path does not show that test.
 */
-function heights(graph, options = {}) {
-	const index = indexed(graph, options);
-	const found = strong(index);
-	const levels = heightsOf(index, found);
-	const out = /* @__PURE__ */ new Map();
-	index.ids.forEach((id, node) => out.set(id, levels[found.of[node]]));
-	return out;
+function heldStop(root, path) {
+	const name = path[1];
+	if (path.length <= 2 || path[0] !== "names" || typeof name !== "string" || !Object.hasOwn(root.names, name)) return void 0;
+	const bound = root.names[name];
+	return bound instanceof Held ? {
+		ok: false,
+		error: bound.error
+	} : void 0;
 }
 /**
-* This function puts the nodes in layers by their heights, in linear time (GRAPH.LAYERS). The first layer has the
-* height 0. Two nodes of one layer read each other only inside one component. Thus a push schedule can evaluate the
-* components of one layer at the same time.
+* This function tells if an old result stays valid in a new context (READS.VERIFY, D26). It resolves the path of
+* each free read again, in the order of the list, and it compares what the path reaches with `sameResult`. It stops at
+* the first read that reaches another thing, and it gives that read (READS.CHANGED).
 *
-* @param graph - The nodes, each with its edges.
-* @param options - The option `eager` keeps only the eager edges with a target node.
-* @returns The layers, from the height 0 up. Each layer keeps the order of the graph.
+* - A read that is not free reads a binding that a kind made from earlier reads, for example a name of `let`. The
+*   function does not resolve it again.
+* - A thing compares as in `sameResult`. Thus a host thing or a date is the same only as itself. A host gives a new
+*   object for a new state, or the option `equal`.
+* - A longer path through a name that holds a `Held` in the new context is a changed read. A reference of the formula
+*   kit gives the error of that binding, and the resolution of the path does not show it.
+* - The answer is sound only for a pure document (FACTS.PURE). A document with an effect, a volatile operation or an
+*   extension of a profile can read outside `resolve`. The schedule asks `factsOf` first.
+*
+* The values of the context must not change in place, as PLAN.CACHE says for the documents. A value that changed in
+* place is the same object, thus `sameResult` cannot see the change. The option `prints` finds such a change
+* (READS.IN-PLACE). The prints come from `printReads` after the evaluation, and the answer then has the mark `inPlace`.
+*
+* @param target - The machine of the evaluation, or its plan.
+* @param reads - The reads of the evaluation, from the option `reads`.
+* @param context - The new context.
+* @param options - The rule of the host for two things, and the prints of the reads.
+* @returns `{ same: true }` when each free read reaches the same thing, or else the first changed read.
 */
-function nodeLayers(graph, options = {}) {
-	const out = [];
-	for (const [id, height] of heights(graph, options)) {
-		while (out.length <= height) out.push([]);
-		out[height]?.push(id);
+function verifyReads(target, reads, context, options = {}) {
+	const machine = "evaluators" in target ? target : target.machine;
+	const root = rootContext(machine, context);
+	const equal = options.equal;
+	const prints = options.prints;
+	let printed;
+	for (let index = 0; index < reads.length; index += 1) {
+		const read = reads[index];
+		if (!read.free) continue;
+		const stop = heldStop(root, read.path);
+		if (stop !== void 0) return {
+			same: false,
+			index,
+			read,
+			now: stop
+		};
+		if (read.kept === true) {
+			const now = keptAgain(machine, root, read.path);
+			if (now === void 0) return {
+				same: false,
+				index,
+				read,
+				now: fail("#N/A", "The host does not know the value of the kept read yet.")
+			};
+			if (!sameResult(read.reached, now, equal)) return {
+				same: false,
+				index,
+				read,
+				now
+			};
+			if (prints !== void 0 && changedInPlace(prints, index, now, printed ??= /* @__PURE__ */ new Map())) return {
+				same: false,
+				index,
+				read,
+				now,
+				inPlace: true
+			};
+			continue;
+		}
+		const asked = read.hops !== void 0;
+		const now = readAgain(machine, root, read.path, asked);
+		if (!sameResult(read.reached, now.reached, equal) || read.hops !== void 0 && !sameHops(read.hops, now.hops, equal)) return {
+			same: false,
+			index,
+			read,
+			now: now.reached
+		};
+		if (prints !== void 0 && changedInPlace(prints, index, now.reached, printed ??= /* @__PURE__ */ new Map())) return {
+			same: false,
+			index,
+			read,
+			now: now.reached,
+			inPlace: true
+		};
 	}
-	return out;
+	return SAME;
 }
-/**
-* This function gives the nodes that a set of observed nodes needs (GRAPH.NECESSARY). These are the observed nodes,
-* and each node with a path of edges from them. A push schedule evaluates only these nodes. An observed name that is
-* not a node of the graph adds nothing.
-*
-* @param graph - The nodes, each with its edges.
-* @param observed - The nodes that the host shows or reads.
-* @param options - The option `eager` keeps only the eager edges with a target node.
-* @returns The necessary nodes, in the order of the graph.
-*/
-function necessary(graph, observed, options = {}) {
-	const index = indexed(graph, options);
-	const numbers = /* @__PURE__ */ new Map();
-	index.ids.forEach((id, node) => numbers.set(id, node));
-	const seen = new Uint8Array(index.size);
-	const work = [];
-	for (const id of observed) {
-		const node = numbers.get(id);
-		if (node === void 0 || seen[node] === 1) continue;
-		seen[node] = 1;
-		work.push(node);
-	}
-	while (work.length > 0) {
-		const node = work.pop();
-		for (let edge = index.start[node]; edge < index.start[node + 1]; edge += 1) {
-			const to = index.targets[edge];
-			if (seen[to] === 1) continue;
-			seen[to] = 1;
-			work.push(to);
+// src/durable.ts
+/** The most values that a cache of value documents keeps, as in `planner`. */
+const MAX_VALUES = 1e3;
+/** No reads. One frozen list serves each result of a pure document without reads. */
+const NO_READS = /* @__PURE__ */ Object.freeze([]);
+/** The key of the document `-0` in a cache of value documents. A `Map` finds the entry of `0` for `-0`. */
+const NEGATIVE_ZERO = /* @__PURE__ */ Symbol("coeval.negative-zero");
+/** This function makes a cache by document. A document object gives its value one time, as PLAN.CACHE says. */
+function byDocument(make) {
+	const objects = /* @__PURE__ */ new WeakMap();
+	const values = /* @__PURE__ */ new Map();
+	return (doc) => {
+		if (typeof doc === "object" && doc !== null) {
+			if (objects.has(doc)) return objects.get(doc);
+			const made = make(doc);
+			objects.set(doc, made);
+			return made;
 		}
-	}
-	const out = /* @__PURE__ */ new Set();
-	index.ids.forEach((id, node) => {
-		if (seen[node] === 1) out.add(id);
-	});
-	return out;
+		const key = Object.is(doc, -0) ? NEGATIVE_ZERO : doc;
+		if (values.has(key)) return values.get(key);
+		const made = make(doc);
+		if (values.size >= MAX_VALUES) values.clear();
+		values.set(key, made);
+		return made;
+	};
 }
 /**
-* This function gives the static cycles of a graph (GRAPH.CYCLE): each component with two or more nodes, and each
-* node with an edge to itself. A cycle of the eager edges with a target is certain, and `check` or a host can report
-* it before a run. Another cycle is possible: an evaluation can skip a lazy read.
+* This function makes a cache with two levels of durability for a host or a schedule (R4 P7, D30). The structure is
+* the machine and the documents. The data is each value that a context gives: the names, `self`, `event`, the
+* capabilities and the world of the host.
 *
-* - A component of all the edges that is also a component of the eager edges is one certain cycle.
-* - Each other component of all the edges is one possible cycle, and each certain cycle in it comes after it.
-* - A read can still fail before it occurs. Thus the demand of D31, not a static cycle, gives the value of each node.
+* - A plan and the facts depend only on the structure. A document object compiles one time for a machine, thus a
+*   change of data compiles nothing (DURABLE.DATA).
+* - A result depends on the data too. It stays in its data epoch. After a change of data, a pure document verifies
+*   its reads with `verifyReads`, and each other document evaluates again.
+* - An edit gives a new document object, thus only that document compiles. A new machine drops each plan, each fact
+*   and each result (DURABLE.STRUCTURE).
 *
-* @param graph - The nodes, each with its edges.
-* @returns The cycles, deepest first.
-*/
-function cycles(graph) {
-	const every = indexed(graph, {});
-	const found = strong(every);
-	const eager = indexed(graph, { eager: true });
-	const inside = /* @__PURE__ */ new Map();
-	for (const members of strong(eager).list) {
-		if (!cyclic(eager, members)) continue;
-		const component = found.of[members[0]];
-		const list = inside.get(component);
-		if (list === void 0) inside.set(component, [members]);
-		else list.push(members);
-	}
-	const out = [];
-	found.list.forEach((members, component) => {
-		if (!cyclic(every, members)) return;
-		const nodes = named$1(every, members);
-		const certain = inside.get(component) ?? [];
-		if (certain.length === 1 && certain[0]?.length === nodes.length) {
-			out.push({
-				nodes,
-				certain: true
-			});
-			return;
-		}
-		out.push({
-			nodes,
-			certain: false
-		});
-		for (const part of certain) out.push({
-			nodes: named$1(eager, part),
-			certain: true
-		});
-	});
-	return out;
-}
-/**
-* This function gives the nodes that a demand of a node needs first, deepest first (SCHED.LONG-CHAIN). It follows the
-* eager edges with a target from the node, with its own stack. Each node comes after each node that it reads, except
-* on a cycle, as in an order by heights. The walk costs only the nodes that it enters.
+* The host keeps two promises. In one data epoch, the context of a key gives the same data. The values of a
+* context and the documents do not change in place, as PLAN.CACHE and `verifyReads` say. The option `inPlace`
+* finds a change in place of a value that a pure document read (READS.IN-PLACE).
 *
-* @param from - The node of the demand. It is not in the answer.
-* @param edgesOf - This function gives the edges of a node, or `undefined` for a node that the walk does not enter.
-* @returns The nodes, deepest first.
+* @param machine - The machine of the first structure epoch.
+* @param options - The type of a bare root value, the verb, the volatile reads, the rule of the host and the check of changes in place.
+* @returns The cache.
 */
-function deepestFirst(from, edgesOf) {
-	const out = [];
-	const first = edgesOf(from);
-	if (first === void 0) return out;
-	const seen = /* @__PURE__ */ new Set([from]);
-	const nodes = [from];
-	const lists = [first];
-	const positions = [0];
-	while (nodes.length > 0) {
-		const top = nodes.length - 1;
-		const edges = lists[top];
-		let position = positions[top];
-		let entered = false;
-		while (position < edges.length) {
-			const edge = edges[position];
-			position += 1;
-			const to = edge.to;
-			if (edge.lazy || to === void 0 || seen.has(to)) continue;
-			seen.add(to);
-			const more = edgesOf(to);
-			if (more === void 0) continue;
-			positions[top] = position;
-			nodes.push(to);
-			lists.push(more);
-			positions.push(0);
-			entered = true;
-			break;
+function durable(machine, options = {}) {
+	const prepareOptions = {
+		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...options.verb === void 0 ? {} : { verb: options.verb }
+	};
+	const factsOptions = {
+		...prepareOptions,
+		...options.volatile === void 0 ? {} : { volatile: options.volatile }
+	};
+	const verifyOptions = options.equal === void 0 ? {} : { equal: options.equal };
+	const printOptions = options.inPlace === true ? {} : options.inPlace;
+	const printsOf = printOptions === void 0 ? void 0 : /* @__PURE__ */ new WeakMap();
+	const counts = {
+		compiles: 0,
+		facts: 0,
+		evaluations: 0,
+		verifications: 0,
+		reuses: 0
+	};
+	const results = /* @__PURE__ */ new Map();
+	let current = machine;
+	let epochs = {
+		structure: 0,
+		data: 0
+	};
+	const plansOf = (m) => byDocument((doc) => {
+		counts.compiles += 1;
+		return prepare(m, doc, prepareOptions);
+	});
+	const factsFor = (m) => byDocument((doc) => {
+		counts.facts += 1;
+		return factsOf(m, doc, factsOptions);
+	});
+	let plans = plansOf(machine);
+	let facts = factsFor(machine);
+	return {
+		get machine() {
+			return current;
+		},
+		get epochs() {
+			return epochs;
+		},
+		get counts() {
+			return { ...counts };
+		},
+		plan: (doc) => plans(doc),
+		facts: (doc) => facts(doc),
+		evaluate(key, doc, context) {
+			const plan = plans(doc);
+			const entry = results.get(key);
+			if (entry !== void 0 && entry.plan === plan) {
+				if (entry.data === epochs.data) {
+					counts.reuses += 1;
+					return entry.result;
+				}
+				if (entry.reads !== void 0) {
+					counts.verifications += 1;
+					const prints = printsOf?.get(entry);
+					if (verifyReads(plan, entry.reads, context, prints === void 0 ? verifyOptions : {
+						...verifyOptions,
+						prints
+					}).same) {
+						entry.data = epochs.data;
+						counts.reuses += 1;
+						return entry.result;
+					}
+				}
+			}
+			const reads = facts(doc).pure ? [] : void 0;
+			counts.evaluations += 1;
+			const result = plan.evaluate(context, reads === void 0 ? void 0 : { reads });
+			const made = {
+				plan,
+				result,
+				reads: reads === void 0 ? void 0 : reads.length === 0 ? NO_READS : reads.slice(),
+				data: epochs.data
+			};
+			results.set(key, made);
+			if (printsOf !== void 0 && made.reads !== void 0) printsOf.set(made, printReads(made.reads, printOptions));
+			return result;
+		},
+		changeData() {
+			epochs = {
+				structure: epochs.structure,
+				data: epochs.data + 1
+			};
+		},
+		changeStructure(next) {
+			epochs = {
+				structure: epochs.structure + 1,
+				data: epochs.data + 1
+			};
+			if (next === void 0 || next === current) return;
+			current = next;
+			plans = plansOf(next);
+			facts = factsFor(next);
+			results.clear();
+		},
+		forget(key) {
+			results.delete(key);
 		}
-		if (entered) continue;
-		const done = nodes.pop();
-		lists.pop();
-		positions.pop();
-		if (nodes.length > 0) out.push(done);
-	}
-	return out;
+	};
 }
 // src/schedule.ts
 /**
@@ -15507,6 +16814,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map