@mark1russell7/coeval 0.20.1 → 0.22.0

package/package.json

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

package/src/conform.ts

@@ -214,6 +214,8 @@ interface Sample {
   readonly otherSplit: SplitOk;
   /** `true` for each part that a lazy rule covers. */
   readonly lazy: readonly boolean[];
+  /** `true` for each part that a rule `drives` covers: the runner can evaluate it with its code (D119). */
+  readonly driven: readonly boolean[];
   /** The names that the scope rules give each part. */
   readonly names: readonly (readonly string[])[];
 }
@@ -282,6 +284,8 @@ interface Contract {
   readonly declared: readonly Cap[];
   readonly pure: boolean;
   readonly lazy: readonly LazyRule[] | undefined;
+  /** The parts that the runner evaluates with its code, without a wait (RUN.DRIVES). */
+  readonly drives: readonly LazyRule[] | undefined;
   /** `true` when the facts describe the verb: they describe only `eval`. */
   readonly describes: boolean;
   /** `true` when the contract declares the effects of the verb: for `eval`, and for a verb in `verbEffects`. */
@@ -315,6 +319,8 @@ class Shot implements Runtime {
     readonly context: Context,
     /** The key of each part, for the reasons. */
     readonly keys: readonly string[],
+    /** `true` for each part that the runner can evaluate with its code, by the rules `drives` (D119). */
+    private readonly driven: readonly boolean[],
     private readonly perform: Perform | undefined,
     /** The resolutions of an earlier evaluation. Each resolution with the same path gets the same answer (C4). */
     private readonly replay: readonly Asked[] | undefined,
@@ -334,8 +340,8 @@ class Shot implements Runtime {
     this.calls.push({ part, via, context: ctx, later: this.afterwards });
     const key = this.keys[part] ?? String(part);
     if (via === "run" && !this.runner) this.problems.push(`The code of an evaluator starts the steps of the part ${key}. Only a runner waits.`);
-    if (via === "code" && this.runner && this.running) {
-      this.problems.push(`The runner evaluates the part ${key} with its code, and that code cannot wait. A runner evaluates a part with its steps (K65).`);
+    if (via === "code" && this.runner && this.running && this.driven[part] !== true) {
+      this.problems.push(`The runner evaluates the part ${key} with its code, and that code cannot wait. A runner evaluates a part with its steps, or its contract declares the part in drives (D119).`);
     }
     return this.scenario.results[part] ?? NO_RESULT;
   }
@@ -498,13 +504,15 @@ function typesNaming(world: World, name: string, verb: string): readonly TypeRef
 function contractOf(env: Env, kind: Kind, typePath: readonly Key[], caps: readonly Cap[] | undefined): Contract {
   const facts = env.machine.facts?.(typePath, env.name);
   // A verb without a declaration keeps the effects of eval for the capabilities of the probes, as before D49.
-  const own = effectsOfVerb(kind, env.verb);
+  // For eval, the effects of the answer of the hook win over the contract, as in check (D118).
+  const own = (env.verb === "eval" ? facts?.effects : undefined) ?? effectsOfVerb(kind, env.verb);
   const effects = own ?? kind.effects;
   const declared: readonly Cap[] = effects === undefined ? [] : effects === "type" ? [typePath] : effects;
   return {
     declared,
     pure: (facts?.pure ?? kind.pure) === true,
     lazy: facts?.lazy ?? kind.lazy,
+    drives: env.verb === "eval" ? (facts?.drives ?? kind.drives) : undefined,
     describes: env.verb === "eval",
     declares: own !== undefined,
     caps: caps ?? [...declared, "probe"],
@@ -637,6 +645,7 @@ function samplesOf(type: TypeRef, typePath: readonly Key[], kind: Kind, contract
       other: { type, value: otherValue },
       otherSplit,
       lazy: split.parts.map((_slot, index) => contract.lazy?.some((rule) => covers(rule, split.parts, index)) === true),
+      driven: split.parts.map((_slot, index) => contract.drives?.some((rule) => covers(rule, split.parts, index)) === true),
       names: scopesOf(kind.scope, value, split.parts).sees,
     });
   }
@@ -769,7 +778,7 @@ function instanceOf(env: Env, under: Under, doc: Envelope, split: SplitOk, sampl
 /** This function evaluates a probe document one time in a new shot. */
 function shoot(env: Env, instance: Instance, sample: Sample, scenario: Scenario, more: { readonly context?: Context; readonly replay?: readonly Asked[] } = {}): Shot {
   const context = more.context ?? rootContext(env.machine, makeContext(env.names, scenario.caps));
-  const shot = new Shot(env.machine, env.runner, scenario, context, sample.split.parts.map((slot) => slot.key), env.perform, more.replay);
+  const shot = new Shot(env.machine, env.runner, scenario, context, sample.split.parts.map((slot) => slot.key), sample.driven, env.perform, more.replay);
   instance(shot);
   return shot;
 }

package/src/deref.ts

@@ -2,6 +2,7 @@ import { type Envelope, type Json, type JsonRecord, type Key, type TypeRef, fiel
 import { type Kind, type World, entriesAsJson, lookupKind } from "./world.ts";
 import { answerOf } from "./ladder.ts";
 import type { ErrorCode } from "./errors.ts";
+import type { ValueType } from "./types.ts";
 
 /**
  * The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
@@ -169,8 +170,37 @@ export interface WalkInput {
   readonly visit?: (key: Key, thing: Thing) => void;
 }
 
-/** A walker: the code of the verb `step` of a kind of step documents. */
-export type Walker = (input: WalkInput) => WalkResult;
+/** The input of the type rule of a walker: the data of the step document, and the type of the thing before the step. */
+export interface WalkTypeInput {
+  /** The value of the step document. A step document with parts has no type rule, thus this value holds no part. */
+  readonly data: Json;
+  /** The type of the thing that the path reached before this step. */
+  readonly here: ValueType;
+}
+
+/**
+ * A walker: the code of the verb `step` of a kind of step documents. A plain function is a walker.
+ *
+ * A walker can hold a type rule in its field `type` (TYPE.WALKER, D121). The rule gives the type of each thing that
+ * the walker reaches from a thing of the type `here`. It must be sound, as the rule of an evaluator. A walker
+ * without a rule reaches the type `unknown`. A host gives the rule with `Object.assign(walker, { type })`.
+ */
+export interface Walker {
+  /**
+   * This function answers the step document on the thing that the path reached.
+   *
+   * @param input - The data of the step document, the thing before the step and the ladder.
+   * @returns What the step reached, or the reason of a failure.
+   */
+  (input: WalkInput): WalkResult;
+  /**
+   * This optional function gives the type of what the walker reaches.
+   *
+   * @param input - The data of the step document and the type before the step.
+   * @returns The type of each thing that the walker reaches.
+   */
+  readonly type?: (input: WalkTypeInput) => ValueType;
+}
 
 /**
  * What a resolution needs: the world, and the code of the `deref` evaluators and of the walkers.

package/src/effects.ts

@@ -46,7 +46,7 @@ function reaching(machine: Machine, doc: unknown, options: EffectsOptions): read
     doc,
     (v) => {
       const caps = v.caps ?? EACH;
-      for (const kind of declaredEffects(v)) if (rule(caps, kind)) out.push({ kind, visit: v });
+      for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind)) out.push({ kind, visit: v });
       return undefined;
     },
     { caps: options.caps ?? EACH, ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }) },
@@ -65,7 +65,9 @@ function reaching(machine: Machine, doc: unknown, options: EffectsOptions): read
  *
  * The result covers each effect that an evaluation or a run gives the host (CAP.EFFECTS-SOUND). A procedure value keeps
  * the capabilities of the document that made it, thus the effects of its body count at the body (CAP.LATENT). The
- * contract describes the code of its kind. The code of an own entry for another evaluator is outside the result.
+ * contract describes the code of its kind. The contract does not describe the code of an own entry for another
+ * evaluator. The answer of the hook `facts` for that code gives its effects (CAP.OWN-EFFECTS, D118). Without an
+ * answer, its effects are outside the result.
  *
  * @param machine - The world and its contracts, and the hook `permits`.
  * @param doc - The document, as JSON.

package/src/evaluate.ts

@@ -1792,6 +1792,8 @@ function pureCode(c: Compiler, envelope: Envelope | undefined, kind: Kind, typeP
   } catch {
     return false;
   }
+  // The effects of the answer of the hook make the code not pure, also for an own entry (D118).
+  if (answer?.effects !== undefined && answer.effects.length > 0) return false;
   // The contract of the kind describes the code of its own name, or an own entry that names the same code (D24).
   const described = c.verb === "eval" && (envelope === undefined || quick?.rung !== "own" || name === answerOf(c.machine.world, undefined, kind, c.verb)?.name);
   const pure = described ? (answer?.pure ?? kind.pure) : answer?.pure;

package/src/facts.ts

@@ -4,7 +4,7 @@ import { answerOf } from "./ladder.ts";
 import { pathMatches, splitParts } from "./parts.ts";
 import { type Root, ROOTS, isRef } from "./deref.ts";
 import type { Machine } from "./evaluate.ts";
-import { type DocVisit, type WalkOptions, declaredEffects, equationsOf, walk } from "./static.ts";
+import { type DocVisit, type WalkOptions, declaredEffects, effectKeys, equationsOf, walk } from "./static.ts";
 
 /**
  * One read of a document: a free reference, with its marks (FACTS.READS). A plan resolves the path of the reference
@@ -272,7 +272,8 @@ export function factsOf(machine: Machine, doc: unknown, options: FactsOptions =
         }
         // check and effectsOf read the declared effects with the same function (D27). The verb of the facts selects the
         // declaration: effects for eval, and the entry of verbEffects for another verb (D49, D111).
-        const declared = declaredEffects(v, verb);
+        // The answer of the hook for the code of eval wins over the contract, also for an own entry (D118).
+        const declared = verb === "eval" && answer?.effects !== undefined ? effectKeys(v, answer.effects) : declaredEffects(v, verb);
         // The field side gives the side of eval. For another verb, a declared effect needs a runner, as in check, thus
         // the run side (FACTS.VERB-SIDE).
         const runs = verb === "eval" ? kind.side === "run" : declared.length > 0;

package/src/formula.ts

@@ -1,6 +1,7 @@
-import { type Json, type Key, docEquals, isKey, isRecord } from "./doc.ts";
+import { type Json, type Key, docEquals, isKey, isRecord, typeName } from "./doc.ts";
+import { partsOf as docParts } from "./parts.ts";
 import type { Kind, KindFacts, LazyRule, WorldEntry } from "./world.ts";
-import { type CompiledPath, type Context, type Resolution, compilePath, valueOfThing } from "./deref.ts";
+import { type CompiledPath, type Context, type Resolution, compilePath, valueOfThing, walkerOf } from "./deref.ts";
 import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } from "./errors.ts";
 import { type Code, type CompileInput, type CompiledEvaluator, type CompiledPart, type Evaluator, type Machine, type Runtime, resolveCompiled, totalCode } from "./evaluate.ts";
 import { type MachinePart, mergeMachines } from "./merge.ts";
@@ -114,6 +115,12 @@ export function isClosure(value: unknown): value is Closure {
   return typeof value === "function" && (value as Partial<Closure>)[CLOSURE] !== undefined;
 }
 
+/**
+ * The runtime of an evaluation with the clock of `call` (FORMULA.CALL-DEPTH, D125): the count of the applications of
+ * closures that run at this time. The first application adds the field, thus an evaluation without one has no field.
+ */
+type Clocked = Runtime & { applying?: number };
+
 /**
  * The standard extensions: the values that JSON cannot write. `ext.domain` reads a member of a domain through the
  * codec of the domain (EXT.DOMAIN, D40).
@@ -278,6 +285,29 @@ function paramsOf(value: unknown): readonly string[] {
   return Array.isArray(params) ? params.filter((param): param is string => typeof param === "string") : [];
 }
 
+/** This function gives the text of a step of a path: a key, or the kind of a step document in parentheses. */
+function stepText(step: unknown): string {
+  if (isKey(step)) return String(step);
+  return isRecord(step) ? `(${typeName(step["type"] as Parameters<typeof typeName>[0])})` : "(step)";
+}
+
+/**
+ * This function gives the type of what a step document reaches (TYPE.WALKER, D121). The type rule of its walker gives
+ * it. A step document with parts gets its data in the run, thus its type is `unknown`, as for a walker without a rule.
+ *
+ * @param input - The input of the rule of the reference.
+ * @param step - The step document.
+ * @param here - The type before the step.
+ * @returns The type of what the step reaches.
+ */
+function walkType(input: TypeInput, step: unknown, here: ValueType): ValueType {
+  const rule = walkerOf(input.machine, step)?.type;
+  if (rule === undefined) return "unknown";
+  const read = docParts(input.machine.world, step);
+  if (!read.ok || !read.split.ok || read.split.parts.length > 0) return "unknown";
+  return input.contract(rule({ data: read.doc.value, here }), `type of the step ${typeName(read.doc.type)}`);
+}
+
 /**
  * This function makes the type rules of the formula kit for one profile (TYPE.SYNTH, D25). Each evaluator of the kit
  * holds its rule. The rules read the rules of the profile that change a type: `truthy`, `truthType`, `logic`,
@@ -395,12 +425,14 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
           if (isUnknown(type, domains) || (!plain && holdsEnvelope(type, domains))) return "unknown";
           if (index >= path.length) return type;
           const step = path[index];
-          // A step document gives what its walker reaches. It has no type yet.
-          if (!isKey(step)) return "unknown";
+          if (!isKey(step)) {
+            type = walkType(input, step, type);
+            continue;
+          }
           const next = stepType(type, step, domains, input.contract);
           if ("missing" in next) {
             const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
-            report({ reason: `The value at ${path.slice(0, index).map(String).join(".")} has no field ${String(step)}.${fields}` });
+            report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
             return "unknown";
           }
           type = next.type;
@@ -899,15 +931,26 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
         }
         return known;
       };
+      // The clock of call permits a quarter of the depth limit, because an application nests its body (D125).
+      const limit = Math.ceil((machine.maxDepth ?? 1000) / 4);
       return (ctx, rt) => {
         // A closure keeps the context for each later use, thus the list of reads gets each path that it can read (READS.CLOSURE).
         rt.keepsContext?.(ctx, reads);
+        const clock = rt as Clocked;
         const closure = (...args: readonly unknown[]): unknown => {
-          const scope: Record<string, unknown> = { ...ctx.names };
-          names.forEach((name, index) => setOwn(scope, name, args[index]));
-          const result = body.code({ ...ctx, names: scope }, rt);
-          if (!result.ok) throw new Failure(result.error);
-          return result.value;
+          // Each application counts one level on the runtime of its evaluation, and the count goes down after it (FORMULA.CALL-DEPTH).
+          const level = (clock.applying ?? 0) + 1;
+          if (level > limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+          clock.applying = level;
+          try {
+            const scope: Record<string, unknown> = { ...ctx.names };
+            names.forEach((name, index) => setOwn(scope, name, args[index]));
+            const result = body.code({ ...ctx, names: scope }, rt);
+            if (!result.ok) throw new Failure(result.error);
+            return result.value;
+          } finally {
+            clock.applying = level - 1;
+          }
         };
         Object.defineProperty(closure, CLOSURE, { value: { params: names } });
         return ok(closure);

package/src/index.ts

@@ -36,10 +36,15 @@ export {
 } from "./errors.ts";
 export {
   type Alias,
+  type AtArgs,
+  type AtEquation,
+  type AtRule,
   type AttributeDeclaration,
   type CapsRule,
   type CircularDeclaration,
   type CircularRule,
+  type CollectDeclaration,
+  type CollectRule,
   type Kind,
   type KindFacts,
   type LazyRule,
@@ -55,7 +60,11 @@ export {
   type World,
   type WorldEntry,
   CIRCULAR_LIMIT,
+  argsKey,
+  atArgsOf,
+  atRuleOf,
   circularOf,
+  collectOf,
   effectsOfVerb,
   entriesAsJson,
   equationType,
@@ -108,6 +117,7 @@ export {
   type Thing,
   type WalkInput,
   type WalkResult,
+  type WalkTypeInput,
   type Walker,
   ROOTS,
   THING,

package/src/instances.ts

@@ -1,5 +1,5 @@
 import { type Json, type Key, field, isKey, isRecord, typeName } from "./doc.ts";
-import { type Kind, 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);
@@ -460,9 +499,58 @@ function rungReads(b: Builder, id: string): void {
     termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.fold.combine`, fold.combine), node, undefined, combined ? later : { ...later, lazy: true });
     return;
   }
+  const collect = declared?.collect === undefined ? undefined : collectOf(declared.collect);
+  if (collect?.ok === true) {
+    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);
 }
 
+/** This function gives the list children of a node before the run. A node without a rung for it has no children. */
+function childrenOf(b: Builder, at: NodeInfo): Value {
+  const part = at.parts.get("children");
+  if (part !== undefined) return valueOf(part);
+  const tree = at.kind.tree;
+  if (hasOwnEntry(tree?.equations, "children") || hasOwnEntry(tree?.attributes, "children")) return "unknown";
+  if (at.up === undefined) return downNames(b.machine.world).has("children") ? "unknown" : "data";
+  return at.up !== null && hasOwnEntry(at.up.kind.tree?.down, "children") ? "unknown" : "data";
+}
+
+/**
+ * This function adds the reads of a collection (TREE.COLLECT, D122), in the order of the run. Each node of the subtree
+ * gives the reads of its contribution and of its list `children`. A list that only the run knows gives an edge with an
+ * unknown source. The registry of names reads only the lists `children`.
+ */
+function collectReads(b: Builder, node: NodeInfo, key: string, rule: CollectRule & { readonly ok: true }, later: Reader): void {
+  if (!rule.names) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.collect.unit`, rule.unit), node, undefined, later);
+  let combined = false;
+  const done = new Set<NodeInfo>();
+  const stack: NodeInfo[] = [node];
+  while (stack.length > 0) {
+    const at = stack.pop() as NodeInfo;
+    if (done.has(at)) continue;
+    done.add(at);
+    const term = rule.names || !hasOwnEntry(at.kind.tree?.contributes, key) ? undefined : at.kind.tree?.contributes?.[key];
+    if (term !== undefined) {
+      termReads(b, termRefs(b, at.kind, `tree.contributes.${key}`, term), at, undefined, later);
+      combined = true;
+    }
+    edge(b, vertexOf(b, at, "children"), later);
+    const children = childrenOf(b, at);
+    if (children === "unknown") edge(b, undefined, later);
+    else if (typeof children === "object" && "list" in children) {
+      const items = itemsOf(children.list);
+      for (let index = items.length - 1; index >= 0; index -= 1) {
+        const child = items[index]?.node;
+        if (child !== undefined && child.up === at) stack.push(child);
+      }
+    }
+  }
+  // The combine evaluates once for each contribution, thus without a known contribution its reads are lazy.
+  if (!rule.names) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.collect.combine`, rule.combine), node, undefined, combined ? later : { ...later, lazy: true });
+}
+
 /** The vertices and the edges of a document, and the roots of the demand of the run: the own parts of each tree root. */
 interface Built {
   readonly b: Builder;
@@ -585,7 +673,8 @@ function allCircular(b: Builder, ids: readonly string[]): boolean {
 }
 
 function vertexText(vertex: AttributeVertex): string {
-  return `${vertex.attribute} of ${vertex.type} at [${vertex.place.join(", ")}]`;
+  const name = vertex.args === undefined ? vertex.attribute : `${vertex.attribute} with ${String(argsKey(vertex.args))}`;
+  return `${name} of ${vertex.type} at [${vertex.place.join(", ")}]`;
 }
 
 /**

package/src/parts.ts

@@ -1,5 +1,5 @@
 import { type Envelope, type Json, type Key, docEquals, isEnvelope, isRecord, typeName, typePath } from "./doc.ts";
-import { type Kind, type NamesSource, type ScopeRule, type Shape, type World, lookupKind } from "./world.ts";
+import { type Kind, type LazyRule, type NamesSource, type ScopeRule, type Shape, type World, lookupKind } from "./world.ts";
 import type { ValueType } from "./types.ts";
 
 /** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
@@ -269,6 +269,35 @@ export function pathMatches(path: readonly Key[], pattern: readonly Key[]): bool
   return true;
 }
 
+/**
+ * This function tells if a list of rules in the form of the lazy rules covers a part (D24, D119). A rule without
+ * `in` covers each part. With `after: n`, a rule covers only the parts after the first `n` parts that it matches.
+ *
+ * @param rules - The rules.
+ * @param shape - The shape of the parts of the parent.
+ * @param value - The value of the parent.
+ * @param slot - The path of the part in the value.
+ * @returns `true` when a rule covers the part.
+ */
+export function rulesCover(rules: readonly LazyRule[], shape: Shape | undefined, value: Json, slot: readonly Key[]): boolean {
+  for (const rule of rules) {
+    if (rule.in !== undefined && !rule.in.some((pattern) => pathMatches(slot, pattern))) continue;
+    const after = rule.after ?? 0;
+    if (after <= 0) return true;
+    const split = splitParts(shape, value);
+    let count = 0;
+    for (const part of split.ok ? split.parts : []) {
+      if (rule.in !== undefined && !rule.in.some((pattern) => pathMatches(part.path, pattern))) continue;
+      if (part.path.length === slot.length && pathMatches(part.path, slot)) {
+        if (count >= after) return true;
+        break;
+      }
+      count += 1;
+    }
+  }
+  return false;
+}
+
 function valueAt(value: unknown, path: readonly Key[]): unknown {
   let here: unknown = value;
   for (const key of path) {