@mark1russell7/coeval 0.20.1 → 0.22.0

package/src/static.ts

@@ -1,13 +1,14 @@
-import { type Envelope, type Json, type Key, isKey, isRecord, typeName } from "./doc.ts";
-import { type Kind, type World, type WorldEntry, circularOf, eachKind, effectsOfVerb, equationType, isKind, isNamespace } from "./world.ts";
-import { ask } from "./ladder.ts";
-import { type PartSlot, partsOf, scopesOf } from "./parts.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";
 import type { ErrorCode } from "./errors.ts";
 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 {
@@ -405,6 +406,19 @@ export interface Typing {
   readonly places: readonly Typed[];
 }
 
+/**
+ * This function gives the parts that the code of a runner evaluates itself, without a wait (RUN.DRIVES, D119). The
+ * answer of the hook `facts` for the code wins over the contract. The contract describes only the code of its kind for
+ * `eval`. Without a declaration, the runner passes each wait of its parts through.
+ */
+function driveRules(machine: Machine, v: DocVisit, kind: Kind, name: string, rung: string | undefined, verb: string): readonly LazyRule[] | undefined {
+  if (verb !== "eval") return undefined;
+  const hook = machine.facts?.(v.typePath ?? [], name)?.drives;
+  if (hook !== undefined) return hook;
+  const described = v.declared || rung !== "own" || name === answerOf(machine.world, undefined, kind, verb)?.name;
+  return described ? kind.drives : undefined;
+}
+
 /** The least authority: the capability `[]` permits each effect (CAP.KEYS). */
 const EACH: readonly Cap[] = /* @__PURE__ */ Object.freeze([[]]);
 
@@ -412,16 +426,42 @@ const EACH: readonly Cap[] = /* @__PURE__ */ Object.freeze([[]]);
 const NO_EFFECTS: readonly (readonly Key[])[] = /* @__PURE__ */ Object.freeze([]);
 
 /**
- * This function gives the effects that the contract of the kind of a visit declares for a verb, as keys
- * (FACTS.EFFECTS, VERB.EFFECTS). The text `"type"` gives the type of the document after each alias. A visit without a
- * kind declares no effect. `check`, `factsOf` and `effectsOf` read the declarations with this one function (D27).
+ * This function gives the effects that the code of a visit declares for a verb, as keys (FACTS.EFFECTS, VERB.EFFECTS).
+ * The text `"type"` gives the type of the document after each alias. A visit without a kind declares no effect.
+ * `check`, `factsOf`, `effectsOf` and `checkLatent` read the declarations with this one function (D27).
+ *
+ * For `eval`, the answer of the hook `facts` of the machine for the code of the visit wins over the contract of the
+ * kind (CAP.OWN-EFFECTS, D118). Thus a language gives the effects of an own entry for another evaluator. Without a
+ * machine, or without the field `effects` in the answer, the contract gives the effects.
  *
  * @param v - The visit.
  * @param verb - The verb. The default is `eval`. A kind without a declaration for the verb gives no effect.
- * @returns The keys of each declared effect, in the order of the contract.
+ * @param machine - The machine with the hook `facts`, when the caller has it.
+ * @param name - The name of the evaluator of the visit, when the caller knows it. Else the ladder gives it.
+ * @returns The keys of each declared effect, in the order of the declaration.
+ */
+export function declaredEffects(v: DocVisit, verb = "eval", machine?: Machine, name?: string): readonly (readonly Key[])[] {
+  return hookEffects(v, verb, machine, name) ?? verbDeclared(v, verb) ?? NO_EFFECTS;
+}
+
+/**
+ * This function gives the effects that the hook `facts` gives for the code of a visit, as keys (D118). The result is
+ * `undefined` for another verb than `eval`, without the hook, or when the answer has no field `effects`.
  */
-export function declaredEffects(v: DocVisit, verb = "eval"): readonly (readonly Key[])[] {
-  return verbDeclared(v, verb) ?? NO_EFFECTS;
+function hookEffects(v: DocVisit, verb: string, machine: Machine | undefined, name: string | undefined): readonly (readonly Key[])[] | undefined {
+  if (verb !== "eval" || machine?.facts === undefined || v.kind === undefined) return undefined;
+  const code = name ?? answerOf(machine.world, v.declared ? undefined : v.doc.own, v.kind, "eval")?.name;
+  const effects = code === undefined ? undefined : machine.facts(v.typePath ?? [], code)?.effects;
+  return effects === undefined ? undefined : effectKeys(v, effects);
+}
+
+/**
+ * This function gives the keys of a declaration of effects at a visit (D27). The text `"type"` gives the type of the
+ * document after each alias.
+ */
+export function effectKeys(v: DocVisit, effects: "type" | readonly string[]): readonly (readonly Key[])[] {
+  if (effects.length === 0) return NO_EFFECTS;
+  return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
 }
 
 /**
@@ -433,8 +473,7 @@ function verbDeclared(v: DocVisit, verb: string): readonly (readonly Key[])[] |
   if (v.kind === undefined) return verb === "eval" ? NO_EFFECTS : undefined;
   const effects = effectsOfVerb(v.kind, verb);
   if (effects === undefined) return undefined;
-  if (effects.length === 0) return NO_EFFECTS;
-  return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
+  return effectKeys(v, effects);
 }
 
 /**
@@ -637,7 +676,8 @@ const FOLD_NAMES: readonly string[] = /* @__PURE__ */ Object.freeze(["acc", "ite
 
 /**
  * This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
- * `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
+ * `equations`, a `unit`, a `default` and a contribution see no names. `check` and `factsOf` read the equations with
+ * this one function.
  */
 export function equationsOf(kind: Kind): readonly Equation[] {
   const tree = kind.tree;
@@ -651,6 +691,18 @@ export function equationsOf(kind: Kind): readonly Equation[] {
       out.push({ label: `tree.attributes.${name}.fold.combine`, term: declared.fold.combine, names: FOLD_NAMES, attribute: name, down: false });
     }
     if (declared.default !== undefined) out.push({ label: `tree.attributes.${name}.default`, term: declared.default, names: [], attribute: name, down: false });
+    const collect = declared.collect === undefined ? undefined : collectOf(declared.collect);
+    if (collect?.ok === true && !collect.names) {
+      out.push({ label: `tree.attributes.${name}.collect.unit`, term: collect.unit, names: [], attribute: name, down: false });
+      out.push({ label: `tree.attributes.${name}.collect.combine`, term: collect.combine, names: FOLD_NAMES, attribute: name, down: false });
+    }
+  }
+  // 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;
 }
@@ -665,6 +717,10 @@ export interface Equation {
   readonly attribute: string;
   /** `true` for an equation of `down`: it gives the attribute of a child. */
   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;
 }
 
 /**
@@ -837,7 +893,7 @@ export function answered(world: World, node: SeenNode, name: string): boolean {
   if (hasEntry(tree?.equations, name)) return true;
   if (node.parent === undefined ? downNames(world).has(name) : hasEntry(node.parent.kind.tree?.down, name)) return true;
   const declared = tree?.attributes !== undefined && Object.hasOwn(tree.attributes, name) ? tree.attributes[name] : undefined;
-  return declared !== undefined && (declared.copy === true || declared.fold !== undefined || declared.default !== undefined);
+  return declared !== undefined && (declared.copy === true || declared.fold !== undefined || declared.collect !== undefined || declared.default !== undefined);
 }
 
 /**
@@ -853,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 } 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 ? 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}` });
@@ -868,12 +924,13 @@ 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).
+ * 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). 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"] 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}.` });
@@ -883,6 +940,12 @@ function contractIssues(kind: Kind, kindText: string): readonly Issue[] {
   for (const [name, declared] of Object.entries(tree?.attributes ?? {})) {
     const rule = declared.circular === undefined ? undefined : circularOf(declared.circular);
     if (rule !== undefined && !rule.ok) out.push({ code: "#VALUE!", place: [], reason: `The kind ${kindText} has a bad declaration tree.attributes.${name}.circular. ${rule.reason}` });
+    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.` });
@@ -915,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") {
@@ -925,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) {
@@ -934,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;
@@ -971,6 +1083,9 @@ function checkAll(
   // run, and a drive for a runner under an evaluator. A document without code fails before its parts, thus it is not
   // in the map.
   const waits = options.run === true ? new Map<DocVisit, Waits>() : undefined;
+  // The parts that the code of a runner evaluates itself, without a wait (RUN.DRIVES). They get no wait, as under an
+  // evaluator. Only a runner that declares `drives` is in the map.
+  const driven = new Map<DocVisit, readonly LazyRule[]>();
   const drives: Drive[] = [];
   const maxDepth = machine.maxDepth ?? 1000;
   const anyName = options.names === "any";
@@ -1026,7 +1141,7 @@ function checkAll(
         if (known !== true) push({ code: "#NAME?", place: v.place, reason: known, at: v.at });
       }
       const caps = v.caps;
-      const stated = verbDeclared(v, verb);
+      const stated = hookEffects(v, verb, machine, name) ?? verbDeclared(v, verb);
       const declared = stated ?? NO_EFFECTS;
       if (allowed !== undefined && caps !== undefined) {
         for (const kind of declared) {
@@ -1035,7 +1150,9 @@ function checkAll(
       }
       if (waits !== undefined && coded) {
         // The parent of the root is the driver of the run, and it can wait. An evaluator gives its parts no wait.
-        const up = v.parent === undefined ? true : waits.get(v.parent);
+        let up = v.parent === undefined ? true : waits.get(v.parent);
+        const rules = v.parent === undefined ? undefined : driven.get(v.parent);
+        if (up !== false && rules !== undefined && v.parent !== undefined && rulesCover(rules, v.parent.kind?.parts, v.parent.doc.value as Json, v.slot)) up = false;
         let chain: Waits = false;
         if (runner && up === false) {
           // The run drives a runner under an evaluator, and only a real wait fails (RUN.DRIVE-NESTED). Its issue goes in
@@ -1047,6 +1164,10 @@ function checkAll(
           chain = up ?? true;
         }
         waits.set(v, chain);
+        if (runner && v.kind !== undefined) {
+          const own = driveRules(machine, v, v.kind, name, answer.rung, verb);
+          if (own !== undefined && own.length > 0) driven.set(v, own);
+        }
         // A runner waits only for an effect that reaches the host (C6). A refused effect gives #CAP! without a wait. A
         // runner without a declaration for the verb can cause each effect, thus it can wait.
         if (typeof chain === "object" && !chain.wait) {
@@ -1089,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, 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";
 
@@ -67,6 +67,20 @@ export const STD_WORLD: 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" },
+          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", view: "view.op" },
       parts: { shape: "record", fields: ["width", "height", "children"], of: "number" },
@@ -167,6 +181,8 @@ export const WORLD_SYNTAX: SyntaxProfile = /* @__PURE__ */ Object.freeze({
       { name: "panel", kind: "panel", args: "named", fields: ["width", "height", "children"] },
       { 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" },
@@ -272,6 +288,8 @@ export interface AttributeTrace {
 /** The state of a node behind its brand. */
 interface NodeState extends LoopNode {
   readonly build: TreeBuild;
+  /** The binding name from the header of the document of the node, for the registry of names (TREE.NAMED). */
+  readonly name: string | undefined;
   /**
    * This function gives an attribute through its ladder (TREE.LADDER).
    *
@@ -331,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.
@@ -853,6 +875,131 @@ function plainOf(value: unknown, path: Set<object>): Result {
   }
 }
 
+/**
+ * This function gives the collection of an attribute of a node (TREE.COLLECT, D122). It visits the node, then each node
+ * of the same tree in each list `children`, in the order of the lists. Each node is visited one time.
+ * The registry of names (TREE.NAMED) gives a record from each binding name to its node.
+ */
+function collected(root: HostThing, key: string, declared: unknown): Result {
+  const top = stateOf(root) as NodeState;
+  const rule = collectOf(declared);
+  if (!rule.ok) return fail("#VALUE!", `The attribute ${attributeText(key, top.type, top.place)} has a bad declaration collect. ${rule.reason}`);
+  const registry: Record<string, unknown> = {};
+  const owners = new Map<string, NodeState>();
+  let acc = rule.names ? ok(registry) : top.equation(rule.unit, NO_NAMES);
+  if (!acc.ok) return acc;
+  const seen = new Set<NodeState>();
+  const stack: unknown[] = [root];
+  while (stack.length > 0) {
+    const thing = stack.pop();
+    const at = stateOf(thing);
+    // An item that is not a node of this tree does not count, and a node counts one time.
+    if (at === undefined || at.build !== top.build || seen.has(at)) continue;
+    seen.add(at);
+    if (rule.names) {
+      const name = at.name;
+      const earlier = name === undefined ? undefined : owners.get(name);
+      if (earlier !== undefined) {
+        const both = `${earlier.type} at [${earlier.place.join(", ")}] and ${at.type} at [${at.place.join(", ")}]`;
+        return fail("#VALUE!", `Two nodes have the name ${name} in the registry ${attributeText(key, top.type, top.place)}: ${both}.`);
+      }
+      if (name !== undefined) {
+        owners.set(name, at);
+        putField(registry, name, thing);
+      }
+    } else {
+      const term = entryOf(at.tree?.contributes, key);
+      if (term !== undefined) {
+        const item = at.equation(term, NO_NAMES);
+        if (!item.ok) return item;
+        acc = top.equation(rule.combine, { acc: acc.value, item: item.value });
+        if (!acc.ok) return acc;
+      }
+    }
+    const children = at.read("children");
+    if (children === undefined) continue;
+    if (!children.ok) return children;
+    if (!Array.isArray(children.value)) return fail("#VALUE!", `The collection of ${key} needs a list in children of ${at.type} at [${at.place.join(", ")}].`);
+    const list = children.value as readonly unknown[];
+    for (let index = list.length - 1; index >= 0; index -= 1) stack.push(list[index]);
+  }
+  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
@@ -916,6 +1063,7 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
       if (copied !== undefined) return { result: copied, by: "copy" };
     }
     if (declared?.fold !== undefined) return { result: fold(key, declared.fold), by: "default" };
+    if (declared?.collect !== undefined) return { result: collected(node, key, declared.collect), by: "default" };
     if (declared?.default !== undefined) return { result: state.equation(declared.default, NO_NAMES), by: "default" };
     return undefined;
   };
@@ -984,6 +1132,7 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
 
   const state: NodeState = {
     build,
+    name: input.doc.name,
     type,
     place,
     tree,
@@ -1170,8 +1319,46 @@ export function nearestWalker(options: NearestOptions = {}): Walker {
 
 const nearest: Walker = /* @__PURE__ */ nearestWalker();
 
+/**
+ * The walker of the step `tree.named` (TREE.NAMED, D122). It goes up from the thing before the step through the key
+ * `parent`, to the first thing that answers the registry. The field `in` names the registry, and the default is
+ * `names`. The walker gives the node with the field `name` in that registry.
+ */
+const named: Walker = ({ data, here, deref }) => {
+  const name = isRecord(data) ? field(data, "name") : undefined;
+  if (typeof name !== "string") return { ok: false, code: "#VALUE!", reason: "The step tree.named needs a text name." };
+  const registry = isRecord(data) && typeof field(data, "in") === "string" ? String(field(data, "in")) : "names";
+  let at: Thing | undefined = here;
+  for (let hops = 0; hops < 256 && at !== undefined && at !== null; hops += 1) {
+    const found = deref(at, registry);
+    if (found !== undefined) {
+      if (!isRecord(found) || !Object.hasOwn(found, name)) return { ok: false, reason: `The registry ${registry} has no node with the name ${name}.` };
+      return { ok: true, thing: field(found, name) as Thing };
+    }
+    at = deref(at, "parent");
+  }
+  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 };
+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> {

package/src/types.ts

@@ -1144,8 +1144,10 @@ function valueStep(value: unknown, key: Key): { readonly found: unknown } | { re
  *
  * - A record gives the type of its field. A closed record without the field has no such step. An open record gives
  *   `unknown`.
- * - A list gives the type of its items for an index, and `number` for `length`.
- * - A base type reads the steps of its domain, then of each parent (`Domain.steps`).
+ * - A list gives the type of its items for an index, and `number` for `length`. Another key has no such step.
+ * - A base type reads the steps of its domain, then of each parent (`Domain.steps`). A base type of the kernel
+ *   without such a step has no step, because its values are not objects (TYPE.NO-STEP, D120).
+ * - A function type has no step, because a step into a function reaches nothing.
  * - A union joins the steps of its types. `one` gives the values that the step reaches.
  * - Each other step gives `unknown`, and `never` gives `never`.
  *
@@ -1171,10 +1173,13 @@ export function stepType(
         const found = steps[name] as ValueType;
         return { type: examine === undefined ? found : examine(found, `type of the step ${name} of the domain ${each}`) };
       }
-      return { type: "unknown" };
+      // A value of a base type of the kernel is not an object, thus a step into it reaches nothing (TYPE.NO-STEP).
+      return Object.hasOwn(STD_DOMAINS, form.name) ? NO_STEP : { type: "unknown" };
+    case "fn":
+      return NO_STEP;
     case "list":
       if (key === "length") return { type: "number" };
-      return { type: indexOf(key) >= 0 ? form.item : "unknown" };
+      return indexOf(key) >= 0 ? { type: form.item } : NO_STEP;
     case "record":
       if (Object.hasOwn(form.fields, name)) return { type: form.fields[name] as ValueType };
       return form.closed ? { missing: Object.keys(form.fields) } : { type: "unknown" };
@@ -1204,6 +1209,9 @@ export function stepType(
   }
 }
 
+/** The answer of `stepType` for a type whose members have no step with the key, and no fields to name. */
+const NO_STEP: StepType = { missing: [] };
+
 /** A term that `typeIssues` reads later: the term, its keys from the root and its depth. */
 interface Pending {
   readonly type: unknown;