@mark1russell7/coeval 0.21.0 → 0.22.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "coeval: the kernel of declarative languages. Documents in envelopes, a ladder that finds the evaluator, kind contracts, compiled plans, a static kit, a formula kit and a run side with capabilities.",
   "type": "module",
   "main": "./build/index.js",

package/src/formula.ts

@@ -115,6 +115,12 @@ export function isClosure(value: unknown): value is Closure {
   return typeof value === "function" && (value as Partial<Closure>)[CLOSURE] !== undefined;
 }
 
+/**
+ * The runtime of an evaluation with the clock of `call` (FORMULA.CALL-DEPTH, D125): the count of the applications of
+ * closures that run at this time. The first application adds the field, thus an evaluation without one has no field.
+ */
+type Clocked = Runtime & { applying?: number };
+
 /**
  * The standard extensions: the values that JSON cannot write. `ext.domain` reads a member of a domain through the
  * codec of the domain (EXT.DOMAIN, D40).
@@ -925,15 +931,26 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
         }
         return known;
       };
+      // The clock of call permits a quarter of the depth limit, because an application nests its body (D125).
+      const limit = Math.ceil((machine.maxDepth ?? 1000) / 4);
       return (ctx, rt) => {
         // A closure keeps the context for each later use, thus the list of reads gets each path that it can read (READS.CLOSURE).
         rt.keepsContext?.(ctx, reads);
+        const clock = rt as Clocked;
         const closure = (...args: readonly unknown[]): unknown => {
-          const scope: Record<string, unknown> = { ...ctx.names };
-          names.forEach((name, index) => setOwn(scope, name, args[index]));
-          const result = body.code({ ...ctx, names: scope }, rt);
-          if (!result.ok) throw new Failure(result.error);
-          return result.value;
+          // Each application counts one level on the runtime of its evaluation, and the count goes down after it (FORMULA.CALL-DEPTH).
+          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: Record<string, unknown> = { ...ctx.names };
+            names.forEach((name, index) => setOwn(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, { value: { params: names } });
         return ok(closure);

package/src/index.ts

@@ -36,6 +36,9 @@ export {
 } from "./errors.ts";
 export {
   type Alias,
+  type AtArgs,
+  type AtEquation,
+  type AtRule,
   type AttributeDeclaration,
   type CapsRule,
   type CircularDeclaration,
@@ -57,6 +60,9 @@ export {
   type World,
   type WorldEntry,
   CIRCULAR_LIMIT,
+  argsKey,
+  atArgsOf,
+  atRuleOf,
   circularOf,
   collectOf,
   effectsOfVerb,

package/src/instances.ts

@@ -1,5 +1,5 @@
 import { type Json, type Key, field, isKey, isRecord, typeName } from "./doc.ts";
-import { type CollectRule, type Kind, collectOf, equationType } from "./world.ts";
+import { type CollectRule, type Kind, argsKey, collectOf, equationType } from "./world.ts";
 import { ask } from "./ladder.ts";
 import { isRef, walkerOf } from "./deref.ts";
 import type { Machine } from "./evaluate.ts";
@@ -7,13 +7,16 @@ import { type Above, codeFactsOf, partLazy } from "./facts.ts";
 import { type NodeGraph, type GraphEdge, cycles } from "./graph.ts";
 import { STD_WALKERS } from "./stdlib.ts";
 import {
+  type AtStep,
   type CheckOptions,
   type DocVisit,
   type Issue,
   type SeenNode,
   REF_CODE,
   TREE_NODE,
+  atStepOf,
   downNames,
+  isAtStep,
   isStructural,
   keepsSelf,
   selvesOf,
@@ -39,6 +42,8 @@ export interface AttributeVertex {
   readonly type: string;
   /** `true` when the kind of the node declares the attribute `circular` (TREE.CIRCULAR-CHECK). Else the field is absent. */
   readonly circular?: true;
+  /** The arguments of an instance of an attribute with parameters (TREE.AT-CHECK). Else the field is absent. */
+  readonly args?: Readonly<Record<string, Json>>;
 }
 
 /** One read of an attribute by the code of another attribute (D107). */
@@ -220,6 +225,20 @@ function vertexOf(b: Builder, node: NodeInfo, attribute: string): string {
   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: Builder, node: NodeInfo, at: AtStep & { readonly kind: "exact" }): string {
+  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: Builder, from: string | undefined, r: Reader, lazy = false): void {
   b.edges.push({ from, to: r.to, lazy: r.lazy || lazy, place: r.place });
   b.ats.push(r.at);
@@ -310,6 +329,15 @@ function follow(b: Builder, start: Value, path: readonly Json[], from: number, r
       }
       continue;
     }
+    // A step tree.at with literal arguments reads one instance (TREE.AT-CHECK). A step that fails gives no read.
+    if (isAtStep(b.machine, step)) {
+      const at = atStepOf(node.kind, node.text, step.value);
+      if (at.kind === "unknown") edge(b, undefined, r);
+      if (at.kind !== "exact") return;
+      edge(b, atVertexOf(b, node, at), r);
+      here = "unknown";
+      continue;
+    }
     // The standard walker nearest depends only on the structure (R3 P5). Each other walker can read each attribute.
     if (walkerOf(b.machine, step) !== STD_WALKERS["walk.nearest"]) {
       edge(b, undefined, r);
@@ -361,10 +389,11 @@ function termRefs(b: Builder, kind: Kind, label: string, term: Json): readonly T
   return out;
 }
 
-/** The names of the equation of a rung, before the run. */
+/** The names of the equation of a rung, before the run. The parameters of an attribute hold JSON data (TREE.AT). */
 interface TermNames {
   readonly child?: NodeInfo;
   readonly prev?: Value;
+  readonly params?: readonly string[];
 }
 
 /** This function adds the reads of an equation of a rung: self is a node, and the names of the rung have their values. */
@@ -386,7 +415,10 @@ function termReads(b: Builder, refs: readonly TermRef[], self: NodeInfo, names:
     // A name that a kind inside the equation binds holds a value of the run. The others are the names of the rung.
     let start: Value;
     if (ref.bound.has(name)) start = "unknown";
-    else if (names?.child !== undefined && name === "child") start = { node: names.child };
+    else if (names?.params !== undefined) {
+      if (!names.params.includes(name)) continue;
+      start = "data";
+    } else if (names?.child !== undefined && name === "child") start = { node: names.child };
     else if (names?.prev !== undefined && name === "prev") start = names.prev;
     else if (name === "index") start = "data";
     else if (name === "acc" || name === "item") start = "unknown";
@@ -412,9 +444,16 @@ function prevOf(parent: NodeInfo, child: NodeInfo): Value {
  */
 function rungReads(b: Builder, id: string): void {
   const node = b.nodes.get(id) as NodeInfo;
-  const key = (b.vertices.get(id) as AttributeVertex).attribute;
+  const vertex = b.vertices.get(id) as AttributeVertex;
+  const key = vertex.attribute;
   const tree = node.kind.tree;
   const r: Reader = { to: id, lazy: false, place: node.visit.place, at: node.visit.at };
+  // An instance of an attribute with parameters has one rung: its equation in tree.at (TREE.AT).
+  if (vertex.args !== undefined) {
+    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] : undefined;
   if (equation !== undefined) {
     termReads(b, termRefs(b, node.kind, `tree.equations.${key}`, equation), node, undefined, r);
@@ -634,7 +673,8 @@ function allCircular(b: Builder, ids: readonly string[]): boolean {
 }
 
 function vertexText(vertex: AttributeVertex): string {
-  return `${vertex.attribute} of ${vertex.type} at [${vertex.place.join(", ")}]`;
+  const name = vertex.args === undefined ? vertex.attribute : `${vertex.attribute} with ${String(argsKey(vertex.args))}`;
+  return `${name} of ${vertex.type} at [${vertex.place.join(", ")}]`;
 }
 
 /**

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, collectOf, 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 }),
   };
 }
@@ -1069,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> = {};
@@ -1157,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, []);
@@ -1285,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);

package/src/static.ts

@@ -1,5 +1,5 @@
-import { type Envelope, type Json, type Key, isKey, isRecord, typeName } from "./doc.ts";
-import { type Kind, type LazyRule, type World, type WorldEntry, circularOf, collectOf, eachKind, effectsOfVerb, equationType, isKind, isNamespace } from "./world.ts";
+import { type Envelope, type Json, type Key, field, isEnvelope, isKey, isRecord, typeName } from "./doc.ts";
+import { type Kind, type LazyRule, type World, type WorldEntry, atArgsOf, atRuleOf, circularOf, collectOf, eachKind, effectsOfVerb, equationType, isKind, isNamespace } from "./world.ts";
 import { answerOf, ask } from "./ladder.ts";
 import { type PartSlot, partsOf, rulesCover, scopesOf } from "./parts.ts";
 import { type Cap, type Context, type Root, ROOTS, context, isRef, walkerOf, worldThing } from "./deref.ts";
@@ -8,6 +8,7 @@ import { type Machine, partCaps, permits, waitedReason } from "./evaluate.ts";
 import type { ValueType } from "./types.ts";
 import { type RootTypes, type TypeNode, type Typed, machineTypeIssues, typePass } from "./typing.ts";
 import { cycleIssues } from "./instances.ts";
+import { STD_WALKERS } from "./stdlib.ts";
 
 /** One document that a walk visits. */
 export interface DocVisit {
@@ -698,6 +699,11 @@ export function equationsOf(kind: Kind): readonly Equation[] {
   }
   // A contribution is not the attribute of its node, thus an own part of its name does not hide it (D122).
   for (const [name, term] of Object.entries(tree.contributes ?? {})) out.push({ label: `tree.contributes.${name}`, term, names: [], attribute: name, down: false, contributes: true });
+  // An equation of an attribute with parameters sees each parameter as a name (TREE.AT, D124).
+  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;
 }
 
@@ -713,6 +719,8 @@ export interface Equation {
   readonly down: boolean;
   /** `true` for an equation of `contributes`: it gives a contribution to a collection (TREE.COLLECT). */
   readonly contributes?: true;
+  /** `true` for an equation of `at`: it gives an attribute with parameters (TREE.AT). */
+  readonly at?: true;
 }
 
 /**
@@ -901,10 +909,10 @@ function equationIssues(machine: Machine, kind: Kind, kindText: string, options:
   state.needs.set(kind, needs);
   for (const name of Object.keys(kind.tree?.attributes ?? {})) needs.push({ name, why: "the kind declares it", hidden: undefined });
   const self: SeenNode = { kind, text: kindText, own: undefined, parent: undefined };
-  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: CheckOptions = { names, ...(of === undefined ? {} : { declaredType: of }), ...(options.caps === undefined ? {} : { caps: [] }) };
     const read = (name: string): void => {
-      needs.push({ name, why: `the equation ${label} reads it`, hidden: down || contributes === true ? undefined : attribute });
+      needs.push({ name, why: `the equation ${label} reads it`, hidden: down || contributes === true || at === true ? undefined : attribute });
     };
     for (const issue of checkAll(machine, term, inner, undefined, state, { node: self, read })) {
       out.push({ code: issue.code, place: [], reason: `In the equation ${label} of the kind ${kindText}: ${issue.reason}` });
@@ -917,12 +925,12 @@ function equationIssues(machine: Machine, kind: Kind, kindText: string, options:
  * 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: Kind, kindText: string): readonly Issue[] {
   const out: Issue[] = [];
   const tree = kind.tree;
-  for (const table of ["equations", "down", "attributes", "contributes"] as const) {
+  for (const table of ["equations", "down", "attributes", "contributes", "at"] as const) {
     for (const name of Object.keys(tree?.[table] ?? {})) {
       const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : undefined;
       if (why !== undefined) out.push({ code: "#NAME?", place: [], reason: `The kind ${kindText} gives the reserved attribute tree.${table}.${name}: ${why}.` });
@@ -935,6 +943,10 @@ function contractIssues(kind: Kind, kindText: string): readonly Issue[] {
     const collect = declared.collect === undefined ? undefined : collectOf(declared.collect);
     if (collect !== undefined && !collect.ok) out.push({ code: "#VALUE!", place: [], 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: [], reason: `The tree kind ${kindText} is on the run side: a node evaluates its attributes on demand, thus in no fixed order.` });
   }
@@ -966,9 +978,14 @@ function nodeIssues(machine: Machine, node: SeenNode, state: TreeState, v: DocVi
  * 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: Machine, self: SeenNode | undefined, path: readonly Json[], rootSelf: RootSelf | undefined): { readonly index: number; readonly reason: string } | undefined {
+function readIssue(
+  machine: Machine,
+  self: SeenNode | undefined,
+  path: readonly Json[],
+  rootSelf: RootSelf | undefined,
+): { readonly index: number; readonly reason: string; readonly code?: ErrorCode } | undefined {
   let node = self;
   let index = 1;
   while (node !== undefined && index < path.length && path[index] === "parent") {
@@ -976,6 +993,10 @@ function readIssue(machine: Machine, self: SeenNode | undefined, path: readonly
     index += 1;
   }
   const step = path[index];
+  if (node !== undefined && isAtStep(machine, step)) {
+    const at = atStepOf(node.kind, node.text, step.value);
+    return at.kind === "issue" ? { index, reason: at.reason, code: at.code } : undefined;
+  }
   if (node === undefined || !isKey(step) || Object.hasOwn(STRUCTURAL, String(step))) return undefined;
   const name = String(step);
   if (node.own === undefined) {
@@ -985,6 +1006,46 @@ function readIssue(machine: Machine, self: SeenNode | undefined, path: readonly
   return answered(machine.world, node, name) ? undefined : { index, 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). */
+export function isAtStep(machine: Machine, step: unknown): step is Envelope {
+  return isEnvelope(step) && walkerOf(machine, step) === STD_WALKERS["walk.tree.at"];
+}
+
+/**
+ * A step `tree.at` of a known kind before the run (TREE.AT-CHECK, D124). An exact step names an instance. The run of a
+ * step with an issue fails at the step. Only the run knows a step with a document in its data, or a bad entry.
+ */
+export type AtStep =
+  | { readonly kind: "exact"; readonly attr: string; readonly key: string; readonly equation: Json; readonly params: readonly string[]; readonly names: Readonly<Record<string, Json>> }
+  | { readonly kind: "issue"; readonly code: ErrorCode; readonly reason: string }
+  | { readonly kind: "unknown" };
+
+/**
+ * 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.
+ */
+export function atStepOf(kind: Kind, kindText: string, data: unknown): AtStep {
+  if (holdsDocument(data)) return { kind: "unknown" };
+  const attr = isRecord(data) ? field(data, "attr") : undefined;
+  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 !== undefined && Object.hasOwn(table, attr) ? table[attr] : undefined;
+  if (declared === undefined) return { kind: "issue", code: "#N/A", reason: `No rung gives the attribute ${attr} with parameters of the kind ${kindText}.` };
+  const rule = atRuleOf(declared);
+  // The issue of a bad entry is an issue of the kind (contractIssues).
+  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: unknown): boolean {
+  if (isEnvelope(value)) return true;
+  if (Array.isArray(value)) return value.some(holdsDocument);
+  return isRecord(value) && Object.values(value).some(holdsDocument);
+}
+
 /** The self of the root of a walk for the checks of attributes: the node of an equation, and the function for its reads. */
 interface RootSelf {
   readonly node: SeenNode;
@@ -1149,7 +1210,7 @@ function checkAll(
       // Only the standard code of a reference reads the attribute, thus a header that changes the code hides the read.
       if (attributes && root === "self" && v.address !== true && name === REF_CODE) {
         const issue = readIssue(machine, self, path, rootSelf);
-        if (issue !== undefined) push({ code: "#N/A", place: v.place, reason: issue.reason, at: stepAt(issue.index) });
+        if (issue !== undefined) push({ code: issue.code ?? "#N/A", place: v.place, reason: issue.reason, at: stepAt(issue.index) });
       }
       path.forEach((step, index) => {
         if (index === 0 || isKey(step)) return;

package/src/stdlib.ts

@@ -18,7 +18,7 @@ import {
 import { Failure } from "./errors.ts";
 import { type Cap, type HostThing, type Thing, type Walker, THING, isHostThing, valueOfThing } from "./deref.ts";
 import type { World } from "./ladder.ts";
-import { type AttributeDeclaration, type CircularRule, type TreeContract, circularOf, collectOf, equationType, lookupKind } from "./world.ts";
+import { type AttributeDeclaration, type CircularRule, type TreeContract, atArgsOf, atRuleOf, circularOf, collectOf, equationType, lookupKind } from "./world.ts";
 import { STD_DOMAINS } from "./types.ts";
 import type { SyntaxProfile } from "./syntax.ts";
 
@@ -74,6 +74,11 @@ export const STD_WORLD: World = {
           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: {
@@ -177,6 +182,7 @@ export const WORLD_SYNTAX: SyntaxProfile = /* @__PURE__ */ Object.freeze({
       { name: "box", kind: "box", args: "named", fields: ["width", "height", "children"] },
       { name: "nearest", kind: "nearest", args: "named", fields: ["type", "follow", "self"] },
       { name: "tree.named", kind: "tree.named", args: "named", fields: ["name", "in"] },
+      { name: "tree.at", kind: "tree.at", args: "named", fields: ["attr", "args"] },
       // An operator document with fewer terms than its operator takes, for example add(5) (K163, D65).
       { name: "add", kind: "add" },
       { name: "multiply", kind: "multiply" },
@@ -343,6 +349,10 @@ export interface AttributeAnswer {
  * A new plan gives new arrays. Thus a host keeps its cells by the identity of `place` and by `attribute`.
  * A host that keeps its cells by the keys of `place` can give the answer of another node or a stale answer.
  *
+ * An attribute with parameters gets one cell for each key of its arguments (TREE.AT-CELL, D124). Its `place` is a
+ * second array with the same keys, one for each key of a node. Its `attribute` is the JSON text of the name and the
+ * arguments, for example `["height",{"width":200}]`.
+ *
  * The function gives the answer of `compute`, or a kept answer. A host with signals gives a computed signal: a change
  * of its store then makes only the attributes that read the store compute again. Each demand gives a new `compute`, and
  * a cell that computes again uses the last one.
@@ -916,6 +926,80 @@ function collected(root: HostThing, key: string, declared: unknown): Result {
   return acc;
 }
 
+/** A function from the name of an attribute and the arguments to the result, or `undefined` when no rung answers (D124). */
+export type AtReader = (attr: string, args: unknown) => Result | undefined;
+
+/**
+ * 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.
+ */
+export const AT_READERS: WeakMap<object, AtReader> = /* @__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<NodeState, Map<string, Cell>>();
+
+/** 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<readonly Key[], readonly Key[]>();
+
+/**
+ * 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: NodeState, attr: string, args: unknown): Result | undefined {
+  const declared: unknown = entryOf(n.tree?.at, attr);
+  if (declared === undefined) return undefined;
+  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}`);
+  // An open fixed point does not use the cells of the host (D113).
+  const host = openPoint === undefined ? n.host : undefined;
+  const place = n.host === undefined ? n.place : keptAt(atPlaces, n.place, () => Object.freeze([...n.place]));
+  let marks: Map<string, Cell> | undefined = n.host === undefined ? atMemos.get(n) : keptAt(marksByPlace, place, () => new Map<string, Cell>());
+  if (marks === undefined) {
+    marks = 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 !== undefined) return cell.busy ? cycleAt(marks, key, text) : cell.result;
+  const demand: Demand = { cells: marks, key, text };
+  const loop = openPoint;
+  const compute = (): AttributeAnswer => ({ result: n.equation(rule.equation, given.names), by: "kind" });
+  marks.set(key, BUSY);
+  demands.push(demand);
+  let thrown: unknown = NOT_THROWN;
+  let answer: AttributeAnswer;
+  try {
+    answer =
+      host === undefined
+        ? compute()
+        : host(place, key, () => {
+            try {
+              return compute();
+            } catch (error) {
+              thrown = error;
+              throw error;
+            }
+          });
+  } catch (error) {
+    marks.delete(key);
+    // An exception of the kit or of the stack goes on. Another exception of the cell is a cycle of the host (D108).
+    if (host === undefined || error === thrown) throw error;
+    const chain = demands.map((item) => item.text).join(" -> ");
+    answer = { result: fail("#CYCLE!", `The cells of the host found a cycle in the demands: ${chain}.`, { cause: error }), by: undefined };
+  } finally {
+    demands.pop();
+  }
+  // A result that read an approximation is not final. With the cells of a host, the cell is the memo.
+  if (n.host !== undefined || 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
@@ -1256,8 +1340,25 @@ const named: Walker = ({ data, here, deref }) => {
   return { ok: false, 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: Walker = ({ data, here }) => {
+  const attr = isRecord(data) ? field(data, "attr") : undefined;
+  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 === undefined && typeof here === "object" && here !== null ? AT_READERS.get(here) : undefined;
+  if (state === undefined && reader === undefined) return { ok: false, reason: `The step tree.at reads ${attr} of a thing that is not a node of a tree.` };
+  const result = state === undefined ? (reader as AtReader)(attr, args) : atRead(state, attr, args);
+  if (result === undefined) 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 as Thing };
+};
+
 /** The walkers of the standard world, by name. */
-export const STD_WALKERS: Readonly<Record<string, Walker>> = { "walk.nearest": nearest, "walk.named": named };
+export const STD_WALKERS: Readonly<Record<string, Walker>> = { "walk.nearest": nearest, "walk.named": named, "walk.tree.at": at };
 
 /** This function evaluates parts one after the other, and stops at the first error. */
 function* inOrder(parts: readonly RunPart[]): Generator<Promise<unknown>, { readonly values: readonly unknown[] } | { readonly error: Result }, unknown> {