@mark1russell7/coeval 0.21.0 → 0.22.0

package/build/index.js

@@ -428,6 +428,92 @@ function collectOf(declared) {
 	};
 }
 /**
+* This function reads an entry of the table `tree.at` (D124). The tree kit, the reference, `check` and the graph of
+* attribute instances read it with this one function.
+*
+* @param declared - The entry.
+* @returns The rule, or the reason when the entry has no correct form.
+*/
+function atRuleOf(declared) {
+	const params = isRecord(declared) ? field(declared, "params") : void 0;
+	if (!(Array.isArray(params) && params.every((name, index) => typeof name === "string" && params.indexOf(name) === index)) || !Object.hasOwn(declared, "equation")) return {
+		ok: false,
+		reason: "An entry of tree.at needs a list params of different texts and the field equation."
+	};
+	return {
+		ok: true,
+		params,
+		equation: field(declared, "equation")
+	};
+}
+/**
+* This function examines the arguments of a step `tree.at` (D124). The step gives an argument for each parameter, and
+* no other argument. Each argument is JSON data. The key is the text of `argsKey`, thus two equal arguments give one key.
+*
+* @param params - The parameters of the attribute.
+* @param args - The field `args` of the step.
+* @returns The names of the equation and the key, or the reason.
+*/
+function atArgsOf(params, args) {
+	if (!isRecord(args)) return {
+		ok: false,
+		reason: "The arguments are a record."
+	};
+	const extra = Object.keys(args).find((name) => !params.includes(name));
+	if (extra !== void 0) return {
+		ok: false,
+		reason: `The attribute has no parameter ${extra}.`
+	};
+	const names = {};
+	for (const name of params) {
+		if (!Object.hasOwn(args, name)) return {
+			ok: false,
+			reason: `The step gives no argument ${name}.`
+		};
+		const value = field(args, name);
+		if (argsKey(value) === void 0) return {
+			ok: false,
+			reason: `The argument ${name} is not JSON data.`
+		};
+		Object.defineProperty(names, name, {
+			value,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	return {
+		ok: true,
+		names,
+		key: argsKey(names)
+	};
+}
+/**
+* This function gives the key of a JSON value (D124). The fields of a record are in the order of their names. Two
+* values have the same key only when they are equal by DOC.EQUALS, thus `-0` and `0` have different keys.
+*
+* @param value - The value.
+* @returns The JSON text, or `undefined` for a value that is not JSON data: a number that is not finite, a host value or a cycle.
+*/
+function argsKey(value) {
+	return keyOf$1(value, /* @__PURE__ */ new Set());
+}
+function keyOf$1(value, open) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") return !Number.isFinite(value) ? void 0 : Object.is(value, -0) ? "-0" : JSON.stringify(value);
+	if (typeof value !== "object" || open.has(value) || !Array.isArray(value) && !isRecord(value)) return void 0;
+	open.add(value);
+	try {
+		const list = Array.isArray(value);
+		const names = list ? [] : Object.keys(value).sort();
+		const items = list ? value.map((item) => keyOf$1(item, open)) : names.map((name) => keyOf$1(field(value, name), open));
+		if (items.includes(void 0)) return void 0;
+		return list ? `[${items.join(",")}]` : `{${names.map((name, index) => `${JSON.stringify(name)}:${String(items[index])}`).join(",")}}`;
+	} finally {
+		open.delete(value);
+	}
+}
+/**
 * This function gives the type of a bare equation of a kind (D42). It is the type `of` of the shape of its parts, or
 * else the type `of` of the shape `rest` of a record. The plan, the reference and `check` read it with this one function.
 *
@@ -5484,14 +5570,24 @@ const STD_WORLD = {
 			pure: true,
 			summary: "A step of a path: it follows a key again and again, until it reaches a node of a type."
 		},
-		tree: { kinds: { named: {
-			verbs: {
-				step: "walk.named",
-				view: "view.card"
+		tree: { kinds: {
+			named: {
+				verbs: {
+					step: "walk.named",
+					view: "view.card"
+				},
+				pure: true,
+				summary: "A step of a path: it goes up to the nearest registry of names, and it gives the node with the name (TREE.NAMED)."
 			},
-			pure: true,
-			summary: "A step of a path: it goes up to the nearest registry of names, and it gives the node with the name (TREE.NAMED)."
-		} } },
+			at: {
+				verbs: {
+					step: "walk.tree.at",
+					view: "view.card"
+				},
+				pure: true,
+				summary: "A step of a path: it reads an attribute with parameters of the node before it, with the arguments of the step (TREE.AT)."
+			}
+		} },
 		panel: {
 			verbs: {
 				eval: "tree.node",
@@ -5737,6 +5833,12 @@ const WORLD_SYNTAX = /* @__PURE__ */ Object.freeze({
 				args: "named",
 				fields: ["name", "in"]
 			},
+			{
+				name: "tree.at",
+				kind: "tree.at",
+				args: "named",
+				fields: ["attr", "args"]
+			},
 			{
 				name: "add",
 				kind: "add"
@@ -6328,6 +6430,80 @@ function collected(root, key, declared) {
 	return acc;
 }
 /**
+* The host things that answer the step `tree.at` with their own function (D124). A node of the reference is in it, and
+* its fields do not change. The walker reads the state of a node of the kit.
+*/
+const AT_READERS = /* @__PURE__ */ new WeakMap();
+/** The memo of the instances of the attributes with parameters of each node, without the cells of a host (TREE.AT). */
+const atMemos = /* @__PURE__ */ new WeakMap();
+/** The second key of each key of a node, for the cells of the attributes with parameters (TREE.AT-CELL). */
+const atPlaces = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives an instance of an attribute with parameters of a node (TREE.AT, D124). The equation in
+* `tree.at` of the kind of the node evaluates with the arguments as names. The memo keeps one result for each key of
+* the arguments, and a demand of an instance in evaluation gives `#CYCLE!`. The function is outside the code of
+* `read`, thus a node without such attributes does no new work.
+*/
+function atRead(n, attr, args) {
+	const declared = entryOf(n.tree?.at, attr);
+	if (declared === void 0) return void 0;
+	const rule = atRuleOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${attributeText(attr, n.type, n.place)} has a bad entry tree.at. ${rule.reason}`);
+	const given = atArgsOf(rule.params, args);
+	if (!given.ok) return fail("#VALUE!", `The step tree.at of ${attributeText(attr, n.type, n.place)} has bad arguments. ${given.reason}`);
+	const host = openPoint === void 0 ? n.host : void 0;
+	const place = n.host === void 0 ? n.place : keptAt(atPlaces, n.place, () => Object.freeze([...n.place]));
+	let marks = n.host === void 0 ? atMemos.get(n) : keptAt(marksByPlace, place, () => /* @__PURE__ */ new Map());
+	if (marks === void 0) {
+		marks = /* @__PURE__ */ new Map();
+		atMemos.set(n, marks);
+	}
+	const key = `[${JSON.stringify(attr)},${given.key}]`;
+	const text = attributeText(`${attr} with ${given.key}`, n.type, n.place);
+	const cell = marks.get(key);
+	if (cell !== void 0) return cell.busy ? cycleAt(marks, key, text) : cell.result;
+	const demand = {
+		cells: marks,
+		key,
+		text
+	};
+	const loop = openPoint;
+	const compute = () => ({
+		result: n.equation(rule.equation, given.names),
+		by: "kind"
+	});
+	marks.set(key, BUSY);
+	demands.push(demand);
+	let thrown = NOT_THROWN;
+	let answer;
+	try {
+		answer = host === void 0 ? compute() : host(place, key, () => {
+			try {
+				return compute();
+			} catch (error) {
+				thrown = error;
+				throw error;
+			}
+		});
+	} catch (error) {
+		marks.delete(key);
+		if (host === void 0 || error === thrown) throw error;
+		answer = {
+			result: fail("#CYCLE!", `The cells of the host found a cycle in the demands: ${demands.map((item) => item.text).join(" -> ")}.`, { cause: error }),
+			by: void 0
+		};
+	} finally {
+		demands.pop();
+	}
+	if (n.host !== void 0 || loop?.tentative.has(demand) === true) marks.delete(key);
+	else marks.set(key, {
+		busy: false,
+		result: answer.result,
+		by: answer.by
+	});
+	return answer.result;
+}
+/**
 * This function makes a node of the decorated tree. A step `parent` gives the self of the context of the node, and a
 * step `type` gives its type. Another step reads an attribute through its ladder (TREE.LADDER). The rungs are a part of
 * the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
@@ -6702,10 +6878,40 @@ const named$2 = ({ data, here, deref }) => {
 		reason: `No registry ${registry} is on the way.`
 	};
 };
+/**
+* The walker of the step `tree.at` (TREE.AT, D124). The field `attr` names an attribute with parameters, and the
+* field `args` gives the arguments. The thing before the step is a node. A failed instance throws its own error.
+*/
+const at = ({ data, here }) => {
+	const attr = isRecord(data) ? field(data, "attr") : void 0;
+	if (typeof attr !== "string") return {
+		ok: false,
+		code: "#VALUE!",
+		reason: "The step tree.at needs a text attr."
+	};
+	const args = isRecord(data) && Object.hasOwn(data, "args") ? field(data, "args") : {};
+	const state = stateOf(here);
+	const reader = state === void 0 && typeof here === "object" && here !== null ? AT_READERS.get(here) : void 0;
+	if (state === void 0 && reader === void 0) return {
+		ok: false,
+		reason: `The step tree.at reads ${attr} of a thing that is not a node of a tree.`
+	};
+	const result = state === void 0 ? reader(attr, args) : atRead(state, attr, args);
+	if (result === void 0) return {
+		ok: false,
+		reason: `No rung gives the attribute ${attr} with parameters.`
+	};
+	if (!result.ok) throw new Failure(result.error);
+	return {
+		ok: true,
+		thing: result.value
+	};
+};
 /** The walkers of the standard world, by name. */
 const STD_WALKERS = {
 	"walk.nearest": nearest,
-	"walk.named": named$2
+	"walk.named": named$2,
+	"walk.tree.at": at
 };
 /** This function evaluates parts one after the other, and stops at the first error. */
 function* inOrder(parts) {
@@ -8163,6 +8369,25 @@ function vertexOf(b, node, attribute) {
 	}
 	return id;
 }
+/**
+* This function gives the vertex of an instance of an attribute with parameters (TREE.AT-CHECK, D124). Its name is the
+* name of a plain vertex with the key of the arguments after the name of the attribute.
+*/
+function atVertexOf(b, node, at) {
+	const id = `${attributeVertexId(node.visit.place, at.attr).slice(0, -1)},${at.key}]`;
+	if (!b.vertices.has(id)) {
+		b.vertices.set(id, {
+			id,
+			place: node.visit.place,
+			attribute: at.attr,
+			type: node.text,
+			args: at.names
+		});
+		b.nodes.set(id, node);
+		b.work.push(id);
+	}
+	return id;
+}
 function edge(b, from, r, lazy = false) {
 	b.edges.push({
 		from,
@@ -8252,6 +8477,14 @@ function follow(b, start, path, from, r) {
 			}
 			continue;
 		}
+		if (isAtStep(b.machine, step)) {
+			const at = atStepOf(node.kind, node.text, step.value);
+			if (at.kind === "unknown") edge(b, void 0, r);
+			if (at.kind !== "exact") return;
+			edge(b, atVertexOf(b, node, at), r);
+			here = "unknown";
+			continue;
+		}
 		if (walkerOf(b.machine, step) !== STD_WALKERS["walk.nearest"]) {
 			edge(b, void 0, r);
 			return;
@@ -8327,7 +8560,10 @@ function termReads(b, refs, self, names, r) {
 		const name = String(ref.path[1]);
 		let start;
 		if (ref.bound.has(name)) start = "unknown";
-		else if (names?.child !== void 0 && name === "child") start = { node: names.child };
+		else if (names?.params !== void 0) {
+			if (!names.params.includes(name)) continue;
+			start = "data";
+		} else if (names?.child !== void 0 && name === "child") start = { node: names.child };
 		else if (names?.prev !== void 0 && name === "prev") start = names.prev;
 		else if (name === "index") start = "data";
 		else if (name === "acc" || name === "item") start = "unknown";
@@ -8351,7 +8587,8 @@ function prevOf(parent, child) {
 */
 function rungReads(b, id) {
 	const node = b.nodes.get(id);
-	const key = b.vertices.get(id).attribute;
+	const vertex = b.vertices.get(id);
+	const key = vertex.attribute;
 	const tree = node.kind.tree;
 	const r = {
 		to: id,
@@ -8359,6 +8596,14 @@ function rungReads(b, id) {
 		place: node.visit.place,
 		at: node.visit.at
 	};
+	if (vertex.args !== void 0) {
+		const at = atStepOf(node.kind, node.text, {
+			attr: key,
+			args: vertex.args
+		});
+		if (at.kind === "exact") termReads(b, termRefs(b, node.kind, `tree.at.${key}`, at.equation), node, { params: at.params }, r);
+		return;
+	}
 	const equation = hasOwnEntry(tree?.equations, key) ? tree?.equations?.[key] : void 0;
 	if (equation !== void 0) {
 		termReads(b, termRefs(b, node.kind, `tree.equations.${key}`, equation), node, void 0, r);
@@ -8622,7 +8867,7 @@ function allCircular(b, ids) {
 	return ids.every((id) => b.vertices.get(id)?.circular === true);
 }
 function vertexText(vertex) {
-	return `${vertex.attribute} of ${vertex.type} at [${vertex.place.join(", ")}]`;
+	return `${vertex.args === void 0 ? vertex.attribute : `${vertex.attribute} with ${String(argsKey(vertex.args))}`} of ${vertex.type} at [${vertex.place.join(", ")}]`;
 }
 /**
 * This function finds each certain cycle of the attributes of a document before a run (TREE.GRAPH-CYCLE, D107). A run
@@ -9228,6 +9473,17 @@ function equationsOf(kind) {
 		down: false,
 		contributes: true
 	});
+	for (const [name, declared] of Object.entries(tree.at ?? {})) {
+		const rule = atRuleOf(declared);
+		if (rule.ok) out.push({
+			label: `tree.at.${name}`,
+			term: rule.equation,
+			names: rule.params,
+			attribute: name,
+			down: false,
+			at: true
+		});
+	}
 	return out;
 }
 /**
@@ -9373,7 +9629,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 		own: void 0,
 		parent: void 0
 	};
-	for (const { label, term, names, attribute, down, contributes } of equationsOf(kind)) {
+	for (const { label, term, names, attribute, down, contributes, at } of equationsOf(kind)) {
 		const inner = {
 			names,
 			...of === void 0 ? {} : { declaredType: of },
@@ -9383,7 +9639,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 			needs.push({
 				name,
 				why: `the equation ${label} reads it`,
-				hidden: down || contributes === true ? void 0 : attribute
+				hidden: down || contributes === true || at === true ? void 0 : attribute
 			});
 		};
 		for (const issue of checkAll(machine, term, inner, void 0, state, {
@@ -9401,7 +9657,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 * This function finds the issues of the contract of a tree kind (TREE.CHECK-RESERVED). An attribute with the name of a
 * structural step gets no read. A tree kind of the run side contradicts the evaluation on demand of its attributes. A
 * declaration `circular` without a start value or with a bad limit gives `#VALUE!` (TREE.CIRCULAR-CHECK). A declaration
-* `collect` without its form gives `#VALUE!` too (TREE.COLLECT).
+* `collect` without its form gives `#VALUE!` too (TREE.COLLECT). So does an entry of `at` without its form (TREE.AT-CHECK).
 */
 function contractIssues(kind, kindText) {
 	const out = [];
@@ -9410,7 +9666,8 @@ function contractIssues(kind, kindText) {
 		"equations",
 		"down",
 		"attributes",
-		"contributes"
+		"contributes",
+		"at"
 	]) for (const name of Object.keys(tree?.[table] ?? {})) {
 		const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : void 0;
 		if (why !== void 0) out.push({
@@ -9433,6 +9690,14 @@ function contractIssues(kind, kindText) {
 			reason: `The kind ${kindText} has a bad declaration tree.attributes.${name}.collect. ${collect.reason}`
 		});
 	}
+	for (const [name, declared] of Object.entries(tree?.at ?? {})) {
+		const rule = atRuleOf(declared);
+		if (!rule.ok) out.push({
+			code: "#VALUE!",
+			place: [],
+			reason: `The kind ${kindText} has a bad entry tree.at.${name}. ${rule.reason}`
+		});
+	}
 	if (kind.side === "run") out.push({
 		code: "#CALC!",
 		place: [],
@@ -9478,7 +9743,7 @@ function nodeIssues(machine, node, state, v) {
 * This function examines a reference from the root `self` (TREE.CHECK-UNKNOWN). The steps `parent` go up the known
 * nodes. The first other key names an attribute of the node that they reach. When no rung answers the attribute, the
 * function gives the index of the step and the reason. In an equation, a read of the node of the equation goes to the
-* needs of its kind.
+* needs of its kind. A step `tree.at` with literal arguments gets the checks of TREE.AT-CHECK.
 */
 function readIssue(machine, self, path, rootSelf) {
 	let node = self;
@@ -9488,6 +9753,14 @@ function readIssue(machine, self, path, rootSelf) {
 		index += 1;
 	}
 	const step = path[index];
+	if (node !== void 0 && isAtStep(machine, step)) {
+		const at = atStepOf(node.kind, node.text, step.value);
+		return at.kind === "issue" ? {
+			index,
+			reason: at.reason,
+			code: at.code
+		} : void 0;
+	}
 	if (node === void 0 || !isKey(step) || Object.hasOwn(STRUCTURAL, String(step))) return void 0;
 	const name = String(step);
 	if (node.own === void 0) {
@@ -9499,6 +9772,52 @@ function readIssue(machine, self, path, rootSelf) {
 		reason: `No rung gives the attribute ${name} of the kind ${node.text}.`
 	};
 }
+/** This function tells if a step of a path is a step `tree.at` of the standard walker (TREE.AT, D124). */
+function isAtStep(machine, step) {
+	return isEnvelope(step) && walkerOf(machine, step) === STD_WALKERS["walk.tree.at"];
+}
+/**
+* This function examines the data of a step `tree.at` on a node of a known kind (TREE.AT-CHECK, D124). `check` and the
+* graph of attribute instances read the step with this one function.
+*/
+function atStepOf(kind, kindText, data) {
+	if (holdsDocument(data)) return { kind: "unknown" };
+	const attr = isRecord(data) ? field(data, "attr") : void 0;
+	if (typeof attr !== "string") return {
+		kind: "issue",
+		code: "#VALUE!",
+		reason: "The step tree.at needs a text attr."
+	};
+	const table = kind.tree?.at;
+	const declared = table !== void 0 && Object.hasOwn(table, attr) ? table[attr] : void 0;
+	if (declared === void 0) return {
+		kind: "issue",
+		code: "#N/A",
+		reason: `No rung gives the attribute ${attr} with parameters of the kind ${kindText}.`
+	};
+	const rule = atRuleOf(declared);
+	if (!rule.ok) return { kind: "unknown" };
+	const given = atArgsOf(rule.params, isRecord(data) && Object.hasOwn(data, "args") ? field(data, "args") : {});
+	if (!given.ok) return {
+		kind: "issue",
+		code: "#VALUE!",
+		reason: `The step tree.at of ${attr} of the kind ${kindText} has bad arguments. ${given.reason}`
+	};
+	return {
+		kind: "exact",
+		attr,
+		key: given.key,
+		equation: rule.equation,
+		params: rule.params,
+		names: given.names
+	};
+}
+/** This function tells if a value holds a document. A document in the data of a step can be a part, thus only the run knows its value. */
+function holdsDocument(value) {
+	if (isEnvelope(value)) return true;
+	if (Array.isArray(value)) return value.some(holdsDocument);
+	return isRecord(value) && Object.values(value).some(holdsDocument);
+}
 /**
 * This function finds the issues of `check`. With a list of nodes, it also records each document that it visits for
 * the pass of types. It marks each document with an issue. The state holds the kinds whose equations the check
@@ -9685,7 +10004,7 @@ function checkAll(machine, doc, options, nodes, state = {
 		if (attributes && root === "self" && v.address !== true && name === "ref.resolve") {
 			const issue = readIssue(machine, self, path, rootSelf);
 			if (issue !== void 0) push({
-				code: "#N/A",
+				code: issue.code ?? "#N/A",
 				place: v.place,
 				reason: issue.reason,
 				at: stepAt(issue.index)
@@ -10928,17 +11247,26 @@ function formulaCode(profile) {
 				}
 				return known;
 			};
+			const limit = Math.ceil((machine.maxDepth ?? 1e3) / 4);
 			return (ctx, rt) => {
 				rt.keepsContext?.(ctx, reads);
+				const clock = rt;
 				const closure = (...args) => {
-					const scope = { ...ctx.names };
-					names.forEach((name, index) => setOwn$2(scope, name, args[index]));
-					const result = body.code({
-						...ctx,
-						names: scope
-					}, rt);
-					if (!result.ok) throw new Failure(result.error);
-					return result.value;
+					const level = (clock.applying ?? 0) + 1;
+					if (level > limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+					clock.applying = level;
+					try {
+						const scope = { ...ctx.names };
+						names.forEach((name, index) => setOwn$2(scope, name, args[index]));
+						const result = body.code({
+							...ctx,
+							names: scope
+						}, rt);
+						if (!result.ok) throw new Failure(result.error);
+						return result.value;
+					} finally {
+						clock.applying = level - 1;
+					}
 				};
 				Object.defineProperty(closure, CLOSURE$2, { value: { params: names } });
 				return ok(closure);
@@ -12825,6 +13153,7 @@ function envOf(machine, options, running, root, outer) {
 			alls: 0
 		},
 		held: 0,
+		applying: 0,
 		reading: outer ?? (options.reads === void 0 ? void 0 : {
 			list: options.reads,
 			root
@@ -13175,6 +13504,51 @@ function attributeOf(node, name) {
 	if (!entry.tentative && result !== void 0) node.values.set(name, result);
 	return result;
 }
+/** TREE.AT: the instances of each node of the reference. Two arguments are the same instance by DOC.EQUALS. */
+const refInstances = /* @__PURE__ */ new WeakMap();
+/**
+* TREE.AT: the instance of an attribute with parameters, or `undefined` when the kind has no entry in `tree.at`. The
+* equation sees the arguments as names. A demand of an instance in evaluation gives `#CYCLE!`, also in a fixed point.
+*/
+function instanceOf$1(node, attr, args) {
+	const declared = termIn(node.contract?.at, attr);
+	if (declared === void 0) return void 0;
+	const rule = atRuleOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${nameOfAttribute(node, attr)} has a bad entry tree.at. ${rule.reason}`);
+	const given = atArgsOf(rule.params, args);
+	if (!given.ok) return fail("#VALUE!", `The step tree.at of ${nameOfAttribute(node, attr)} has bad arguments. ${given.reason}`);
+	const name = `${attr} with ${given.key}`;
+	const list = refInstances.get(node) ?? [];
+	refInstances.set(node, list);
+	const found = list.find((item) => item.attr === attr && docEquals(item.names, given.names));
+	if (found?.result !== void 0) return found.result;
+	if (found !== void 0) {
+		const from = inEvaluation.findIndex((entry) => entry.node === node && entry.name === name);
+		return fail("#CYCLE!", `The attributes form a cycle: ${[...inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name)), nameOfAttribute(node, name)].join(" -> ")}.`);
+	}
+	const item = {
+		attr,
+		names: given.names,
+		result: void 0
+	};
+	list.push(item);
+	const entry = {
+		node,
+		name,
+		circular: false,
+		tentative: false
+	};
+	inEvaluation.push(entry);
+	let result;
+	try {
+		result = equationOf(node, rule.equation, given.names);
+	} finally {
+		inEvaluation.pop();
+		if (result === void 0 || entry.tentative) list.splice(list.indexOf(item), 1);
+		else item.result = result;
+	}
+	return result;
+}
 /** TREE.RESULT: the JSON of a node. `open` holds the nodes and the containers whose JSON is in progress. */
 function jsonOfNode(node, self, open) {
 	const record = {};
@@ -13261,6 +13635,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	};
 	node.thing = self;
 	refNodes.set(self, node);
+	AT_READERS.set(self, (attr, args) => instanceOf$1(node, attr, args));
 	if (nested) return ok(self);
 	try {
 		return jsonOfNode(node, self, []);
@@ -13387,16 +13762,27 @@ function formulaDefinitions(profile = {}) {
 		if (!Array.isArray(params) || !params.every((param) => typeof param === "string") || new Set(params).size !== params.length) return fail("#VALUE!", "The params of fn are a list of different texts.");
 		const names = params;
 		const body = partNamed(parts, "body");
+		const clock = activeEnvs[activeEnvs.length - 1] ?? {
+			applying: 0,
+			maxDepth: 1e3
+		};
+		const limit = Math.ceil(clock.maxDepth / 4);
 		const closure = (...args) => {
-			const scope = {};
-			for (const key of Object.keys(context.names)) setField$1(scope, key, context.names[key]);
-			names.forEach((name, index) => setField$1(scope, name, args[index]));
-			const result = body.evaluate({
-				...context,
-				names: scope
-			});
-			if (!result.ok) throw new Failure(result.error);
-			return result.value;
+			if (clock.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+			clock.applying += 1;
+			try {
+				const scope = {};
+				for (const key of Object.keys(context.names)) setField$1(scope, key, context.names[key]);
+				names.forEach((name, index) => setField$1(scope, name, args[index]));
+				const result = body.evaluate({
+					...context,
+					names: scope
+				});
+				if (!result.ok) throw new Failure(result.error);
+				return result.value;
+			} finally {
+				clock.applying -= 1;
+			}
 		};
 		Object.defineProperty(closure, CLOSURE$1, { value: { params: names } });
 		return ok(closure);
@@ -18002,6 +18388,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, collectOf, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, collectOf, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map