@mark1russell7/coeval 0.21.0 → 0.23.0

package/src/deref.ts

@@ -58,6 +58,15 @@ export interface HostThing {
    * @returns What the step reaches, or `undefined` when the host does not know it yet. Then the kept read ends at the thing.
    */
   known?(key: Key): { readonly thing: Thing } | undefined;
+  /**
+   * This optional function holds a kept read (SCHED.OWN-NODE). The evaluation did not ask for that read. Thus a host
+   * that follows the reads of an evaluation can tell the two apart. The kernel calls this function of the root `world`
+   * around each kept read that resolves its path.
+   *
+   * @param read - This function does the read.
+   * @returns What `read` gives.
+   */
+  keeping?<T>(read: () => T): T;
 }
 
 /** Something that a path can reach: any value of the host, or a host thing. */
@@ -522,7 +531,8 @@ function walkQuick(start: unknown, path: readonly unknown[], plain: boolean, key
 /**
  * A compiled path: one static path for one navigator (PLAN.PATH). `compilePath` reads the root, the open roots and
  * the steps one time. It asks the ladder of the verb `step` for each step document one time. Each resolution then
- * examines only the values of the context.
+ * examines only the values of the context. Code of a language reads a compiled path with `resolveCompiled`, thus the
+ * list of reads gets the read (PLAN.PATH-READS).
  */
 export interface CompiledPath {
   /** The steps of the path, as the document gives them. The list of reads records these steps. */
@@ -530,7 +540,8 @@ export interface CompiledPath {
   /** The navigator of the compilation. A runtime with another navigator resolves the steps again. */
   readonly nav: Navigator;
   /**
-   * This function resolves the path from a context, without a record of hops.
+   * This function resolves the path from a context, without a record of hops. It records no read and it does not
+   * apply the grant of the evaluation, as `resolve` does not. Use it only outside an evaluation.
    *
    * @param ctx - The context.
    * @returns The same resolution as `resolve(nav, ctx, path, { hops: false })`.
@@ -592,8 +603,11 @@ class StaticPath implements CompiledPath {
  * - The walker of each step document comes from the ladder one time, here. The navigator and the step document do
  *   not change, thus the answer does not change either.
  *
+ * An evaluator of a language calls this function in its `compile`, with the field `machine` of the input, and reads the
+ * result with `resolveCompiled` (PLAN.PATH-EXPORT).
+ *
  * @param nav - The navigator. A plan compiles its paths for its machine.
- * @param path - The steps. The first step is a root.
+ * @param path - The steps. The first step is a root. The compiled path keeps this list, thus the host must not change it.
  * @returns The compiled path.
  */
 export function compilePath(nav: Navigator, path: readonly unknown[]): CompiledPath {

package/src/durable.ts

@@ -1,5 +1,5 @@
 import type { Context } from "./deref.ts";
-import type { Result } from "./errors.ts";
+import { type Result, overflowCount } from "./errors.ts";
 import { type Machine, type Plan, type PrepareOptions, type Read, prepare } from "./evaluate.ts";
 import { type DocFacts, type FactsOptions, factsOf } from "./facts.ts";
 import { type PrintOptions, type ReadPrints, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
@@ -126,20 +126,24 @@ const NO_READS: readonly Read[] = /* @__PURE__ */ Object.freeze([]);
 /** The key of the document `-0` in a cache of value documents. A `Map` finds the entry of `0` for `-0`. */
 const NEGATIVE_ZERO = /* @__PURE__ */ Symbol("coeval.negative-zero");
 
-/** This function makes a cache by document. A document object gives its value one time, as PLAN.CACHE says. */
-function byDocument<T>(make: (doc: unknown) => T): (doc: unknown) => T {
+/**
+ * This function makes a cache by document. A document object gives its value one time, as PLAN.CACHE says. A value
+ * that `lasts` refuses stays out of the cache, and the next call makes it again.
+ */
+function byDocument<T>(make: (doc: unknown) => T, lasts?: () => boolean): (doc: unknown) => T {
   const objects = new WeakMap<object, T>();
   const values = new Map<unknown, T>();
   return (doc) => {
     if (typeof doc === "object" && doc !== null) {
       if (objects.has(doc)) return objects.get(doc) as T;
       const made = make(doc);
-      objects.set(doc, made);
+      if (lasts === undefined || lasts()) objects.set(doc, made);
       return made;
     }
     const key = Object.is(doc, -0) ? NEGATIVE_ZERO : doc;
     if (values.has(key)) return values.get(key) as T;
     const made = make(doc);
+    if (lasts !== undefined && !lasts()) return made;
     if (values.size >= MAX_VALUES) values.clear();
     values.set(key, made);
     return made;
@@ -180,11 +184,19 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
   const results = new Map<unknown, Entry>();
   let current = machine;
   let epochs: Epochs = { structure: 0, data: 0 };
-  const plansOf = (m: Machine): ((doc: unknown) => Plan) =>
-    byDocument((doc) => {
-      counts.compiles += 1;
-      return prepare(m, doc, prepareOptions);
-    });
+  const plansOf = (m: Machine): ((doc: unknown) => Plan) => {
+    let before = 0;
+    // A compilation near the limit of the stack gives a plan that fails. That failure depends on the depth of the
+    // demand, not on the document, thus such a plan stays out of the cache (SCHED.DEEP-CYCLE-CHANGE).
+    return byDocument(
+      (doc) => {
+        counts.compiles += 1;
+        before = overflowCount();
+        return prepare(m, doc, prepareOptions);
+      },
+      () => overflowCount() === before,
+    );
+  };
   const factsFor = (m: Machine): ((doc: unknown) => DocFacts) =>
     byDocument((doc) => {
       counts.facts += 1;

package/src/errors.ts

@@ -116,6 +116,19 @@ export function isStackOverflow(error: unknown): boolean {
   }
 }
 
+/** The count of the stack overflows that `thrown` changed into `#DEPTH!`. */
+let overflows = 0;
+
+/**
+ * This function gives the count of the stack overflows that `thrown` changed into `#DEPTH!`. A schedule compares two
+ * counts. Thus it finds an overflow also when a document catches the error (SCHED.DEEP-CYCLE).
+ *
+ * @returns The count since the start of the process.
+ */
+export function overflowCount(): number {
+  return overflows;
+}
+
 /**
  * This function changes an exception into an error value. A `Failure` gives its error value. A stack overflow
  * gives `#DEPTH!`. Each other exception gives `#CALC!`, with the exception as the cause.
@@ -126,7 +139,10 @@ export function isStackOverflow(error: unknown): boolean {
  */
 export function thrown(error: unknown, who: string): Failed {
   if (error instanceof Failure) return { ok: false, error: error.error };
-  if (isStackOverflow(error)) return fail("#DEPTH!", `The nesting of ${who} is too deep for the stack of the host.`, { cause: error });
+  if (isStackOverflow(error)) {
+    overflows += 1;
+    return fail("#DEPTH!", `The nesting of ${who} is too deep for the stack of the host.`, { cause: error });
+  }
   return fail("#CALC!", `${upper(who)} threw: ${describe(error)}`, { cause: error });
 }
 

package/src/evaluate.ts

@@ -1004,9 +1004,24 @@ function keptPath(nav: Navigator, root: Context, path: readonly unknown[]): Kept
   }
 }
 
+/**
+ * This function resolves the path of a kept read. A reference on the path can reach a node of a schedule, thus the
+ * resolution goes through `keeping` of the root `world` (SCHED.OWN-NODE).
+ *
+ * @param nav - The world and the code of the evaluators.
+ * @param ctx - The context.
+ * @param path - The path of the kept read.
+ * @returns What the path reaches.
+ */
+function readKept(nav: Navigator, ctx: Context, path: readonly unknown[]): Result {
+  const read = (): Result => readAgain(nav, ctx, path, false).reached;
+  const world = ctx.world;
+  return isHostThing(world) && world.keeping !== undefined ? world.keeping(read) : read();
+}
+
 /**
  * This function resolves the path of a kept read again, for `verifyReads` (SCHED.CLOSURE). It walks the path as
- * `keptPath` did. A host thing with `known` answers its step. A path without such a step resolves with `readAgain`.
+ * `keptPath` did. A host thing with `known` answers its step. A path without such a step resolves with `readKept`.
  *
  * @param nav - The world and the code of the evaluators.
  * @param ctx - The new context.
@@ -1018,7 +1033,7 @@ export function keptAgain(nav: Navigator, ctx: Context, path: readonly unknown[]
   let here = adopt(ctx[path[0] as Root]);
   let known = false;
   // Before a step of `known`, each other answer of the walk is the answer of `readAgain`, as before SCHED.CLOSURE.
-  const other = (): Result | undefined => (known ? undefined : readAgain(nav, ctx, path, false).reached);
+  const other = (): Result | undefined => (known ? undefined : readKept(nav, ctx, path));
   for (let index = 1; index < path.length; index += 1) {
     if (isHostThing(here)) {
       if (here.known === undefined) return other();
@@ -1049,6 +1064,22 @@ function readingOf(list: Read[] | undefined, root: Context): Reading | undefined
 
 /** This class holds the state of one evaluation or run: the machine, the effects, the clock and the trace. */
 class Session implements Runtime {
+  readonly machine: Machine;
+  /**
+   * The epoch of the evaluation: the list of capabilities that the host gave the root (CAP.NARROW-KEPT). A context
+   * keeps its grant only in an evaluation of the same epoch.
+   */
+  readonly epoch: readonly Cap[];
+  readonly running: boolean;
+  readonly traced: boolean;
+  readonly perform: Perform | undefined;
+  readonly signal: StopSignal | undefined;
+  /**
+   * The record of the reads. Without it, a resolution records nothing. A nested evaluation of an equation of a tree
+   * shares the record of the evaluation around it (READS.EQUATION).
+   */
+  readonly reading: Reading | undefined;
+
   /** The list of the effects. It is made at the first effect, thus an evaluation without effects makes no list. */
   private list: Effect[] | undefined;
   tick = 0;
@@ -1067,23 +1098,22 @@ class Session implements Runtime {
   private scope: Scope | undefined;
 
   constructor(
-    readonly machine: Machine,
-    /**
-     * The epoch of the evaluation: the list of capabilities that the host gave the root (CAP.NARROW-KEPT). A context
-     * keeps its grant only in an evaluation of the same epoch.
-     */
-    readonly epoch: readonly Cap[],
-    readonly running: boolean,
-    readonly traced: boolean,
-    readonly perform: Perform | undefined,
-    readonly signal: StopSignal | undefined,
+    machine: Machine,
+    epoch: readonly Cap[],
+    running: boolean,
+    traced: boolean,
+    perform: Perform | undefined,
+    signal: StopSignal | undefined,
     effects: Effect[] | undefined,
-    /**
-     * The record of the reads. Without it, a resolution records nothing. A nested evaluation of an equation of a tree
-     * shares the record of the evaluation around it (READS.EQUATION).
-     */
-    readonly reading: Reading | undefined = undefined,
+    reading: Reading | undefined = undefined,
   ) {
+    this.machine = machine;
+    this.epoch = epoch;
+    this.running = running;
+    this.traced = traced;
+    this.perform = perform;
+    this.signal = signal;
+    this.reading = reading;
     this.list = effects;
     this.holder = traced ? holderNode() : undefined;
     this.current = this.holder;
@@ -1185,7 +1215,7 @@ class Session implements Runtime {
     if (paths.has(text) || paths.has(JSON.stringify([root]))) return true;
     paths.add(text);
     if (path.length === 1 && root === "self") reading.self = true;
-    reading.list.push({ path, reached: walk.reached ?? readAgain(this.machine, reading.root, path, false).reached, free: true, kept: true });
+    reading.list.push({ path, reached: walk.reached ?? readKept(this.machine, reading.root, path), free: true, kept: true });
     return true;
   }
 
@@ -1197,7 +1227,7 @@ class Session implements Runtime {
     for (const root of roots) {
       if (root === "self") reading.self = true;
       const path = [root];
-      reading.list.push({ path, reached: readAgain(this.machine, reading.root, path, false).reached, free: true, kept: true });
+      reading.list.push({ path, reached: readKept(this.machine, reading.root, path), free: true, kept: true });
     }
   }
 
@@ -1422,7 +1452,9 @@ class Session implements Runtime {
 
 /**
  * This function resolves a compiled path through a runtime (PLAN.PATH). The runtime of the kernel uses the compiled
- * path. Each other runtime gets the steps through `resolve`, thus a runtime that wraps another runtime sees each path.
+ * path. Each other runtime gets the steps through `resolve`, thus a runtime that wraps another runtime sees each path
+ * (PLAN.PATH-ROUTE). The result and the list of reads are the same as for `rt.resolve(ctx, compiled.path)`
+ * (PLAN.PATH-READS).
  *
  * @param rt - The runtime.
  * @param ctx - The context.
@@ -1831,6 +1863,7 @@ function freeOf(doc: Envelope, kind: Kind, slots: readonly PartSlot[], frees: re
 
 /** This class is the runtime of a fold. It reads only the names that the folded part binds, and it causes no effect. */
 class Probe implements Runtime {
+  readonly machine: Machine;
   readonly running = false;
   /** `true` after the part asked for something that a fold cannot give. */
   refused = false;
@@ -1842,7 +1875,8 @@ class Probe implements Runtime {
    */
   readonly root: Context;
 
-  constructor(readonly machine: Machine) {
+  constructor(machine: Machine) {
+    this.machine = machine;
     const refuse = (): void => {
       this.refused = true;
     };

package/src/formula.ts

@@ -97,7 +97,11 @@ const SKIPPED: unique symbol = /* @__PURE__ */ Symbol("skipped");
 
 /** The value of a name whose binding failed. A reference to the name gives the error. */
 export class Held {
-  constructor(readonly error: EvalError) {}
+  readonly error: EvalError;
+
+  constructor(error: EvalError) {
+    this.error = error;
+  }
 }
 
 const CLOSURE: unique symbol = /* @__PURE__ */ Symbol.for("coeval.closure") as never;
@@ -115,6 +119,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).
@@ -236,6 +246,36 @@ function isSignature(value: unknown): value is Signature {
   return typeof value === "object" && value !== null && Array.isArray((value as { readonly params?: unknown }).params) && Object.hasOwn(value, "to");
 }
 
+/** This function gives the signatures of an operation as the profile holds them, or `undefined` for no entry. */
+function rawSignatures(profile: FormulaProfile, name: string): readonly unknown[] | undefined {
+  const sigs = profile.sigs;
+  if (sigs === undefined) return undefined;
+  let found: unknown;
+  if (typeof sigs === "function") {
+    try {
+      found = sigs(name);
+    } catch {
+      return undefined;
+    }
+  } else {
+    found = Object.hasOwn(sigs, name) ? sigs[name] : undefined;
+  }
+  if (found === undefined) return undefined;
+  return Array.isArray(found) ? found : [found];
+}
+
+/**
+ * This function gives each signature of an operation that has the form of a signature, for `conforms` (D137). The
+ * kernel does not export the function.
+ *
+ * @param profile - The profile.
+ * @param name - The name of the operation.
+ * @returns The signatures.
+ */
+export function signaturesOf(profile: FormulaProfile, name: string): readonly Signature[] {
+  return (rawSignatures(profile, name) ?? []).filter(isSignature);
+}
+
 /** This function tells if two signatures have the same parameters and the same rest parameter. */
 function sameParams(a: Signature, b: Signature): boolean {
   if (!docEquals(a.params, b.params)) return false;
@@ -323,22 +363,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
   };
   const logicValue = profile.logic === "value";
   const otherwise = Object.hasOwn(profile, "otherwise") ? valueType(profile.otherwise) : "null";
-  const lookup = (name: string): readonly unknown[] | undefined => {
-    const sigs = profile.sigs;
-    if (sigs === undefined) return undefined;
-    let found: unknown;
-    if (typeof sigs === "function") {
-      try {
-        found = sigs(name);
-      } catch {
-        return undefined;
-      }
-    } else {
-      found = Object.hasOwn(sigs, name) ? sigs[name] : undefined;
-    }
-    if (found === undefined) return undefined;
-    return Array.isArray(found) ? found : [found];
-  };
+  const lookup = (name: string): readonly unknown[] | undefined => rawSignatures(profile, name);
   const nameOf = (input: TypeInput): string => input.typePath.slice(1).join(".");
   /** The signatures of an operation. Each type of a signature is a contract, thus the check examines it one time. */
   const signatures = (input: TypeInput): { readonly sigs: readonly Signature[]; readonly bad: boolean } | undefined => {
@@ -638,6 +663,29 @@ export function declaredTruthOf(code: unknown): DeclaredTruth | undefined {
   return (typeof code === "object" || typeof code === "function") && code !== null ? truthByCode.get(code) : undefined;
 }
 
+/** An evaluator of the kit that reads functions of a profile: its name, and the fields of the profile (D137). */
+export interface ProfileReader {
+  readonly name: string;
+  readonly profile: FormulaProfile;
+}
+
+/** The evaluators of the kit that `conforms` examines the functions of a profile with. */
+const PROFILE_READERS: readonly string[] = ["formula.op", "formula.ext", "formula.record", "formula.ref"];
+
+/** The profile of each evaluator of the kit that reads its functions, for `conforms` (D137). */
+const readerByCode = /* @__PURE__ */ new WeakMap<object, ProfileReader>();
+
+/**
+ * This function gives the profile of an evaluator of the kit, when that evaluator reads functions of the profile
+ * (D137). The kernel does not export the function.
+ *
+ * @param code - The evaluator or the runner.
+ * @returns The name of the evaluator and the profile, or `undefined`.
+ */
+export function profileReaderOf(code: unknown): ProfileReader | undefined {
+  return (typeof code === "object" || typeof code === "function") && code !== null ? readerByCode.get(code) : undefined;
+}
+
 /** This function makes new evaluators of the formula kit for the fields of one profile. */
 function makeEvaluators(profile: FormulaProfile): Readonly<Record<string, Evaluator>> {
   const evaluators = formulaCode(profile);
@@ -650,6 +698,7 @@ function makeEvaluators(profile: FormulaProfile): Readonly<Record<string, Evalua
     const type = Object.hasOwn(types, name) ? types[name] : undefined;
     const made = Object.freeze(type === undefined ? evaluator : { compile: evaluator.compile, type });
     if (truth !== undefined && TRUTH_READERS.includes(name)) truthByCode.set(made, truth);
+    if (PROFILE_READERS.includes(name)) readerByCode.set(made, { name, profile });
     out[name] = made;
   }
   return Object.freeze(out);
@@ -925,15 +974,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,11 @@ export {
   type World,
   type WorldEntry,
   CIRCULAR_LIMIT,
+  GENERATION_LIMIT,
+  argsKey,
+  atArgsOf,
+  atRuleOf,
+  documentKey,
   circularOf,
   collectOf,
   effectsOfVerb,
@@ -98,6 +106,7 @@ export {
 export { type StepKey, type StepLadder, type StepNeed, type StepReason, type StepRefusal, type StepWalk, checkStep, isStep, stepLadder, stepOf, stepRank } from "./steps.ts";
 export {
   type Cap,
+  type CompiledPath,
   type Context,
   type DerefCode,
   type Hop,
@@ -115,6 +124,7 @@ export {
   type Walker,
   ROOTS,
   THING,
+  compilePath,
   context,
   derefStep,
   isHostThing,
@@ -170,6 +180,7 @@ export {
   permits,
   planner,
   prepare,
+  resolveCompiled,
   run,
 } from "./evaluate.ts";
 export {
@@ -249,10 +260,12 @@ export {
   jsTruthy,
 } from "./formula.ts";
 export { decodeDomain, decodeValue, encodeValue } from "./codec.ts";
+export { type CodecFinding, type CodecLaw, type CodecLawsOptions, type CodecProbe, codecLaws } from "./codec-laws.ts";
 export {
   type ParseResult,
   type SyntaxAssoc,
   type SyntaxCalls,
+  type SyntaxConstructs,
   type SyntaxEnvelopes,
   type SyntaxFixity,
   type SyntaxForm,
@@ -264,6 +277,7 @@ export {
   type SyntaxProfile,
   type SyntaxRefPattern,
   type SyntaxRefs,
+  MAX_SYNTAX_ISSUES,
   STD_SYNTAX,
   parse,
   print,
@@ -276,12 +290,14 @@ export { sameResult } from "./same.ts";
 export { type PrintOptions, type ReadPrints, type ReadsCheck, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
 export { type Durable, type DurableCounts, type DurableOptions, type Epochs, durable } from "./durable.ts";
 export {
+  type CycleIssue,
   type NodeEdge,
   type NodeInfo,
   type NodeRunOptions,
   type Schedule,
   type ScheduleCounts,
   type ScheduleOptions,
+  checkCycles,
   edgesOf,
   schedule,
 } from "./schedule.ts";

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);
@@ -465,7 +504,22 @@ function rungReads(b: Builder, id: string): void {
     collectReads(b, node, key, collect, later);
     return;
   }
-  if (declared?.default !== undefined) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.default`, declared.default), node, undefined, later);
+  if (declared?.default !== undefined) {
+    termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.default`, declared.default), node, undefined, later);
+    return;
+  }
+  // The document of a higher-order attribute is known only in the run, thus its reads are not known (TREE.HIGHER-CHECK).
+  if (declared?.higher !== undefined) {
+    termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.higher`, declared.higher), node, undefined, later);
+    edge(b, undefined, later);
+    return;
+  }
+  // The last rung reads the attribute `forwards` and an attribute of a node that only the run knows (TREE.FORWARD-CHECK).
+  const forwards = tree?.forwards;
+  if (typeof forwards === "string" && forwards !== key) {
+    edge(b, vertexOf(b, node, forwards), later);
+    edge(b, undefined, later);
+  }
 }
 
 /** This function gives the list children of a node before the run. A node without a rung for it has no children. */
@@ -634,7 +688,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(", ")}]`;
 }
 
 /**