@mark1russell7/coeval 0.18.0 → 0.19.0

package/src/static.ts

@@ -1,12 +1,13 @@
 import { type Envelope, type Json, type Key, isKey, isRecord, typeName } from "./doc.ts";
-import { type Kind, type Namespace, type World, type WorldEntry, effectsOfVerb, equationType, isKind, isNamespace } from "./world.ts";
+import { type Kind, type World, type WorldEntry, eachKind, effectsOfVerb, equationType, isKind, isNamespace } from "./world.ts";
 import { ask } from "./ladder.ts";
 import { type PartSlot, partsOf, scopesOf } from "./parts.ts";
 import { type Cap, type Context, type Root, ROOTS, context, isRef, walkerOf, worldThing } from "./deref.ts";
 import type { ErrorCode } from "./errors.ts";
 import { type Machine, partCaps, permits, waitedReason } from "./evaluate.ts";
 import type { ValueType } from "./types.ts";
-import { type RootTypes, type TypeNode, type Typed, typePass } from "./typing.ts";
+import { type RootTypes, type TypeNode, type Typed, machineTypeIssues, typePass } from "./typing.ts";
+import { cycleIssues } from "./instances.ts";
 
 /** One document that a walk visits. */
 export interface DocVisit {
@@ -528,19 +529,46 @@ export function typeCheck(machine: Machine, doc: unknown, options: CheckOptions
 /**
  * A problem of a world that `checkWorld` finds before a document exists (STATIC.COVERAGE). Each document of the
  * kind gives this problem for the verb, thus `check` with the verb finds it too.
+ *
+ * With the option `types`, a problem can also be a bad value type of the machine (TYPE.WORLD, D110). Such a problem has
+ * the code `#TYPE!` and the keys of the bad term in `at`.
  */
 export interface WorldIssue {
-  /** The code of the problem. `#NOEVAL`: no rung of the ladder gives an evaluator for the verb. */
-  readonly code: "#NOEVAL";
-  /** The keys of the kind from the root of the world. For a fallback kind, the keys of its namespace. */
+  /**
+   * The code of the problem. `#NOEVAL`: no rung of the ladder gives an evaluator for the verb. `#TYPE!`: a value type
+   * of the machine is not correct, or a declaration of types cannot be true.
+   */
+  readonly code: "#NOEVAL" | "#TYPE!";
+  /**
+   * The keys of the kind from the root of the world. For a fallback kind, the keys of its namespace. For a type of a
+   * domain or of a type rule, the list is empty.
+   */
   readonly kind: readonly Key[];
   /** `true` for the fallback kind of a namespace or of the world. */
   readonly fallback?: true;
-  /** The verb without an evaluator. */
+  /** The verb without an evaluator. A type issue has the verb `eval`, because the value types describe `eval` (D25). */
   readonly verb: string;
+  /** For a type issue of a domain: the name of the domain in `Machine.domains`. */
+  readonly domain?: string;
+  /** For a type issue of a type rule: the name of its evaluator in `Machine.evaluators`. */
+  readonly evaluator?: string;
+  /**
+   * For a type issue: the keys of the bad term in the kind, the domain or the declarations of the rule. An example is
+   * `["parts", "item", "expect"]`, or `["sigs", "add", 1, "params", 0]`.
+   */
+  readonly at?: readonly Key[];
   readonly reason: string;
 }
 
+/** The options of `checkWorld`. */
+export interface WorldOptions {
+  /**
+   * With `true`, the check also examines each value type of the machine (TYPE.WORLD, D110). It reads the contracts of
+   * the kinds, the domains and the declarations of the type rules. The default is `false`.
+   */
+  readonly types?: boolean;
+}
+
 /** This function tells if a table of verbs has an entry for a verb. */
 function hasVerb(table: Readonly<Record<string, string>> | undefined, verb: string): boolean {
   return table !== undefined && Object.hasOwn(table, verb);
@@ -552,44 +580,34 @@ function hasVerb(table: Readonly<Record<string, string>> | undefined, verb: stri
  * evaluator for the verb, thus the check gives the same proof of coverage as a type system.
  *
  * The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
- * world. It does not follow an alias, because the kind of an alias has its own place. The check reads only the world.
+ * world. It does not follow an alias, because the kind of an alias has its own place. Without the option `types`, the
+ * check reads only the world.
+ *
+ * With the option `types`, the check also examines each value type of the machine (TYPE.WORLD, D110). These issues
+ * have the code `#TYPE!`, and they come after the issues of the verbs.
  *
  * @param machine - The machine, for its world.
  * @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
+ * @param options - The option `types`.
  * @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
  *   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
  */
-export function checkWorld(machine: Machine, verbs: readonly string[]): readonly WorldIssue[] {
+export function checkWorld(machine: Machine, verbs: readonly string[], options: WorldOptions = {}): readonly WorldIssue[] {
   const world = machine.world;
   const open = verbs.filter((verb) => !hasVerb(world.defaults, verb));
   const out: WorldIssue[] = [];
-  if (open.length === 0) return out;
-  const visit = (kind: Kind, path: readonly Key[], fallback: boolean): void => {
-    const text = path.join(".");
-    const name = fallback ? (path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}`) : `the kind ${text}`;
-    for (const verb of open) {
-      if (hasVerb(kind.verbs, verb)) continue;
-      const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
-      out.push(fallback ? { code: "#NOEVAL", kind: path, fallback: true, verb, reason } : { code: "#NOEVAL", kind: path, verb, reason });
-    }
-  };
-  // The set holds the namespaces on the way, thus a namespace that holds itself does not loop.
-  const way = new Set<Namespace>();
-  const entries = (kinds: Readonly<Record<string, WorldEntry>>, path: readonly Key[]): void => {
-    for (const key of Object.keys(kinds)) {
-      const entry = kinds[key];
-      const here = [...path, key];
-      if (isKind(entry)) visit(entry, here, false);
-      else if (isNamespace(entry) && !way.has(entry)) {
-        way.add(entry);
-        entries(entry.kinds, here);
-        if (entry.fallback !== undefined) visit(entry.fallback, here, true);
-        way.delete(entry);
+  if (open.length > 0) {
+    eachKind(world, (kind, path, fallback) => {
+      const text = path.join(".");
+      const name = fallback ? (path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}`) : `the kind ${text}`;
+      for (const verb of open) {
+        if (hasVerb(kind.verbs, verb)) continue;
+        const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
+        out.push(fallback ? { code: "#NOEVAL", kind: path, fallback: true, verb, reason } : { code: "#NOEVAL", kind: path, verb, reason });
       }
-    }
-  };
-  entries(world.kinds, []);
-  if (world.fallback !== undefined) visit(world.fallback, [], true);
+    });
+  }
+  if (options.types === true) out.push(...machineTypeIssues(machine));
   return out;
 }
 
@@ -621,45 +639,316 @@ const FOLD_NAMES: readonly string[] = /* @__PURE__ */ Object.freeze(["acc", "ite
  * This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
  * `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
  */
-export function equationsOf(kind: Kind): readonly { readonly label: string; readonly term: Json; readonly names: readonly string[] }[] {
+export function equationsOf(kind: Kind): readonly Equation[] {
   const tree = kind.tree;
   if (tree === undefined) return [];
-  const out: { readonly label: string; readonly term: Json; readonly names: readonly string[] }[] = [];
-  for (const [name, term] of Object.entries(tree.equations ?? {})) out.push({ label: `tree.equations.${name}`, term, names: [] });
-  for (const [name, term] of Object.entries(tree.down ?? {})) out.push({ label: `tree.down.${name}`, term, names: DOWN_NAMES });
+  const out: Equation[] = [];
+  for (const [name, term] of Object.entries(tree.equations ?? {})) out.push({ label: `tree.equations.${name}`, term, names: [], attribute: name, down: false });
+  for (const [name, term] of Object.entries(tree.down ?? {})) out.push({ label: `tree.down.${name}`, term, names: DOWN_NAMES, attribute: name, down: true });
   for (const [name, declared] of Object.entries(tree.attributes ?? {})) {
     if (declared.fold !== undefined) {
-      out.push({ label: `tree.attributes.${name}.fold.unit`, term: declared.fold.unit, names: [] });
-      out.push({ label: `tree.attributes.${name}.fold.combine`, term: declared.fold.combine, names: FOLD_NAMES });
+      out.push({ label: `tree.attributes.${name}.fold.unit`, term: declared.fold.unit, names: [], attribute: name, down: false });
+      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: [] });
+    if (declared.default !== undefined) out.push({ label: `tree.attributes.${name}.default`, term: declared.default, names: [], attribute: name, down: false });
   }
   return out;
 }
 
+/** One equation of the tree contract of a kind, with the names that it sees (D42). */
+export interface Equation {
+  /** The path of the equation in the contract, for the reason of an issue. */
+  readonly label: string;
+  readonly term: Json;
+  readonly names: readonly string[];
+  /** The name of the attribute that the equation gives. */
+  readonly attribute: string;
+  /** `true` for an equation of `down`: it gives the attribute of a child. */
+  readonly down: boolean;
+}
+
+/**
+ * The steps that a node of the decorated tree answers before its ladder: `parent` and `type` (D106). An attribute with
+ * one of these names gets no read.
+ */
+const STRUCTURAL: Readonly<Record<string, string>> = /* @__PURE__ */ Object.freeze({
+  parent: "the step parent gives the parent of the node",
+  type: "the step type gives the type of the node",
+});
+
+/**
+ * The standard code that gives its parts the self of its own context (D106). `check` knows the self of a document only
+ * through this code and the nodes of the decorated tree.
+ */
+const KEEPS_SELF: ReadonlySet<string> = /* @__PURE__ */ new Set([
+  "data.number",
+  "data.text",
+  "data.bool",
+  "math.add",
+  "math.multiply",
+  "math.greater",
+  "control.seq",
+  "control.pure",
+  "control.if",
+  "list.all",
+  "effect.log",
+  "effect.write",
+]);
+
+/** This function tells if standard code gives its parts the self of its own context (D106). */
+export function keepsSelf(evaluator: string | undefined): boolean {
+  return evaluator !== undefined && KEEPS_SELF.has(evaluator);
+}
+
+/** The name of the standard code of a node of the decorated tree. */
+export const TREE_NODE = "tree.node";
+
+/** The name of the standard code of a reference. */
+export const REF_CODE = "ref.resolve";
+
+/** A node of the decorated tree that `check` knows (D106): the self of the code of its parts. */
+export interface SeenNode {
+  readonly kind: Kind;
+  /** The name of the kind, for the reason of an issue. */
+  readonly text: string;
+  /** The names of the own parts of the node. The node of an equation has `undefined`: it stands for each node of its kind. */
+  readonly own: ReadonlySet<string> | undefined;
+  /** The parent node. It is `undefined` when `check` does not know the parent. */
+  readonly parent: SeenNode | undefined;
+}
+
+/** The self of the code of each document of one walk, for the checks of attributes and the graph of attribute instances (D106, D107). */
+export interface Selves {
+  /**
+   * This function tells if a document is a node of the decorated tree whose attributes the walk knows.
+   *
+   * @param v - The visit of the document.
+   * @param evaluator - The evaluator that the ladder gives for the document.
+   */
+  isNode(v: DocVisit, evaluator: string | undefined): boolean;
+  /**
+   * This function gives the self of the code of a document, and its node when the document is a node. It records the
+   * self that the parts of the document get. The walk visits a document before its parts.
+   *
+   * @param v - The visit of the document.
+   * @param evaluator - The evaluator that the ladder gives for the document.
+   */
+  enter(v: DocVisit, evaluator: string | undefined): { readonly self: SeenNode | undefined; readonly node: SeenNode | undefined };
+}
+
+/**
+ * This function makes the selves of one walk (D106). Only `eval` reads attributes, and only when the root `self` is
+ * open. A node gets the self of its code as its parent. The standard code that keeps self gives its parts its own self.
+ * Other code gives its parts a self that the walk does not know.
+ *
+ * @param machine - The machine.
+ * @param verb - The verb of the walk.
+ * @param root - The self of the root document: the node of an equation, or `undefined`.
+ * @returns The selves.
+ */
+export function selvesOf(machine: Machine, verb: string, root: SeenNode | undefined): Selves {
+  const roots: readonly string[] = machine.roots ?? ROOTS;
+  const on = verb === "eval" && roots.includes("self") && hasEntry(machine.evaluators, TREE_NODE) && !hasEntry(machine.runners, TREE_NODE);
+  const selves = new Map<DocVisit, SeenNode | undefined>();
+  const isNode = (v: DocVisit, evaluator: string | undefined): boolean => on && evaluator === TREE_NODE && v.kind !== undefined;
+  return {
+    isNode,
+    enter(v, evaluator) {
+      const self = v.parent === undefined ? root : selves.get(v.parent);
+      if (!isNode(v, evaluator) || v.kind === undefined) {
+        selves.set(v, keepsSelf(evaluator) ? self : undefined);
+        return { self, node: undefined };
+      }
+      // The own parts are the parts of the split, as in a run. A field without a part is data, and no step reads it.
+      const read = partsOf(machine.world, v.declared ? v.doc.value : v.doc, v.declared ? typeName(v.doc.type) : undefined);
+      const own = read.ok && read.split.ok ? new Set(read.split.parts.map((part) => part.key)) : undefined;
+      const node: SeenNode = { kind: v.kind, text: typeName(v.doc.type), own, parent: self };
+      selves.set(v, node);
+      return { self, node };
+    },
+  };
+}
+
+/**
+ * This function tells if a name is a structural step of a node of the decorated tree: `parent` or `type` (D106). An
+ * attribute with such a name gets no read.
+ */
+export function isStructural(name: string): boolean {
+  return Object.hasOwn(STRUCTURAL, name);
+}
+
+/** One attribute that a kind needs at each of its nodes: a declaration, or a read in an equation (TREE.CHECK-COMPLETE). */
+interface Need {
+  readonly name: string;
+  /** The words of the reason that tell why the kind needs the attribute. */
+  readonly why: string;
+  /** The attribute of the equation with the read. An own part with this name hides the equation. */
+  readonly hidden: string | undefined;
+}
+
+/** The state of the checks of attributes in one check: the kinds that the check walked, and the needs of each kind. */
+interface TreeState {
+  readonly seen: Set<Kind>;
+  readonly needs: Map<Kind, Need[]>;
+}
+
+/** The names of `down` in the world of each machine, for a parent that `check` does not know (D106). */
+const DOWNS = /* @__PURE__ */ new WeakMap<World, ReadonlySet<string>>();
+
+/**
+ * This function gives each name that an equation of `down` of a kind of the world gives. The kinds include the kinds
+ * of the namespaces and each fallback kind (WORLD.OPEN). A parent that `check` does not know has one of these kinds.
+ */
+export function downNames(world: World): ReadonlySet<string> {
+  const known = DOWNS.get(world);
+  if (known !== undefined) return known;
+  const out = new Set<string>();
+  const done = new Set<object>();
+  const add = (kind: Kind | undefined): void => {
+    for (const name of Object.keys(kind?.tree?.down ?? {})) out.add(name);
+  };
+  const visit = (entries: Readonly<Record<string, WorldEntry>>, fallback: Kind | undefined): void => {
+    if (done.has(entries)) return;
+    done.add(entries);
+    add(fallback);
+    for (const entry of Object.values(entries)) {
+      if (isKind(entry)) add(entry);
+      else if (isNamespace(entry)) visit(entry.kinds, entry.fallback);
+    }
+  };
+  visit(world.kinds, world.fallback);
+  DOWNS.set(world, out);
+  return out;
+}
+
+/** This function tells if a table of a tree contract has its own entry for a name. */
+function hasEntry(table: Readonly<Record<string, unknown>> | undefined, name: string): boolean {
+  return table !== undefined && Object.hasOwn(table, name);
+}
+
+/**
+ * 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.
+ */
+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 (node.parent === undefined ? downNames(world).has(name) : hasEntry(node.parent.kind.tree?.down, name)) return true;
+  const declared = tree?.attributes !== undefined && Object.hasOwn(tree.attributes, name) ? tree.attributes[name] : undefined;
+  return declared !== undefined && (declared.copy === true || declared.fold !== undefined || declared.default !== undefined);
+}
+
 /**
  * This function checks the equations of the tree contract of a kind, each with the names of its rung (TREE.DOWN-NAMES).
  * An equation evaluates without capabilities, thus a check with capabilities gives it none. Each issue gets the place
- * of the document of the kind, and its reason names the equation.
+ * of the document of the kind, and its reason names the equation. The function also records the needs of the kind:
+ * each declared attribute, and each attribute of the node that an equation reads (TREE.CHECK-COMPLETE).
  */
-function equationIssues(machine: Machine, kind: Kind, kindText: string, options: CheckOptions, seen: Set<Kind>): readonly Issue[] {
+function equationIssues(machine: Machine, kind: Kind, kindText: string, options: CheckOptions, state: TreeState): readonly Issue[] {
   const of = equationType(kind);
   const out: Issue[] = [];
-  for (const { label, term, names } of equationsOf(kind)) {
+  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 });
+  const self: SeenNode = { kind, text: kindText, own: undefined, parent: undefined };
+  for (const { label, term, names, attribute, down } of equationsOf(kind)) {
     const inner: CheckOptions = { names, ...(of === undefined ? {} : { declaredType: of }), ...(options.caps === undefined ? {} : { caps: [] }) };
-    for (const issue of checkAll(machine, term, inner, undefined, seen)) {
+    const read = (name: string): void => {
+      needs.push({ name, why: `the equation ${label} reads it`, hidden: down ? 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}` });
     }
   }
   return out;
 }
 
+/**
+ * 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.
+ */
+function contractIssues(kind: Kind, kindText: string): readonly Issue[] {
+  const out: Issue[] = [];
+  const tree = kind.tree;
+  for (const table of ["equations", "down", "attributes"] as const) {
+    for (const 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}.` });
+    }
+  }
+  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.` });
+  }
+  return out;
+}
+
+/**
+ * This function finds the issues of a node of a document (D106). An own part with the name of a structural step is
+ * not read at any time (TREE.CHECK-RESERVED). Each need of the kind gets an answer from a rung (TREE.CHECK-COMPLETE).
+ */
+function nodeIssues(machine: Machine, node: SeenNode, state: TreeState, v: DocVisit): readonly Issue[] {
+  const out: Issue[] = [];
+  const at = (key: string): readonly Key[] => [...v.at, ...(v.declared ? [] : ["value"]), key];
+  for (const name of node.own ?? []) {
+    const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : undefined;
+    if (why !== undefined) out.push({ code: "#NAME?", place: v.place, reason: `The part ${name} of the kind ${node.text} has a reserved name: ${why}.`, at: at(name) });
+  }
+  const done = new Set<string>();
+  for (const need of state.needs.get(node.kind) ?? []) {
+    if (done.has(need.name) || (need.hidden !== undefined && node.own?.has(need.hidden) === true)) continue;
+    done.add(need.name);
+    if (answered(machine.world, node, need.name)) continue;
+    out.push({ code: "#N/A", place: v.place, reason: `No rung gives the attribute ${need.name} of the kind ${node.text}, and ${need.why}.`, at: v.at });
+  }
+  return out;
+}
+
+/**
+ * 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.
+ */
+function readIssue(machine: Machine, self: SeenNode | undefined, path: readonly Json[], rootSelf: RootSelf | undefined): { readonly index: number; readonly reason: string } | undefined {
+  let node = self;
+  let index = 1;
+  while (node !== undefined && index < path.length && path[index] === "parent") {
+    node = node.parent;
+    index += 1;
+  }
+  const step = path[index];
+  if (node === undefined || !isKey(step) || Object.hasOwn(STRUCTURAL, String(step))) return undefined;
+  const name = String(step);
+  if (node.own === undefined) {
+    if (node === rootSelf?.node) rootSelf.read(name);
+    return undefined;
+  }
+  return answered(machine.world, node, name) ? undefined : { index, reason: `No rung gives the attribute ${name} of the kind ${node.text}.` };
+}
+
+/** 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;
+  /** This function gets each attribute of the node of the equation that the equation reads. */
+  readonly read: (name: string) => void;
+}
+
 /**
  * This function finds the issues of `check`. With a list of nodes, it also records each document that it visits for
- * the pass of types. It marks each document with an issue. The set `seen` holds the kinds whose equations the check
- * walked, thus it walks the equations of each kind one time.
+ * the pass of types. It marks each document with an issue. The state holds the kinds whose equations the check
+ * walked, thus it walks the equations of each kind one time. In an equation, `rootSelf` is the node of the equation.
  */
-function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes: TypeNode[] | undefined, seen: Set<Kind> = new Set()): readonly Issue[] {
+function checkAll(
+  machine: Machine,
+  doc: unknown,
+  options: CheckOptions,
+  nodes: TypeNode[] | undefined,
+  state: TreeState = { seen: new Set(), needs: new Map() },
+  rootSelf?: RootSelf,
+): readonly Issue[] {
+  const seen = state.seen;
   const issues: Issue[] = [];
   const verb = options.verb ?? "eval";
   const indices = nodes === undefined ? undefined : new Map<DocVisit, number>();
@@ -681,6 +970,11 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
   const anyName = options.names === "any";
   const roots: readonly string[] = machine.roots ?? ROOTS;
   const has = (table: Readonly<Record<string, unknown>> | undefined, name: string): boolean => table !== undefined && Object.hasOwn(table, name);
+  // The checks of attributes know the self of the code of each document (D106). Only eval reads attributes.
+  const attributes = verb === "eval" && roots.includes("self");
+  const selves = selvesOf(machine, verb, rootSelf?.node);
+  // A document with a node of the decorated tree gets the check of the cycles of its attributes (D107).
+  let trees = false;
   walk(
     machine.world,
     doc,
@@ -703,10 +997,16 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
         return "skip";
       }
       // The equations of a kind are code of the kind. The check walks them at the first document of the kind (D42).
-      if (v.kind?.tree !== undefined && !seen.has(v.kind)) {
+      const node = selves.isNode(v, answer.evaluator);
+      if (v.kind !== undefined && (v.kind.tree !== undefined || node) && !seen.has(v.kind)) {
         seen.add(v.kind);
-        for (const issue of equationIssues(machine, v.kind, typeName(v.doc.type), options, seen)) push({ ...issue, place: v.place, at: v.at });
+        const kindText = typeName(v.doc.type);
+        for (const issue of [...contractIssues(v.kind, kindText), ...equationIssues(machine, v.kind, kindText, options, state)]) push({ ...issue, place: v.place, at: v.at });
       }
+      // The self of the code of this document, and the self that its parts get (D106).
+      const { self, node: here } = selves.enter(v, answer.evaluator);
+      if (here !== undefined) trees = true;
+      if (here?.own !== undefined) for (const issue of nodeIssues(machine, here, state, v)) push(issue);
       const name = answer.evaluator;
       if (current !== undefined) current.evaluator = name;
       // A runner hides the evaluator of its name (MACHINE.RUNNER), as in the compilation of a plan.
@@ -780,6 +1080,11 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
           at: stepAt(1),
         });
       }
+      // 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) });
+      }
       path.forEach((step, index) => {
         if (index === 0 || isKey(step)) return;
         // The resolution finds the walker with the same function, thus the check and a run agree (VERB.LADDER).
@@ -811,5 +1116,7 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
     issues.splice(drive.index, 0, drive.issue);
     if (drive.node !== undefined) drive.node.marked = true;
   }
+  // The cycles of the attributes come after the issues of the walk (TREE.GRAPH-CYCLE). An equation gets none here.
+  if (trees && rootSelf === undefined) for (const issue of cycleIssues(machine, doc, options)) issues.push(issue);
   return issues;
 }