@mark1russell7/coeval 0.20.1 → 0.22.0

package/src/providers.ts

@@ -33,13 +33,106 @@ const NOTES: ReadonlySet<string> = /* @__PURE__ */ new Set([
 ]);
 
 /** The keywords that the reading reads. Each other keyword gives an issue and tests nothing. */
-const READ: ReadonlySet<string> = /* @__PURE__ */ new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "const", "anyOf", "oneOf"]);
+const READ: ReadonlySet<string> = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "enum",
+  "const",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "$ref",
+]);
+
+/**
+ * The keywords that can permit more values than the other keywords permit. A dynamic reference can reach a schema
+ * outside this schema, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
+ */
+const WIDENING: ReadonlySet<string> = /* @__PURE__ */ new Set(["$dynamicRef", "$recursiveRef", "nullable"]);
+
+/** The keywords of an object without the keyword `type`. They test only the values that are records. */
+const OBJECT_KEYS: readonly string[] = ["properties", "required", "additionalProperties"];
+
+/** The form of a local reference: a definition in `$defs` or `definitions` of the root schema. */
+const LOCAL_REF = /^#\/(\$defs|definitions)\/([^/]*)$/;
+
+/** The most pairs of members that the meet of two unions builds. A larger meet keeps the first type, which is sound. */
+const MAX_MEET_PAIRS = 64;
+
+/** The keywords of one JSON type without the keyword `type`: they test only the records or only the lists. */
+interface Condition {
+  readonly on: "record" | "list";
+  readonly type: ValueType;
+  readonly at: readonly Key[];
+}
+
+/** A record type of the reading. */
+type RecordType = Extract<ValueType, { readonly record: unknown }>;
+
+/** This function tells if a field of a record type can be absent. */
+function isOptional(type: RecordType, key: string): boolean {
+  return type.optional?.includes(key) === true;
+}
 
 /**
- * The keywords that can permit more values than the other keywords permit. Older drafts ignore each keyword beside
- * `$ref`, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
+ * This function gives the meet of two types of a reading: a type that holds each value of both types. A schema is
+ * the conjunction of its keywords, thus its type is the meet of their types. The meet is exact for the forms that a
+ * reading makes: base types, lists, records, unions and `one`. A meet of two different forms is `never`.
  */
-const WIDENING: ReadonlySet<string> = /* @__PURE__ */ new Set(["$ref", "$dynamicRef", "$recursiveRef", "nullable"]);
+function meet(a: ValueType, b: ValueType, depth: number): ValueType {
+  if (depth > MAX_SCHEMA_DEPTH) return a;
+  if (isUnknown(a, undefined)) return b;
+  if (isUnknown(b, undefined)) return a;
+  if (a === "never" || b === "never") return "never";
+  if (typeof a !== "string" && "one" in a) return { one: a.one.filter((value) => member(value, b)) };
+  if (typeof b !== "string" && "one" in b) return { one: b.one.filter((value) => member(value, a)) };
+  if (typeof b !== "string" && "union" in b && !(typeof a !== "string" && "union" in a)) return meet(b, a, depth);
+  if (typeof a !== "string" && "union" in a) {
+    const others = typeof b !== "string" && "union" in b ? b.union : [b];
+    if (a.union.length * others.length > MAX_MEET_PAIRS) return a;
+    return unionOf(a.union.flatMap((item) => others.map((other) => meet(item, other, depth + 1))));
+  }
+  if (typeof a === "string" || typeof b === "string") return a === b ? a : "never";
+  if ("list" in a && "list" in b) return { list: meet(a.list, b.list, depth + 1) };
+  if ("record" in a && "record" in b) return meetRecords(a, b, depth + 1);
+  // A list and a record have no common value. Each other pair keeps the first type, which is sound.
+  return ("list" in a || "record" in a) && ("list" in b || "record" in b) ? "never" : a;
+}
+
+/**
+ * This function gives the meet of two record types. A field of both records gets the meet of its types, and it is
+ * optional only when both records permit its absence. A closed record has no other field, thus a field of only the
+ * other record is absent. When the other record needs that field, no value fits both records.
+ */
+function meetRecords(a: RecordType, b: RecordType, depth: number): ValueType {
+  const fields: Record<string, ValueType> = {};
+  const optional: string[] = [];
+  const keys = [...Object.keys(a.record), ...Object.keys(b.record).filter((key) => !Object.hasOwn(a.record, key))];
+  for (const key of keys) {
+    const inA = Object.hasOwn(a.record, key);
+    const inB = Object.hasOwn(b.record, key);
+    if ((!inA && a.closed === true) || (!inB && b.closed === true)) {
+      if ((inA && !isOptional(a, key)) || (inB && !isOptional(b, key))) return "never";
+      continue;
+    }
+    const type = inA && inB ? meet(a.record[key] as ValueType, b.record[key] as ValueType, depth) : ((inA ? a.record[key] : b.record[key]) as ValueType);
+    setOwn(fields, key, type);
+    if ((!inA || isOptional(a, key)) && (!inB || isOptional(b, key))) optional.push(key);
+  }
+  const closed = a.closed === true || b.closed === true;
+  return { record: fields, ...(optional.length === 0 ? {} : { optional }), ...(closed ? { closed: true } : {}) };
+}
+
+/** This function applies a condition to a type: each member of the JSON type of the condition meets its type. */
+function narrow(type: ValueType, condition: Condition): ValueType {
+  if (typeof type === "string") return type;
+  if ("union" in type) return unionOf(type.union.map((item) => narrow(item, condition)));
+  if ("one" in type) return { one: type.one.filter((value) => !(condition.on === "list" ? Array.isArray(value) : isRecord(value)) || member(value, condition.type)) };
+  return condition.on in type ? meet(type, condition.type, 0) : type;
+}
 
 /** The base type of each name of the keyword `type`. */
 const BASES: Readonly<Record<string, ValueType>> = { null: "null", boolean: "bool", number: "number", integer: "number", string: "text" };
@@ -55,25 +148,55 @@ function unionOf(types: readonly ValueType[]): ValueType {
   return types.reduce<ValueType>((all, type) => join(all, type), "never");
 }
 
-/** The state of one reading of a schema: the issues that it found. */
+/** The state of one reading of a schema: the root, the issues and the definitions that it read. */
 class SchemaReader {
   readonly issues: TypeIssue[] = [];
+  /** The type of each definition that a reference reached. Each reading of a definition is sound, thus the first stays. */
+  readonly defs = new Map<string, ValueType>();
+  /** The definitions that the reading has not finished. A reference to one of them is a cycle. */
+  readonly open = new Set<string>();
+  /** The number of schemas with an own `$id` around the current schema. A reference inside them has another base. */
+  inner = 0;
+
+  constructor(readonly root: unknown) {}
 
   issue(at: readonly Key[], reason: string): void {
     this.issues.push({ at, reason });
   }
 
-  /** This method reads one schema. */
+  /** This method reads one schema: the meet of the types of its keywords, then its conditions. */
   read(schema: unknown, at: readonly Key[], depth: number): ValueType {
+    const types: ValueType[] = [];
+    const conditions: Condition[] = [];
+    this.parts(schema, at, depth, types, conditions);
+    let type = types.reduce<ValueType>((all, item) => meet(all, item, 0), "unknown");
+    for (const condition of conditions) {
+      if (isUnknown(type, undefined)) {
+        this.issue(condition.at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
+        break;
+      }
+      type = narrow(type, condition);
+    }
+    return type;
+  }
+
+  /**
+   * This method adds the type of each keyword of a schema to `types`, and its conditions to `conditions`. Each type
+   * holds each value that the schema accepts. The parts of `allOf` add their keywords too.
+   */
+  parts(schema: unknown, at: readonly Key[], depth: number, types: ValueType[], conditions: Condition[]): void {
     if (depth > MAX_SCHEMA_DEPTH) {
       this.issue(at, `The schema is deeper than ${MAX_SCHEMA_DEPTH} levels. The type reads it as unknown.`);
-      return "unknown";
+      return;
+    }
+    if (schema === true) return;
+    if (schema === false) {
+      types.push("never");
+      return;
     }
-    if (schema === true) return "unknown";
-    if (schema === false) return "never";
     if (!isRecord(schema)) {
       this.issue(at, "A schema is a record or a truth value. The type reads this value as unknown.");
-      return "unknown";
+      return;
     }
     let widens = false;
     for (const key of Object.keys(schema)) {
@@ -85,31 +208,85 @@ class SchemaReader {
         this.issue([...at, key], `The type does not read the keyword ${key}. It does not test what the keyword tests.`);
       }
     }
-    if (widens) return "unknown";
-    // A schema is the conjunction of its keywords. The reading keeps one of them, and each one alone holds each value.
-    const sides: { readonly key: string; readonly type: ValueType }[] = [];
-    if (Object.hasOwn(schema, "type")) sides.push({ key: "type", type: this.byType(schema, at, depth) });
-    else if (["properties", "required", "additionalProperties", "items"].some((key) => Object.hasOwn(schema, key)) && !["enum", "const", "anyOf", "oneOf"].some((key) => Object.hasOwn(schema, key))) {
-      this.issue(at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
+    if (widens) return;
+    const nested = schema !== this.root && Object.hasOwn(schema, "$id");
+    if (nested) this.inner += 1;
+    try {
+      this.keywords(schema, at, depth, types, conditions);
+    } finally {
+      if (nested) this.inner -= 1;
+    }
+  }
+
+  /** This method reads the keywords of a schema that does not permit more values (WIDENING). */
+  keywords(schema: Readonly<Record<string, unknown>>, at: readonly Key[], depth: number, types: ValueType[], conditions: Condition[]): void {
+    if (Object.hasOwn(schema, "$ref")) {
+      // Older drafts ignore each keyword beside $ref. The target alone holds each value in each draft.
+      for (const key of Object.keys(schema)) if (READ.has(key) && key !== "$ref") this.issue([...at, key], `The type reads only the target of $ref. It does not test the keyword ${key} beside it.`);
+      const type = this.target(schema["$ref"], [...at, "$ref"], depth);
+      if (type !== undefined) types.push(type);
+      return;
+    }
+    if (Object.hasOwn(schema, "type")) types.push(this.byType(schema, at, depth));
+    else {
+      if (OBJECT_KEYS.some((key) => Object.hasOwn(schema, key))) conditions.push({ on: "record", type: this.object(schema, at, depth), at });
+      if (Object.hasOwn(schema, "items")) conditions.push({ on: "list", type: this.array(schema, at, depth), at });
     }
-    for (const key of ["anyOf", "oneOf"]) {
+    for (const key of ["anyOf", "oneOf", "allOf"]) {
       if (!Object.hasOwn(schema, key)) continue;
       const items = schema[key];
       if (!Array.isArray(items)) {
         this.issue([...at, key], `The value of ${key} is a list of schemas.`);
         continue;
       }
+      // Each part of allOf holds each value of the schema, thus its keywords join the keywords of the schema.
+      if (key === "allOf") for (const [index, item] of items.entries()) this.parts(item, [...at, key, index], depth + 1, types, conditions);
       // A union holds each value of oneOf too. It does not test that only one schema fits.
-      sides.push({ key, type: unionOf(items.map((item, index) => this.read(item, [...at, key, index], depth + 1))) });
+      else types.push(unionOf(items.map((item, index) => this.read(item, [...at, key, index], depth + 1))));
     }
-    // A finite set of values meets each other keyword exactly: the type keeps each value that each side holds.
     const values = this.values(schema, at);
-    if (values !== undefined) return { one: values.filter((value) => sides.every((side) => member(value, side.type))) };
-    const known = sides.filter((side) => !isUnknown(side.type, undefined));
-    const kept = known[0];
-    if (kept === undefined) return "unknown";
-    for (const side of known.slice(1)) this.issue([...at, side.key], `The type reads the keyword ${kept.key}, and not the keyword ${side.key}.`);
-    return kept.type;
+    if (values !== undefined) types.push({ one: values });
+  }
+
+  /** This method reads the target of a reference: a definition of the root schema, or `undefined` for each value. */
+  target(ref: unknown, at: readonly Key[], depth: number): ValueType | undefined {
+    const match = typeof ref === "string" ? LOCAL_REF.exec(ref) : null;
+    let name: string | undefined;
+    try {
+      // The name is a step of a JSON Pointer in a URI fragment.
+      name = match === null ? undefined : decodeURIComponent(match[2] ?? "").replace(/~1/g, "/").replace(/~0/g, "~");
+    } catch {
+      name = undefined;
+    }
+    if (match === null || name === undefined) {
+      this.issue(at, "The type reads only a $ref to #/$defs/<name> or #/definitions/<name> of the same schema. Thus it reads the schema as unknown.");
+      return undefined;
+    }
+    if (this.inner > 0) {
+      this.issue(at, "A $ref inside a schema with its own $id has another base. Thus the type reads the schema as unknown.");
+      return undefined;
+    }
+    const group = match[1] as string;
+    const defs = isRecord(this.root) ? this.root[group] : undefined;
+    if (!isRecord(defs) || !Object.hasOwn(defs, name)) {
+      this.issue(at, `The schema has no definition ${String(ref)}. Thus the type reads the reference as unknown.`);
+      return undefined;
+    }
+    const key = `${group}/${name}`;
+    const known = this.defs.get(key);
+    if (known !== undefined) return known;
+    if (this.open.has(key)) {
+      this.issue(at, `The reference ${String(ref)} is in a cycle. The type reads this reference as unknown.`);
+      return undefined;
+    }
+    this.open.add(key);
+    try {
+      const type = this.read(defs[name], [group, name], depth + 1);
+      this.defs.set(key, type);
+      return type;
+    } finally {
+      this.open.delete(key);
+    }
   }
 
   /** This method reads `enum` and `const`: the values that the schema permits, or `undefined` without them. */
@@ -196,17 +373,20 @@ class SchemaReader {
  * - `properties`, `required` and `additionalProperties` give a record. `false` closes it, and a property that is not
  *   in `required` is optional.
  * - `items` gives a list. `enum` and `const` give `one`. `anyOf` and `oneOf` give a union.
+ * - `$ref` reads a definition in `$defs` or `definitions` of the same schema (TYPE.SCHEMA-REF). Another reference, a
+ *   missing definition and a reference in a cycle read as `unknown`.
+ * - `allOf` and the other keywords of a schema give the meet of their types (TYPE.SCHEMA-ALLOF). Records merge their
+ *   fields, and a closed part keeps the merge closed.
  *
  * The type holds each value that the schema accepts. Each keyword that the function does not read tests nothing, as
- * `unknown`, and the issues name it. Examples are `minimum`, `pattern` and `allOf`. A schema with `$ref` or `nullable`
- * reads as `unknown`, because these keywords can permit more values. A schema with more than one of `type`, `anyOf`
- * and `oneOf` gives the type of the first, and an issue for each other. The function does not throw.
+ * `unknown`, and the issues name it. Examples are `minimum` and `pattern`. A schema with `nullable` or `$dynamicRef`
+ * reads as `unknown`, because these keywords can permit more values. The function does not throw.
  *
  * @param schema - The schema, as JSON.
  * @returns The type, and the problems of the reading with their keys in the schema.
  */
 export function typeFromSchema(schema: unknown): TypeReading {
-  const reader = new SchemaReader();
+  const reader = new SchemaReader(schema);
   try {
     return { type: reader.read(schema, [], 0), issues: reader.issues };
   } catch (error) {

package/src/reference.ts

@@ -1,9 +1,9 @@
 import { type Envelope, type Json, type Key, docEquals, isEnvelope, isKey, isRecord, typeName } from "./doc.ts";
 import { ask } from "./ladder.ts";
-import { type AttributeDeclaration, type CapsRule, type CircularRule, type Kind, type TreeContract, circularOf, equationType, lookupKind } from "./world.ts";
+import { type AttributeDeclaration, type CapsRule, type CircularRule, type Kind, type TreeContract, atArgsOf, atRuleOf, circularOf, collectOf, equationType, lookupKind } from "./world.ts";
 import { type PartSlot, type Split, partsOf, pathMatches } from "./parts.ts";
 import { type Cap, type Context, type HostThing, type Resolution, type ResolveOptions, type Thing, ROOTS, THING, isHostThing, resolve, valueOfThing, worldThing } from "./deref.ts";
-import { type AttributeRung, STD_EVALUATORS } from "./stdlib.ts";
+import { type AttributeRung, AT_READERS, STD_EVALUATORS } from "./stdlib.ts";
 import { type EvalError, type Failed, type Result, Failure, describe, fail, ok, placed, thrown } from "./errors.ts";
 import {
   type AllOptions,
@@ -113,6 +113,8 @@ interface Env {
   scope: Scope;
   /** The count of the drives without a wait that are active. In a run, an effect under one does not reach the host (RUN.HELD). */
   held: number;
+  /** The count of the applications of closures that run at this time: the clock of `call` (FORMULA.CALL-DEPTH, D125). */
+  applying: number;
   /** The record of the reads. A nested evaluation for an equation of a tree keeps the record of its tree. */
   readonly reading: Reading | undefined;
 }
@@ -674,6 +676,7 @@ function envOf(machine: Machine, options: ReferenceOptions, running: boolean, ro
     verb: options.verb ?? "eval",
     scope: { prefix: "", counts: new Map(), alls: 0 },
     held: 0,
+    applying: 0,
     reading: outer ?? (options.reads === undefined ? undefined : { list: options.reads, root }),
   };
 }
@@ -754,6 +757,8 @@ interface RefTree {
 interface RefNode {
   readonly tree: RefTree;
   readonly kind: string;
+  /** The binding name from the header of the document of the node (TREE.NAMED). */
+  readonly name: string | undefined;
   readonly place: readonly Key[];
   readonly parts: readonly Part[];
   readonly ctx: Context;
@@ -831,6 +836,52 @@ function foldOf(node: RefNode, name: string, fold: NonNullable<AttributeDeclarat
   return acc;
 }
 
+/**
+ * TREE.COLLECT and TREE.NAMED: the node, then each node of this tree in each list `children`, in the order of the
+ * lists. Each node counts one time. The registry `names` maps each binding name to its node.
+ */
+function collectIn(node: RefNode, name: string, declared: unknown): Result {
+  const rule = collectOf(declared);
+  if (!rule.ok) return fail("#VALUE!", `The attribute ${nameOfAttribute(node, name)} has a bad declaration collect. ${rule.reason}`);
+  const registry: Record<string, unknown> = {};
+  const first = new Map<string, RefNode>();
+  let acc: Result = rule.names ? ok(registry) : equationOf(node, rule.unit, {});
+  if (!acc.ok) return acc;
+  const done: RefNode[] = [];
+  // The contribution of a node comes before the nodes of its list children. A failure ends the collection.
+  const visit = (at: RefNode): Result | undefined => {
+    if (done.includes(at)) return undefined;
+    done.push(at);
+    if (rule.names && at.name !== undefined) {
+      const earlier = first.get(at.name);
+      if (earlier !== undefined) {
+        return fail("#VALUE!", `Two nodes have the name ${at.name} in the registry ${nameOfAttribute(node, name)}: ${earlier.kind} at [${earlier.place.join(", ")}] and ${at.kind} at [${at.place.join(", ")}].`);
+      }
+      first.set(at.name, at);
+      Object.defineProperty(registry, at.name, { value: at.thing, enumerable: true, writable: true, configurable: true });
+    }
+    const term = rule.names ? undefined : termIn(at.contract?.contributes, name);
+    if (!rule.names && term !== undefined) {
+      const item = equationOf(at, term, {});
+      if (!item.ok) return item;
+      acc = equationOf(node, rule.combine, { acc: acc.ok ? acc.value : null, item: item.value });
+      if (!acc.ok) return acc;
+    }
+    const children = attributeOf(at, "children");
+    if (children === undefined) return undefined;
+    if (!children.ok) return children;
+    if (!Array.isArray(children.value)) return fail("#VALUE!", `The collection of ${name} needs a list in children of ${at.kind} at [${at.place.join(", ")}].`);
+    for (const item of children.value) {
+      const child = refNodeOf(item);
+      if (child === undefined || child.tree !== node.tree) continue;
+      const failed = visit(child);
+      if (failed !== undefined) return failed;
+    }
+    return undefined;
+  };
+  return visit(node) ?? acc;
+}
+
 /**
  * TREE.LADDER: the rungs of the ladder of an attribute, in their order. A rung gives `undefined` when it does not
  * answer, and the next rung then tries.
@@ -860,6 +911,7 @@ const REF_RUNGS: readonly (readonly [AttributeRung, (node: RefNode, name: string
     (node, name) => {
       const declared = termIn(node.contract?.attributes, name);
       if (declared?.fold !== undefined) return foldOf(node, name, declared.fold);
+      if (declared?.collect !== undefined) return collectIn(node, name, declared.collect);
       return declared?.default === undefined ? undefined : equationOf(node, declared.default, {});
     },
   ],
@@ -1020,6 +1072,53 @@ function attributeOf(node: RefNode, name: string): Result | undefined {
   return result;
 }
 
+/** TREE.AT: one instance of an attribute with parameters of a node. Its result is `undefined` while it evaluates. */
+interface RefInstance {
+  readonly attr: string;
+  readonly names: unknown;
+  result: Result | undefined;
+}
+
+/** TREE.AT: the instances of each node of the reference. Two arguments are the same instance by DOC.EQUALS. */
+const refInstances = /* @__PURE__ */ new WeakMap<RefNode, RefInstance[]>();
+
+/**
+ * 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(node: RefNode, attr: string, args: unknown): Result | undefined {
+  const declared = termIn(node.contract?.at, attr);
+  if (declared === undefined) return undefined;
+  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 !== undefined) return found.result;
+  if (found !== undefined) {
+    const from = inEvaluation.findIndex((entry) => entry.node === node && entry.name === name);
+    const steps = inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name));
+    return fail("#CYCLE!", `The attributes form a cycle: ${[...steps, nameOfAttribute(node, name)].join(" -> ")}.`);
+  }
+  const item: RefInstance = { attr, names: given.names, result: undefined };
+  list.push(item);
+  const entry = { node, name, circular: false, tentative: false };
+  inEvaluation.push(entry);
+  let result: Result | undefined;
+  try {
+    result = equationOf(node, rule.equation, given.names);
+  } finally {
+    inEvaluation.pop();
+    // A result that read an approximation is not kept (TREE.CIRCULAR).
+    if (result === undefined || 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: RefNode, self: HostThing, open: readonly object[]): Result {
   const record: Record<string, unknown> = {};
@@ -1065,7 +1164,7 @@ function plainValue(value: unknown, open: readonly object[]): Result {
  * tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error. The node
  * reads `self` only through `resolve` (C4, TREE.SELF).
  */
-const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath, resolve: walk }) => {
+const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath, resolve: walk, doc }) => {
   const reached = walk(["self"]);
   const parent: Thing | undefined = reached.ok ? reached.thing : undefined;
   const outer = refNodeOf(parent);
@@ -1076,6 +1175,7 @@ const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath
   const node: RefNode = {
     tree: nested ? outer.tree : { open: true },
     kind,
+    name: doc.name,
     place,
     parts,
     ctx: context,
@@ -1107,6 +1207,7 @@ const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath
   };
   node.thing = self;
   refNodes.set(self, node);
+  AT_READERS.set(self, (attr, args) => instanceOf(node, attr, args));
   if (nested) return ok(self);
   try {
     return jsonOfNode(node, self, []);
@@ -1235,13 +1336,22 @@ export function formulaDefinitions(profile: FormulaProfile = {}): Definitions {
     }
     const names = params as readonly string[];
     const body = partNamed(parts, "body") as Part;
+    // FORMULA.CALL-DEPTH: the evaluation that makes the closure counts its applications. A quarter of maxDepth is the limit.
+    const clock = activeEnvs[activeEnvs.length - 1] ?? { applying: 0, maxDepth: 1000 };
+    const limit = Math.ceil(clock.maxDepth / 4);
     const closure = (...args: readonly unknown[]): unknown => {
-      const scope: Record<string, unknown> = {};
-      for (const key of Object.keys(context.names)) setField(scope, key, context.names[key]);
-      names.forEach((name, index) => setField(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: Record<string, unknown> = {};
+        for (const key of Object.keys(context.names)) setField(scope, key, context.names[key]);
+        names.forEach((name, index) => setField(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, { value: { params: names } });
     return ok(closure);