@mark1russell7/coeval 0.21.0 → 0.23.0

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 {
@@ -102,6 +103,17 @@ function keysOf(trail: Trail | undefined): readonly Key[] {
 
 /** A visit with its paths as trails. It makes the keys of a path only when a reader asks for them. */
 class Visit implements DocVisit {
+  readonly doc: Envelope;
+  readonly declared: boolean;
+  readonly depth: number;
+  readonly names: ReadonlySet<string>;
+  readonly later: ReadonlySet<string>;
+  readonly slot: readonly Key[];
+  readonly parent: DocVisit | undefined;
+  readonly kind: Kind | undefined;
+  readonly typePath: readonly Key[] | undefined;
+  readonly address: true | undefined;
+  readonly caps: readonly Cap[] | undefined;
   readonly #place: Trail | undefined;
   readonly #at: Trail | undefined;
   readonly #bound: readonly string[];
@@ -110,20 +122,31 @@ class Visit implements DocVisit {
   constructor(
     place: Trail | undefined,
     at: Trail | undefined,
-    readonly doc: Envelope,
-    readonly declared: boolean,
-    readonly depth: number,
-    readonly names: ReadonlySet<string>,
-    readonly later: ReadonlySet<string>,
-    readonly slot: readonly Key[],
-    readonly parent: DocVisit | undefined,
-    readonly kind: Kind | undefined,
-    readonly typePath: readonly Key[] | undefined,
-    readonly address: true | undefined,
-    readonly caps: readonly Cap[] | undefined,
+    doc: Envelope,
+    declared: boolean,
+    depth: number,
+    names: ReadonlySet<string>,
+    later: ReadonlySet<string>,
+    slot: readonly Key[],
+    parent: DocVisit | undefined,
+    kind: Kind | undefined,
+    typePath: readonly Key[] | undefined,
+    address: true | undefined,
+    caps: readonly Cap[] | undefined,
     bound: readonly string[],
     expect: ValueType | undefined,
   ) {
+    this.doc = doc;
+    this.declared = declared;
+    this.depth = depth;
+    this.names = names;
+    this.later = later;
+    this.slot = slot;
+    this.parent = parent;
+    this.kind = kind;
+    this.typePath = typePath;
+    this.address = address;
+    this.caps = caps;
     this.#place = place;
     this.#at = at;
     this.#bound = bound;
@@ -690,6 +713,8 @@ 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 });
+    // Only the equation is known before the run. The document that it gives is not known (TREE.HIGHER-CHECK, D126).
+    if (declared.higher !== undefined) out.push({ label: `tree.attributes.${name}.higher`, term: declared.higher, 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 });
@@ -698,6 +723,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 +743,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;
 }
 
 /**
@@ -877,15 +909,16 @@ function hasEntry(table: Readonly<Record<string, unknown>> | undefined, name: st
 /**
  * This function tells if a rung of the ladder can answer an attribute of a node (TREE.LADDER). An unknown parent can
  * be a node of each kind of the world, thus each name of `down` in the world can answer. A copy can always answer,
- * because `check` does not know a node without a parent.
+ * because `check` does not know a node without a parent. A kind with `forwards` can answer each other name, because the
+ * forwarded node is not known before the run (TREE.FORWARD-CHECK).
  */
 export function answered(world: World, node: SeenNode, name: string): boolean {
   if (node.own?.has(name) === true) return true;
   const tree = node.kind.tree;
-  if (hasEntry(tree?.equations, name)) return true;
+  if (hasEntry(tree?.equations, name) || (tree?.forwards !== undefined && tree.forwards !== 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.collect !== undefined || declared.default !== undefined);
+  return declared !== undefined && (declared.copy === true || declared.fold !== undefined || declared.collect !== undefined || declared.default !== undefined || declared.higher !== undefined);
 }
 
 /**
@@ -900,11 +933,12 @@ function equationIssues(machine: Machine, kind: Kind, kindText: string, options:
   const needs: Need[] = [];
   state.needs.set(kind, needs);
   for (const name of Object.keys(kind.tree?.attributes ?? {})) needs.push({ name, why: "the kind declares it", hidden: undefined });
+  if (typeof kind.tree?.forwards === "string" && !Object.hasOwn(STRUCTURAL, kind.tree.forwards)) needs.push({ name: kind.tree.forwards, why: "the kind forwards to 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 +951,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). 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).
+ * A field `forwards` that is not a text gives `#VALUE!`, and a structural name gives `#NAME?` (TREE.FORWARD-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 +970,15 @@ 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}` });
+  }
+  const forwards: unknown = tree?.forwards;
+  if (forwards !== undefined && typeof forwards !== "string") out.push({ code: "#VALUE!", place: [], reason: `The kind ${kindText} has a bad field tree.forwards. It must be a text.` });
+  if (typeof forwards === "string" && Object.hasOwn(STRUCTURAL, forwards)) {
+    out.push({ code: "#NAME?", place: [], reason: `The kind ${kindText} gives the reserved attribute tree.forwards: ${String(STRUCTURAL[forwards])}.` });
+  }
   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 +1010,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 +1025,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 +1038,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 +1242,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,19 @@ 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,
+  GENERATION_LIMIT,
+  atArgsOf,
+  atRuleOf,
+  circularOf,
+  collectOf,
+  documentKey,
+  equationType,
+  lookupKind,
+} from "./world.ts";
 import { STD_DOMAINS } from "./types.ts";
 import type { SyntaxProfile } from "./syntax.ts";
 
@@ -74,6 +86,16 @@ 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).",
+        },
+        quote: {
+          verbs: { eval: "data.quote", view: "view.value" },
+          pure: true,
+          summary: "A document as data. Its value is the result, and nothing in it evaluates. A higher-order attribute uses it (TREE.HIGHER).",
+        },
       },
     },
     panel: {
@@ -177,6 +199,8 @@ 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"] },
+      { name: "tree.quote", kind: "tree.quote", args: "literal" },
       // An operator document with fewer terms than its operator takes, for example add(5) (K163, D65).
       { name: "add", kind: "add" },
       { name: "multiply", kind: "multiply" },
@@ -218,6 +242,7 @@ export const STD_EVALUATORS: Readonly<Record<string, Evaluator>> = {
   "data.number": /* @__PURE__ */ dataOf("number"),
   "data.text": /* @__PURE__ */ dataOf("string"),
   "data.bool": /* @__PURE__ */ dataOf("boolean"),
+  "data.quote": ({ data }) => ok(data ?? null),
   "math.add": ({ parts }) => {
     const all = allValues(parts.map((part) => part.evaluate()));
     if ("error" in all) return all.error;
@@ -265,10 +290,10 @@ interface TreeBuild {
 }
 
 /** The rungs of the ladder of an attribute, in their order (TREE.LADDER, D42). */
-export type AttributeRung = "own" | "kind" | "parent" | "copy" | "default";
+export type AttributeRung = "own" | "kind" | "parent" | "copy" | "default" | "forward";
 
 /** The rungs of the ladder of an attribute, in their order (TREE.LADDER, D42). */
-export const ATTRIBUTE_RUNGS: readonly AttributeRung[] = /* @__PURE__ */ Object.freeze(["own", "kind", "parent", "copy", "default"] as const);
+export const ATTRIBUTE_RUNGS: readonly AttributeRung[] = /* @__PURE__ */ Object.freeze(["own", "kind", "parent", "copy", "default", "forward"] as const);
 
 /** The record of the demand of one attribute of a node (TREE.RUNGS). */
 export interface AttributeTrace {
@@ -343,6 +368,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 +945,180 @@ 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;
+}
+
+/** The most documents and the most characters of the keys in the table of generated documents. */
+const INTERNED_DOCUMENTS = 1000;
+const INTERNED_CHARACTERS = 16_000_000;
+
+/** The first document of each structural key (TREE.HIGHER-PLAN, D126). */
+const internedDocuments = /* @__PURE__ */ new Map<string, Json>();
+
+/** The kept document of each document object. An object gets its key one time, as PLAN.CACHE says. */
+const internedObjects = /* @__PURE__ */ new WeakMap<object, Json>();
+
+/** The characters of the keys of `internedDocuments`. */
+let internedCharacters = 0;
+
+/**
+ * This function gives the one object of a document (TREE.HIGHER-PLAN, D126). `equationPlan` caches by object, thus a
+ * new object with a known key compiles nothing. The table has a limit, and a full table starts again. A document that
+ * left the table compiles again, and that costs only time.
+ *
+ * @param doc - The value of an equation.
+ * @returns The document, or `undefined` for a value that is not JSON data.
+ */
+function internedDocument(doc: unknown): Json | undefined {
+  const object = typeof doc === "object" && doc !== null;
+  const known = object ? internedObjects.get(doc) : undefined;
+  if (known !== undefined) return known;
+  const key = documentKey(doc);
+  if (key === undefined) return undefined;
+  if (!object) return doc as Json;
+  let kept = internedDocuments.get(key);
+  if (kept === undefined) {
+    if (internedDocuments.size >= INTERNED_DOCUMENTS || internedCharacters + key.length > INTERNED_CHARACTERS) {
+      internedDocuments.clear();
+      internedCharacters = 0;
+    }
+    kept = doc as Json;
+    internedDocuments.set(key, kept);
+    internedCharacters += key.length;
+  }
+  internedObjects.set(doc, kept);
+  return kept;
+}
+
+/** The depth of each root of a generated document: the generated documents from the root of the tree to it (D126). */
+const generations = /* @__PURE__ */ new WeakMap<NodeState, number>();
+
+/** This function gives the depth of the nearest root of a generated document at or above a node of a tree, or 0. */
+function generationOf(node: HostThing, build: TreeBuild): number {
+  let thing: Thing | undefined = node;
+  for (let at = stateOf(thing); at?.build === build; at = stateOf(thing)) {
+    const depth = generations.get(at);
+    if (depth !== undefined) return depth;
+    thing = (thing as HostThing).deref("parent");
+  }
+  return 0;
+}
+
+/**
+ * This function gives a higher-order attribute of a node (TREE.HIGHER, D126). The equation gives a document as data.
+ * The document evaluates as an equation, with the node as `self`. Thus its root is a node under the node: it finds the
+ * open tree, and it has the node as its parent. The function is outside the code of `read`, as a fold is.
+ */
+function generated(n: NodeState, node: HostThing, key: string, term: Json): Result {
+  const value = n.equation(term, NO_NAMES);
+  if (!value.ok) return value;
+  const doc = internedDocument(value.value);
+  const text = attributeText(key, n.type, n.place);
+  if (doc === undefined) return fail("#VALUE!", `The equation of the higher-order attribute ${text} gives a value that is not JSON data.`);
+  const depth = generationOf(node, n.build) + 1;
+  if (depth > GENERATION_LIMIT) return fail("#DEPTH!", `The higher-order attribute ${text} is under more than ${GENERATION_LIMIT} generated documents.`);
+  const root = n.equation(doc, NO_NAMES);
+  if (!root.ok) return root;
+  const made = stateOf(root.value);
+  if (made === undefined) return fail("#VALUE!", `The document of the higher-order attribute ${text} gives no node of the tree.`);
+  generations.set(made, depth);
+  return root;
+}
+
+/**
+ * This function gives the last rung of the ladder (TREE.FORWARD, D126). The attribute `forwards` gives a node, and that
+ * node answers the attribute through its own ladder. The attribute `forwards` itself gets no such answer.
+ */
+function forwarded(n: NodeState, node: HostThing, key: string, name: unknown): { readonly result: Result; readonly by: AttributeRung } | undefined {
+  if (key === name) return undefined;
+  const text = attributeText(key, n.type, n.place);
+  if (typeof name !== "string") return { result: fail("#VALUE!", `The attribute ${text} has a contract with a bad field forwards. It must be a text.`), by: "forward" };
+  const target = n.read(name);
+  if (target === undefined) return undefined;
+  if (!target.ok) return { result: target, by: "forward" };
+  const to = stateOf(target.value);
+  if (to === undefined) return { result: fail("#VALUE!", `The attribute ${name} that ${text} forwards to gives no node of a tree.`), by: "forward" };
+  // An equation can give a node without a declaration higher, thus the rung counts each node that it reaches.
+  if (!generations.has(to)) {
+    const depth = generationOf(node, n.build) + 1;
+    if (depth > GENERATION_LIMIT) return { result: fail("#DEPTH!", `The attribute ${text} forwards through more than ${GENERATION_LIMIT} generated documents.`), by: "forward" };
+    generations.set(to, depth);
+  }
+  const result = to.read(key);
+  return result === undefined ? undefined : { result, by: "forward" };
+}
+
 /**
  * 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
@@ -981,7 +1184,8 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
     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;
+    if (declared?.higher !== undefined) return { result: generated(state, node, key, declared.higher), by: "default" };
+    return tree?.forwards === undefined ? undefined : forwarded(state, node, key, tree.forwards);
   };
 
   /**
@@ -1078,7 +1282,9 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
     trace(key) {
       const cell = cells.get(key);
       if (cell === undefined || cell.busy) return undefined;
-      const rungs = cell.by === undefined ? ATTRIBUTE_RUNGS : ATTRIBUTE_RUNGS.slice(0, ATTRIBUTE_RUNGS.indexOf(cell.by) + 1);
+      // The last rung is on the way only for a kind with the field forwards.
+      const end = cell.by === undefined ? ATTRIBUTE_RUNGS.length - (tree?.forwards === undefined ? 1 : 0) : ATTRIBUTE_RUNGS.indexOf(cell.by) + 1;
+      const rungs = ATTRIBUTE_RUNGS.slice(0, end);
       return cell.by === undefined ? { attribute: key, rungs } : { attribute: key, rungs, by: cell.by };
     },
     json(path) {
@@ -1256,8 +1462,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> {