@mark1russell7/coeval 0.4.3 → 0.6.0

package/build/index.js

@@ -299,7 +299,7 @@ var Failure = class extends Error {
 */
 function isStackOverflow(error) {
 	try {
-		return error instanceof RangeError && /call stack/i.test(error.message);
+		return (error instanceof RangeError || error instanceof SyntaxError) && error.message.includes("call stack");
 	} catch {
 		return true;
 	}
@@ -508,6 +508,338 @@ function looksLikeKind(value) {
 	return isRecord(value) && isRecord(field(value, "verbs"));
 }
 //#endregion
+//#region src/merge.ts
+/** The exception of a merge with conflicts. It lists each conflict of the merge, not only the first. */
+var MergeError = class extends Error {
+	conflicts;
+	/**
+	* This constructor makes the exception.
+	*
+	* @param conflicts - The conflicts, in the order that the merge found them.
+	*/
+	constructor(conflicts) {
+		const lines = conflicts.map((item) => `At ${JSON.stringify(item.path)}, the parts ${item.parts[0]} and ${item.parts[1]}: ${item.reason}`);
+		super(`The merge has ${conflicts.length === 1 ? "1 conflict" : `${conflicts.length} conflicts`}. ${lines.join(" ")}`);
+		this.name = "MergeError";
+		this.conflicts = conflicts;
+	}
+};
+const NONE$1 = /* @__PURE__ */ new Set();
+function keyOf(path) {
+	return JSON.stringify(path.map(String));
+}
+/** This function sets an own data property. An assignment to the key `__proto__` changes the prototype. */
+function setOwn$2(target, key, value) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else target[key] = value;
+}
+function own$1(table, key) {
+	return table !== void 0 && Object.hasOwn(table, key) ? table[key] : void 0;
+}
+/** This function gives a copy of a JSON value without the fields whose value is `undefined`, as JSON writes it. */
+function defined(value) {
+	if (Array.isArray(value)) return value.map(defined);
+	if (!isRecord(value)) return value;
+	const out = {};
+	for (const key of Object.keys(value)) if (value[key] !== void 0) setOwn$2(out, key, defined(value[key]));
+	return out;
+}
+/** Two values are the same when they are equal by `docEquals`. A function and a host value are equal only to themselves. */
+function same(a, b) {
+	return Object.is(a, b) || docEquals(defined(a), defined(b));
+}
+/** Two lists of roots are the same when they hold the same roots, in any order. */
+function sameRoots(a, b) {
+	if (!Array.isArray(a) || !Array.isArray(b)) return same(a, b);
+	return same([...new Set(a.map(String))].sort(), [...new Set(b.map(String))].sort());
+}
+/** The record of a merge: the conflicts, and the part that gave each entry. */
+var Merger = class {
+	conflicts = [];
+	sources = /* @__PURE__ */ new Map();
+	/** This method gives the part that gave the entry at a path, or the entry nearest above it. */
+	sourceOf(path) {
+		for (let length = path.length; length >= 0; length -= 1) {
+			const found = this.sources.get(keyOf(path.slice(0, length)));
+			if (found !== void 0) return found;
+		}
+		return 0;
+	}
+	/** This method records the part that gives a new entry. */
+	give(path, part) {
+		this.sources.set(keyOf(path), part);
+	}
+	/** This method records the part that replaces an entry, and forgets the parts of each entry below it. */
+	replace(path, part) {
+		const below = `${keyOf(path).slice(0, -1)},`;
+		for (const key of [...this.sources.keys()]) if (key.startsWith(below)) this.sources.delete(key);
+		this.give(path, part);
+	}
+	clash(path, part, reason) {
+		this.conflicts.push({
+			path,
+			parts: [this.sourceOf(path), part],
+			reason
+		});
+	}
+};
+/**
+* This function merges one entry of a table into the table. A new entry joins the table. A path in `replaces` gives
+* the later entry. Two entries that are the same give one entry. Each other pair is a conflict.
+*/
+function mergeLeaf(m, table, key, later, path, part, replaces, equal, reason) {
+	if (later === void 0) return;
+	const earlier = own$1(table, key);
+	if (earlier === void 0) {
+		setOwn$2(table, key, later);
+		m.give(path, part);
+	} else if (replaces.has(keyOf(path))) {
+		setOwn$2(table, key, later);
+		m.replace(path, part);
+	} else if (!equal(earlier, later)) m.clash(path, part, reason);
+}
+function what(entry) {
+	if (isKind(entry)) return "a kind";
+	if (isAlias(entry)) return "an alias";
+	return isNamespace(entry) ? "a namespace" : "an entry";
+}
+function mergeFallback(m, earlier, later, path, part, replaces) {
+	const table = earlier === void 0 ? {} : { fallback: earlier };
+	mergeLeaf(m, table, "fallback", later, path, part, replaces, same, "Two parts give two different fallback kinds.");
+	return table["fallback"];
+}
+function mergeEntries(m, into, from, path, part, replaces) {
+	for (const key of Object.keys(from)) {
+		const later = from[key];
+		if (later === void 0) continue;
+		const at = [...path, key];
+		const earlier = own$1(into, key);
+		if (earlier === void 0) {
+			setOwn$2(into, key, later);
+			m.give(at, part);
+		} else setOwn$2(into, key, mergeEntry(m, earlier, later, at, part, replaces));
+	}
+}
+/** This function merges two entries at one path. Two namespaces merge key by key, and their fallbacks merge too. */
+function mergeEntry(m, earlier, later, path, part, replaces) {
+	if (replaces.has(keyOf(path))) {
+		m.replace(path, part);
+		return later;
+	}
+	if (same(earlier, later)) return earlier;
+	if (isNamespace(earlier) && isNamespace(later)) {
+		const kinds = { ...earlier.kinds };
+		mergeEntries(m, kinds, later.kinds, [...path, "kinds"], part, replaces);
+		const fallback = mergeFallback(m, earlier.fallback, later.fallback, [...path, "fallback"], part, replaces);
+		return fallback === void 0 ? { kinds } : {
+			kinds,
+			fallback
+		};
+	}
+	const a = what(earlier);
+	const b = what(later);
+	m.clash(path, part, a === b ? `Two parts give two different ${a === "an alias" ? "aliases" : "kinds"}.` : `One part gives ${a}, and the other part gives ${b}.`);
+	return earlier;
+}
+function worldOf(draft) {
+	const world = {
+		kinds: { ...draft.kinds },
+		defaults: { ...draft.defaults }
+	};
+	return draft.fallback === void 0 ? world : {
+		...world,
+		fallback: draft.fallback
+	};
+}
+function mergeWorldInto(m, draft, part, index, replaces, base) {
+	if (part === void 0) return;
+	if (part.kinds !== void 0) mergeEntries(m, draft.kinds, part.kinds, [...base, "kinds"], index, replaces);
+	const defaults = part.defaults ?? {};
+	for (const verb of Object.keys(defaults)) mergeLeaf(m, draft.defaults, verb, defaults[verb], [
+		...base,
+		"defaults",
+		verb
+	], index, replaces, Object.is, "Two parts give two different defaults for this verb.");
+	const fallback = mergeFallback(m, draft.fallback, part.fallback, [...base, "fallback"], index, replaces);
+	if (fallback !== void 0) draft.fallback = fallback;
+}
+/**
+* This function merges worlds into one world, in the order of the parts. It does not change a part.
+*
+* - Two entries that are equal by `docEquals` give one entry.
+* - Two namespaces merge key by key, at each depth. Their fallbacks merge as each other entry.
+* - The defaults merge verb by verb, and the world keeps one fallback.
+* - Each other pair of entries at one path is a conflict, unless the later part names the path in `replaces`.
+*   Then the later entry wins, with no merge below it.
+*
+* A part can be a function of the merge of the parts before it (`prev`, as an overlay of Nix). Thus a part can read
+* the entry that it replaces.
+*
+* @param parts - The worlds, or functions that give a world from the merge before them.
+* @returns The world. It has no `replaces`.
+* @throws {MergeError} The merge has a conflict. The error lists each conflict.
+*/
+function mergeWorlds(...parts) {
+	const m = new Merger();
+	const draft = {
+		kinds: {},
+		defaults: {}
+	};
+	parts.forEach((input, index) => {
+		const part = typeof input === "function" ? input(worldOf(draft)) : input;
+		mergeWorldInto(m, draft, part, index, new Set((part.replaces ?? []).map(keyOf)), []);
+	});
+	if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
+	return worldOf(draft);
+}
+/** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
+const TABLES = /* @__PURE__ */ new Set([
+	"world",
+	"evaluators",
+	"runners",
+	"derefs",
+	"walkers",
+	"known",
+	"replaces"
+]);
+/**
+* This function composes the hooks `known` in the order of their parts. The first answer that is not `true` wins. A
+* hook does not answer for an evaluator name whose code a later part replaces.
+*/
+function composeKnown(hooks, replaced) {
+	const first = hooks[0];
+	if (first === void 0) return void 0;
+	if (hooks.length === 1 && replaced.size === 0) return first.known;
+	const list = [...hooks];
+	const last = new Map(replaced);
+	return (path, evaluator) => {
+		const after = last.get(evaluator);
+		for (const hook of list) {
+			if (after !== void 0 && hook.part < after) continue;
+			const answer = hook.known(path, evaluator);
+			if (answer !== true) return answer;
+		}
+		return true;
+	};
+}
+function machineOf(draft) {
+	const known = composeKnown(draft.hooks, draft.replaced);
+	return {
+		...draft.rest,
+		world: worldOf(draft.world),
+		evaluators: { ...draft.evaluators },
+		...draft.runners === void 0 ? {} : { runners: { ...draft.runners } },
+		...draft.derefs === void 0 ? {} : { derefs: { ...draft.derefs } },
+		...draft.walkers === void 0 ? {} : { walkers: { ...draft.walkers } },
+		...known === void 0 ? {} : { known }
+	};
+}
+/** This function merges the evaluators and the runners of a part. The evaluator and the runner of a name are its code. */
+function mergeCode(m, draft, part, index, replaces) {
+	if (part.runners !== void 0) draft.runners ??= {};
+	const names = /* @__PURE__ */ new Set([...Object.keys(part.evaluators ?? {}), ...Object.keys(part.runners ?? {})]);
+	for (const name of names) {
+		const evaluator = own$1(part.evaluators, name);
+		const runner = own$1(part.runners, name);
+		if (evaluator === void 0 && runner === void 0) continue;
+		const evaluatorPath = ["evaluators", name];
+		const runnerPath = ["runners", name];
+		if (replaces.has(keyOf(evaluatorPath)) || replaces.has(keyOf(runnerPath))) {
+			if (evaluator === void 0) delete draft.evaluators[name];
+			else setOwn$2(draft.evaluators, name, evaluator);
+			if (runner !== void 0) setOwn$2(draft.runners ??= {}, name, runner);
+			else if (draft.runners !== void 0) delete draft.runners[name];
+			m.replace(evaluatorPath, index);
+			m.replace(runnerPath, index);
+			draft.replaced.set(name, index);
+			continue;
+		}
+		mergeLeaf(m, draft.evaluators, name, evaluator, evaluatorPath, index, NONE$1, Object.is, "Two parts give two different evaluators for this name.");
+		if (runner !== void 0) mergeLeaf(m, draft.runners ??= {}, name, runner, runnerPath, index, NONE$1, Object.is, "Two parts give two different runners for this name.");
+	}
+}
+/** A runner hides the evaluator of its name. Thus a name with a runner and an evaluator needs one part that gives both. */
+function checkHidden(m, draft) {
+	const runners = draft.runners ?? {};
+	for (const name of Object.keys(runners)) {
+		const runner = runners[name];
+		const evaluator = own$1(draft.evaluators, name);
+		if (runner === void 0 || evaluator === void 0) continue;
+		if (draft.parts.some((part) => own$1(part.evaluators, name) === evaluator && own$1(part.runners, name) === runner)) continue;
+		const a = m.sourceOf(["evaluators", name]);
+		const b = m.sourceOf(["runners", name]);
+		m.conflicts.push({
+			path: ["runners", name],
+			parts: [Math.min(a, b), Math.max(a, b)],
+			reason: "The runner of one part hides the evaluator of the other part, because a runner wins over an evaluator of its name."
+		});
+	}
+}
+/**
+* This function merges machines into one machine, in the order of the parts. It does not change a part.
+*
+* - The worlds merge with the rules of `mergeWorlds`. The paths of their conflicts start with `"world"`.
+* - The tables `evaluators`, `runners`, `derefs` and `walkers` merge name by name. A function is equal only to itself.
+* - The evaluator and the runner of a name are its code. A replacement of the name replaces both.
+* - A runner hides the evaluator of its name. Thus one part must give both, or the merge gives a conflict.
+* - The hooks `known` compose in the order of the parts. A hook does not answer for a name that a later part replaces.
+* - Each other field, for example `permits`, `adopt`, `roots`, `plain` or `maxDepth`, is one value. Two different
+*   values are a conflict. An absent field has no value.
+*
+* A conflict stops the merge, unless the later part names its path in `replaces`. A part can be a function of the
+* merge of the parts before it (`prev`, as an overlay of Nix). Thus a part can wrap the code that it replaces.
+*
+* @param parts - The machines, or functions that give a machine from the merge before them.
+* @returns The machine.
+* @throws {MergeError} The merge has a conflict. The error lists each conflict.
+*/
+function mergeMachines(...parts) {
+	const m = new Merger();
+	const draft = {
+		world: {
+			kinds: {},
+			defaults: {}
+		},
+		evaluators: {},
+		hooks: [],
+		replaced: /* @__PURE__ */ new Map(),
+		rest: {},
+		parts: []
+	};
+	parts.forEach((input, index) => {
+		const part = typeof input === "function" ? input(machineOf(draft)) : input;
+		draft.parts.push(part);
+		const replaces = new Set([...part.replaces ?? [], ...(part.world?.replaces ?? []).map((path) => ["world", ...path])].map(keyOf));
+		mergeWorldInto(m, draft.world, part.world, index, replaces, ["world"]);
+		mergeCode(m, draft, part, index, replaces);
+		if (part.derefs !== void 0) {
+			const derefs = draft.derefs ??= {};
+			for (const name of Object.keys(part.derefs)) mergeLeaf(m, derefs, name, part.derefs[name], ["derefs", name], index, replaces, Object.is, "Two parts give two different deref codes for this name.");
+		}
+		if (part.walkers !== void 0) {
+			const walkers = draft.walkers ??= {};
+			for (const name of Object.keys(part.walkers)) mergeLeaf(m, walkers, name, part.walkers[name], ["walkers", name], index, replaces, Object.is, "Two parts give two different walkers for this name.");
+		}
+		if (part.known !== void 0 && !draft.hooks.some((hook) => hook.known === part.known)) draft.hooks.push({
+			part: index,
+			known: part.known
+		});
+		const fields = part;
+		for (const key of Object.keys(fields)) {
+			if (TABLES.has(key)) continue;
+			mergeLeaf(m, draft.rest, key, fields[key], [key], index, replaces, key === "roots" ? sameRoots : same, `Two parts give two different values for ${key}.`);
+		}
+	});
+	checkHidden(m, draft);
+	if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
+	return machineOf(draft);
+}
+//#endregion
 //#region src/ladder.ts
 /** The rungs of the ladder, in the order that a question visits them. */
 const RUNGS = [
@@ -2257,7 +2589,8 @@ const STD_WORLD = {
 				],
 				of: "number"
 			},
-			summary: "A node of a tree. Its parts see it as self, and each node links to its parent."
+			caps: [{ rule: "mask" }],
+			summary: "A node of a tree. Each part is an attribute that evaluates on demand, one time, with the node as self."
 		},
 		box: {
 			verbs: {
@@ -2273,7 +2606,8 @@ const STD_WORLD = {
 				],
 				of: "number"
 			},
-			summary: "A node of a tree, as panel. A formula in a box can read the parent of the box."
+			caps: [{ rule: "mask" }],
+			summary: "A node of a tree, as panel. A formula in a box can read its parent and its siblings."
 		},
 		math: { kinds: {
 			sum: {
@@ -2390,53 +2724,167 @@ const STD_EVALUATORS = {
 		const found = resolve(data);
 		return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
 	},
-	"tree.node": (input) => treeNode(input.parts, input.context, input.kind)
+	"tree.node": (input) => treeNode(input)
 };
+/** The brand of a node of the decorated tree. Its value is the state that the kit reads. */
+const TREE_NODE = Symbol.for("coeval.tree.node");
+const BUSY = Object.freeze({ busy: true });
+/** The attributes in evaluation, in the order of their demands. An evaluation does not wait, thus one list serves. */
+const demands = [];
+function attributeText(key, type, place) {
+	return `${key} of ${type} at [${place.join(", ")}]`;
+}
+/** This function gives the `#CYCLE!` of a demand that reached an attribute in evaluation, with the chain of demands. */
+function cycleAt(cells, key, text) {
+	const first = demands.findIndex((demand) => demand.cells === cells && demand.key === key);
+	const chain = first === -1 ? [text] : demands.slice(first).map((demand) => demand.text);
+	chain.push(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;
+}
+/** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
+function putField(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+/**
+* This function gives a value with the JSON of each node of a tree in it. A list or a plain record is new only when
+* it holds a node. A container that holds itself stays as it is.
+*/
+function plainOf(value, path) {
+	const state = stateOf(value);
+	if (state !== void 0) {
+		if (path.has(value)) return fail("#CYCLE!", `The JSON of the node ${state.type} at [${state.place.join(", ")}] holds the node itself.`);
+		return state.json(path);
+	}
+	if (typeof value !== "object" || value === null || path.has(value) || isHostThing(value)) return ok(value);
+	if (!Array.isArray(value) && !isRecord(value)) return ok(value);
+	path.add(value);
+	try {
+		if (Array.isArray(value)) {
+			let list;
+			for (let index = 0; index < value.length; index += 1) {
+				const item = plainOf(value[index], path);
+				if (!item.ok) return item;
+				if (item.value !== value[index]) (list ??= [...value])[index] = item.value;
+			}
+			return ok(list ?? value);
+		}
+		const record = value;
+		let out;
+		for (const key of Object.keys(record)) {
+			const item = plainOf(record[key], path);
+			if (!item.ok) return item;
+			if (item.value === record[key]) continue;
+			if (out === void 0) {
+				out = {};
+				for (const other of Object.keys(record)) putField(out, other, record[other]);
+			}
+			putField(out, key, item.value);
+		}
+		return ok(out ?? value);
+	} finally {
+		path.delete(value);
+	}
+}
 /**
-* This function evaluates a node of a tree. The node is a host thing. A step `parent` reaches the node that holds
-* it. A step with the name of a part evaluates that part on demand, one time. Each part sees the node as self.
+* This function makes a node of the decorated tree. A step `parent` gives the self of the context of the node, and a
+* step `type` gives its type. A step with the key of a part reads that attribute. A failed attribute throws `Failure`
+* with its own error, thus a reference to it gives that error.
 */
-function treeNode(parts, context, type) {
-	const memo = /* @__PURE__ */ new Map();
+function treeThing(parts, context, type, place, build) {
+	const cells = /* @__PURE__ */ new Map();
 	const read = (key) => {
-		const known = memo.get(key);
-		if (known !== void 0) return known;
+		const cell = cells.get(key);
+		if (cell !== void 0) return cell.busy ? cycleAt(cells, key, attributeText(key, type, place)) : cell.result;
 		const part = parts.find((item) => item.key === key);
 		if (part === void 0) return void 0;
-		const result = part.evaluate({
-			...context,
-			self: me
+		cells.set(key, BUSY);
+		demands.push({
+			cells,
+			key,
+			text: attributeText(key, type, place)
+		});
+		let result;
+		try {
+			result = part.evaluate({
+				...context,
+				self: node
+			});
+		} catch (error) {
+			cells.delete(key);
+			throw error;
+		} finally {
+			demands.pop();
+		}
+		cells.set(key, {
+			busy: false,
+			result
 		});
-		memo.set(key, result);
 		return result;
 	};
-	const me = {
+	const state = {
+		build,
+		type,
+		place,
+		json(path) {
+			path.add(node);
+			try {
+				const out = {};
+				for (const part of parts) {
+					const result = read(part.key);
+					if (!result.ok) return result;
+					const value = plainOf(result.value, path);
+					if (!value.ok) return value;
+					putField(out, part.key, value.value);
+				}
+				return ok(out);
+			} finally {
+				path.delete(node);
+			}
+		}
+	};
+	const node = {
 		[THING]: true,
+		[TREE_NODE]: state,
 		type,
 		label: `node ${type}`,
 		deref(key) {
 			if (key === "parent") return context.self;
 			if (key === "type") return type;
 			const result = read(String(key));
-			return result?.ok === true ? result.value : void 0;
+			if (result === void 0) return void 0;
+			if (!result.ok) throw new Failure(result.error);
+			return result.value;
 		},
 		toJson() {
-			const out = {};
-			for (const part of parts) {
-				const result = read(part.key);
-				out[part.key] = result?.ok === true ? result.value : null;
-			}
-			return out;
+			const result = state.json(/* @__PURE__ */ new Set());
+			if (!result.ok) throw new Failure(result.error);
+			return result.value;
 		}
 	};
-	const out = {};
-	for (const part of parts) {
-		const result = read(part.key);
-		if (result === void 0) continue;
-		if (!result.ok) return result;
-		out[part.key] = result.value;
+	return node;
+}
+/**
+* This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
+* thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree.
+*/
+function treeNode({ parts, context, kind, place }) {
+	const above = stateOf(context.self);
+	if (above !== void 0 && above.build.open) return ok(treeThing(parts, context, kind, place, above.build));
+	const build = { open: true };
+	const root = treeThing(parts, context, kind, place, build);
+	try {
+		return stateOf(root).json(/* @__PURE__ */ new Set());
+	} finally {
+		build.open = false;
 	}
-	return ok(out);
 }
 function hostType(node, wanted) {
 	return isHostThing(node) && node.type === wanted;
@@ -3906,44 +4354,36 @@ function formulaKnown(profile = {}) {
 	};
 }
 /**
-* This function makes a machine for a formula language. The machine has the kinds and the evaluators of the
-* formula kit. It also has the kinds, the evaluators and the walkers that the language adds. Its hook `known` comes
-* from the profile (`formulaKnown`). A hook `known` of the language answers each name that the kit knows.
+* This function makes a machine for a formula language. It merges the kit and the parts that the language adds with
+* `mergeMachines`. Thus a kind `ops.*` or a namespace `ops` of the language extends the namespace of the kit, and
+* the fallback of the kit stays. The hook `known` of the kit comes from the profile (`formulaKnown`). A hook `known`
+* of the language answers after it.
+*
+* A kind or an evaluator of the language that differs from the entry of the kit with its name is a conflict. The
+* language names the path in `replaces` to replace the entry, for example `["world", "kinds", "ref"]` or
+* `["evaluators", "formula.op"]`. Then the hook of the kit does not answer for a replaced evaluator.
 *
 * @param profile - The operations and the rules of the language.
-* @param more - The parts of a machine that the language adds. Its kinds win over the kinds of the kit.
+* @param more - The parts of a machine that the language adds, with the paths of the entries that it replaces.
 * @returns The machine.
+* @throws {MergeError} The language and the kit have a conflict.
 */
 function formulaMachine(profile = {}, more = {}) {
-	const kit = formulaKnown(profile);
-	const replaced = (name) => more.evaluators !== void 0 && Object.hasOwn(more.evaluators, name) || more.runners !== void 0 && Object.hasOwn(more.runners, name);
-	const theirs = more.known;
-	const known = (path, evaluator) => {
-		const answer = replaced(evaluator) ? true : kit(path, evaluator);
-		return answer === true && theirs !== void 0 ? theirs(path, evaluator) : answer;
-	};
-	return {
-		...more,
-		world: {
-			kinds: {
-				...formulaKinds(),
-				...more.world?.kinds
-			},
-			defaults: { ...more.world?.defaults }
-		},
-		evaluators: {
-			...formulaEvaluators(profile),
-			...more.evaluators
-		},
-		known
-	};
+	return mergeMachines({
+		world: { kinds: formulaKinds() },
+		evaluators: formulaEvaluators(profile),
+		known: formulaKnown(profile)
+	}, more);
 }
 //#endregion
 //#region src/reference.ts
 function own(table, name) {
 	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
 }
-/** This function finds the code of an evaluator name. A runner wins over an evaluator of the same name. */
+/**
+* This function finds the code of an evaluator name. A runner wins over an evaluator of the same name. A standard
+* evaluator gets the definition of the reference, unless the options give another definition (REF.TREE).
+*/
 function choose(env, name) {
 	const runner = own(env.machine.runners, name);
 	if (runner !== void 0) {
@@ -3953,7 +4393,8 @@ function choose(env, name) {
 	}
 	const evaluator = own(env.machine.evaluators, name);
 	if (evaluator === void 0) return void 0;
-	const defined = own(env.definitions.evaluators, name);
+	const standard = evaluator === own(STD_EVALUATORS, name) ? own(STD_DEFINITIONS.evaluators, name) : void 0;
+	const defined = own(env.definitions.evaluators, name) ?? standard;
 	if (defined !== void 0) return { evaluator: defined };
 	return typeof evaluator === "function" ? { evaluator } : { gap: `The reference has no definition of the compiled evaluator ${name}.` };
 }
@@ -4218,6 +4659,126 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		return placed(thrown(error, "the reference"), []);
 	}
 }
+const refNodes = /* @__PURE__ */ new WeakMap();
+/** The attributes in evaluation in the reference, in the order of their demands (TREE.CYCLE). */
+const inEvaluation = [];
+function nameOfAttribute(node, name) {
+	return `${name} of ${node.kind} at [${node.place.join(", ")}]`;
+}
+function refNodeOf(thing) {
+	return typeof thing === "object" && thing !== null ? refNodes.get(thing) : void 0;
+}
+/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when the node has no such part. */
+function attributeOf(node, self, name) {
+	const done = node.values.get(name);
+	if (done !== void 0) return done;
+	if (node.pending.has(name)) {
+		const from = inEvaluation.findIndex((entry) => entry.node === node && entry.name === name);
+		return fail("#CYCLE!", `The attributes form a cycle: ${[...from < 0 ? [nameOfAttribute(node, name)] : inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name)), nameOfAttribute(node, name)].join(" -> ")}.`);
+	}
+	const part = node.parts.find((item) => item.key === name);
+	if (part === void 0) return void 0;
+	node.pending.add(name);
+	inEvaluation.push({
+		node,
+		name
+	});
+	try {
+		const result = part.evaluate({
+			...node.ctx,
+			self
+		});
+		node.values.set(name, result);
+		return result;
+	} finally {
+		node.pending.delete(name);
+		inEvaluation.pop();
+	}
+}
+/** TREE.RESULT: the JSON of a node. `open` holds the nodes and the containers whose JSON is in progress. */
+function jsonOfNode(node, self, open) {
+	const record = {};
+	for (const part of node.parts) {
+		const result = attributeOf(node, self, part.key);
+		if (!result.ok) return result;
+		const value = plainValue(result.value, [...open, self]);
+		if (!value.ok) return value;
+		setField(record, part.key, value.value);
+	}
+	return ok(record);
+}
+/** This function gives a copy of a value with the JSON of each node in it. */
+function plainValue(value, open) {
+	const node = refNodeOf(value);
+	if (node !== void 0) {
+		if (open.includes(value)) return fail("#CYCLE!", `The JSON of the node ${node.kind} at [${node.place.join(", ")}] holds the node itself.`);
+		return jsonOfNode(node, value, open);
+	}
+	if (typeof value !== "object" || value === null || isHostThing(value) || open.includes(value)) return ok(value);
+	if (Array.isArray(value)) {
+		const items = [];
+		for (const item of value) {
+			const plain = plainValue(item, [...open, value]);
+			if (!plain.ok) return plain;
+			items.push(plain.value);
+		}
+		return ok(items);
+	}
+	if (!isRecord(value)) return ok(value);
+	const copy = {};
+	for (const key of Object.keys(value)) {
+		const plain = plainValue(value[key], [...open, value]);
+		if (!plain.ok) return plain;
+		setField(copy, key, plain.value);
+	}
+	return ok(copy);
+}
+/**
+* TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
+* tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error.
+*/
+const treeDefinition = ({ parts, context, kind, place }) => {
+	const outer = refNodeOf(context.self);
+	const nested = outer !== void 0 && outer.tree.open;
+	const node = {
+		tree: nested ? outer.tree : { open: true },
+		kind,
+		place,
+		parts,
+		ctx: context,
+		values: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Set()
+	};
+	const self = {
+		[THING]: true,
+		type: kind,
+		label: `node ${kind}`,
+		deref: (key) => {
+			if (key === "parent") return context.self;
+			if (key === "type") return kind;
+			const result = attributeOf(node, self, String(key));
+			if (result === void 0 || result.ok) return result?.ok === true ? result.value : void 0;
+			throw new Failure(result.error);
+		},
+		toJson: () => {
+			const result = jsonOfNode(node, self, []);
+			if (result.ok) return result.value;
+			throw new Failure(result.error);
+		}
+	};
+	refNodes.set(self, node);
+	if (nested) return ok(self);
+	try {
+		return jsonOfNode(node, self, []);
+	} finally {
+		node.tree.open = false;
+	}
+};
+/**
+* The definitions of the reference for the evaluators of the standard machine that need their own reading. The
+* reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node`.
+*/
+const STD_DEFINITIONS = { evaluators: { "tree.node": treeDefinition } };
 const CLOSURE$1 = Symbol.for("coeval.closure");
 /** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
 function setField(target, key, value) {
@@ -4697,6 +5258,8 @@ function generate(world, options) {
 	const maxSize = options.maxSize ?? 24;
 	const malformed = options.malformed ?? .05;
 	const keys = options.keys ?? KEYS;
+	const steps = options.steps ?? 2;
+	const roots = options.roots ?? ROOTS;
 	const stepTypes = types.filter((type) => {
 		const found = lookupKind(world, type);
 		return found.ok && Object.hasOwn(found.kind.verbs, "step");
@@ -4774,11 +5337,12 @@ function generate(world, options) {
 			{ names: "a" },
 			["nowhere", "a"]
 		]);
-		const root = pos.names.length > 0 && rng.chance(.75) ? "names" : rng.pick(ROOTS.filter((name) => name !== "names"));
+		const others = roots.filter((name) => name !== "names");
+		const root = roots.includes("names") && pos.names.length > 0 && (others.length === 0 || rng.chance(.75)) || others.length === 0 ? "names" : rng.pick(others);
 		const path = [root];
 		if (root === "names") path.push(pickName(pos.names));
 		if (root === "world") path.push(String(rng.pick(types)[0]));
-		for (let index = rng.int(3); index > 0; index -= 1) if (stepTypes.length > 0 && rng.chance(.2)) {
+		for (let index = rng.int(steps + 1); index > 0; index -= 1) if (stepTypes.length > 0 && rng.chance(.2)) {
 			const type = rng.pick(stepTypes);
 			const kind = kindOf(type);
 			const value = refKind?.parts?.shape === "deep" && kind?.parts !== void 0 ? valueOf(kind.parts, [], {
@@ -5000,6 +5564,6 @@ function generate(world, options) {
 	});
 }
 //#endregion
-export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaDefinitions, formulaEvaluators, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, narrow, nearestWalker, nodeAt, ok, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, random, ref, reference, refsOf, resolve, run, sameValue, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, typesOf, valueOfThing, walk, worldThing };
+export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaDefinitions, formulaEvaluators, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, mergeMachines, mergeWorlds, narrow, nearestWalker, nodeAt, ok, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, random, ref, reference, refsOf, resolve, run, sameValue, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, typesOf, valueOfThing, walk, worldThing };
 
 //# sourceMappingURL=index.js.map