@mark1russell7/coeval 0.6.3 → 0.7.0

package/src/static.ts

@@ -1,10 +1,12 @@
 import { type Envelope, type Json, type Key, isEnvelope, isKey, isRecord, typeName } from "./doc.ts";
-import { type Kind, type NamesSource, type ScopeRule, type World, lookupKind } from "./world.ts";
+import type { Kind, NamesSource, ScopeRule, World } from "./world.ts";
 import { ask } from "./ladder.ts";
 import { type PartSlot, partsOf, pathMatches } from "./parts.ts";
-import { type Cap, type Root, ROOTS, isRef } from "./deref.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 } from "./evaluate.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";
 
 /** One document that a walk visits. */
 export interface DocVisit {
@@ -97,8 +99,16 @@ function namesOf(source: NamesSource, value: unknown, covered: readonly PartSlot
   return covered.map((slot) => headerName(slot.item)).filter((name): name is string => name !== undefined);
 }
 
-/** The names that the scope rules of a kind give each part, and the names that only later parts see. */
-function scopesOf(rules: readonly ScopeRule[] | undefined, value: unknown, slots: readonly PartSlot[]): { readonly sees: readonly (readonly string[])[]; readonly later: readonly (readonly string[])[] } {
+/**
+ * This function gives the names that the scope rules of a kind give each part, and the names that only later parts
+ * see. `check` and `conforms` read the scope rules with it.
+ *
+ * @param rules - The scope rules of the kind.
+ * @param value - The value of the document.
+ * @param slots - The parts of the value, in order.
+ * @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
+ */
+export function scopesOf(rules: readonly ScopeRule[] | undefined, value: unknown, slots: readonly PartSlot[]): { readonly sees: readonly (readonly string[])[]; readonly later: readonly (readonly string[])[] } {
   const sees: string[][] = slots.map(() => []);
   const later: string[][] = slots.map(() => []);
   for (const rule of rules ?? []) {
@@ -162,6 +172,8 @@ function keysOf(trail: Trail | undefined): readonly Key[] {
 class Visit implements DocVisit {
   readonly #place: Trail | undefined;
   readonly #at: Trail | undefined;
+  readonly #bound: readonly string[];
+  readonly #expect: ValueType | undefined;
 
   constructor(
     place: Trail | undefined,
@@ -177,9 +189,23 @@ class Visit implements DocVisit {
     readonly typePath: readonly Key[] | undefined,
     readonly address: true | undefined,
     readonly caps: readonly Cap[] | undefined,
+    bound: readonly string[],
+    expect: ValueType | undefined,
   ) {
     this.#place = place;
     this.#at = at;
+    this.#bound = bound;
+    this.#expect = expect;
+  }
+
+  /** The names that the scope rules of the parent bind for this document. The check of types reads them. */
+  get bound(): readonly string[] {
+    return this.#bound;
+  }
+
+  /** The type that the shape of the parent declares for this part. The check of types reads it. */
+  get expect(): ValueType | undefined {
+    return this.#expect;
   }
 
   get place(): readonly Key[] {
@@ -216,6 +242,8 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
     readonly slot: readonly Key[];
     readonly parent: DocVisit | undefined;
     readonly caps: readonly Cap[] | undefined;
+    readonly bound: readonly string[];
+    readonly expect: ValueType | undefined;
   }
   const stack: Item[] = [
     {
@@ -230,6 +258,8 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
       slot: [],
       parent: undefined,
       caps: options.caps,
+      bound: [],
+      expect: undefined,
     },
   ];
   while (stack.length > 0) {
@@ -254,6 +284,8 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
       read.typePath,
       item.address ? true : undefined,
       item.caps,
+      item.bound,
+      item.expect,
     );
     const answer = visit(here);
     if (answer === "skip" || kind === undefined) continue;
@@ -279,6 +311,8 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
         slot: slot.path,
         parent: here,
         caps: item.caps === undefined || kind.caps === undefined ? item.caps : partCaps(kind.caps, slot.path, item.caps),
+        bound: extra,
+        expect: slot.expect,
       });
     }
   }
@@ -380,6 +414,10 @@ export interface Issue {
   readonly reason: string;
   /** The keys from the root JSON value to the value with the problem. */
   readonly at?: readonly Key[];
+  /** The type that the position needs, for a type issue (`#TYPE!`). */
+  readonly expected?: ValueType;
+  /** The type that the check found, for a type issue (`#TYPE!`). */
+  readonly found?: ValueType;
 }
 
 /** The options of a check. */
@@ -393,16 +431,89 @@ export interface CheckOptions {
    * each part by the capability rules of the kinds, as a run does.
    */
   readonly caps?: readonly Cap[];
+  /**
+   * The verb that goes up the ladder at each document, as in `prepare`. The default is `eval`. `#NOEVAL` and the hook
+   * `known` follow this verb. The contract declares the effects and the value types of `eval` only, thus only `eval`
+   * checks them (VERB.CHECK). The type rule of an evaluator serves each verb.
+   */
+  readonly verb?: string;
+  /**
+   * With `true`, the check also checks the value types (TYPE.CHECK). It reads the type rules of the evaluators, the
+   * signatures of the operations and the value types of the contracts. A type issue has the code `#TYPE!`. The
+   * default is `false`, thus a host opts in.
+   */
+  readonly types?: boolean;
+  /** The type that the root document must have, for the check of the value types. */
+  readonly expect?: ValueType;
+  /**
+   * With `true`, the check also finds the problems of a run (RUN.CAN-WAIT). A runner under a parent without a runner
+   * gives `#CALC!` when an effect of its runners can reach the host. The parent cannot pass that wait through.
+   * A runner without such an effect does not wait, and the run drives it (RUN.DRIVE-NESTED). A kind that declares
+   * effects and has no runner gives `#CALC!` too, because in a run only a runner can wait for the host. The default is
+   * `false`.
+   */
+  readonly run?: boolean;
+  /**
+   * The value types of the roots and of the names of the host, for the check of the value types (TYPE.ROOTS). A
+   * reference then gets the type that its path reaches. Only a check with `types: true` reads them.
+   */
+  readonly rootTypes?: RootTypes;
+}
+
+/** The result of `typeCheck`. */
+export interface Typing {
+  /** The type of the root document. It is `unknown` when the root has an issue. */
+  readonly type: ValueType;
+  /** Each issue of the check. The type issues come after the other issues. */
+  readonly issues: readonly Issue[];
+  /** The type of each document, in the order of the document. */
+  readonly places: readonly Typed[];
+}
+
+/** The least authority: the capability `[]` permits each effect (CAP.KEYS). */
+const EACH: readonly Cap[] = /* @__PURE__ */ Object.freeze([[]]);
+
+/** No declared effect. One list serves each visit without effects. */
+const NO_EFFECTS: readonly (readonly Key[])[] = /* @__PURE__ */ Object.freeze([]);
+
+/**
+ * This function gives the effects that the contract of the kind of a visit declares, as keys (FACTS.EFFECTS). The
+ * text `"type"` gives the type of the document after each alias. A visit without a kind declares no effect. `check`,
+ * `factsOf` and `effectsOf` read the declarations with this one function (D27).
+ *
+ * @param v - The visit.
+ * @returns The keys of each declared effect, in the order of the contract.
+ */
+export function declaredEffects(v: DocVisit): readonly (readonly Key[])[] {
+  const effects = v.kind?.effects;
+  if (effects === undefined || effects.length === 0) return NO_EFFECTS;
+  return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
+}
+
+/**
+ * This function gives the rule of a machine for an effect, for the static kit (CAP.PERMITS). The rule is the hook
+ * `permits` of the machine, as in a run, or else the function `permits`. A check has no values, thus the hook gets a
+ * context with the capabilities of the document and the world of the machine. Its names, its self and its event are
+ * empty.
+ *
+ * @param machine - The machine.
+ * @returns The rule. It gets the capabilities of a document and the keys of an effect.
+ */
+export function permitsOf(machine: Machine): (caps: readonly Cap[], kind: readonly Key[]) => boolean {
+  const hook = machine.permits;
+  if (hook === undefined) return permits;
+  let base: Context | undefined;
+  return (caps, kind) => hook(caps, kind, { ...(base ??= context({ world: worldThing(machine.world) })), caps });
 }
 
 /**
  * This function gives the reason of a `#CAP!`. When a kind around the document narrowed the capabilities, the
  * reason names the nearest such kind.
  */
-function capReason(v: DocVisit, kind: readonly Key[]): string {
+function capReason(v: DocVisit, kind: readonly Key[], allowed: (caps: readonly Cap[], kind: readonly Key[]) => boolean): string {
   const text = kind.join(".");
   for (let up = v.parent; up !== undefined; up = up.parent) {
-    if (up.caps !== undefined && permits(up.caps, kind)) {
+    if (up.caps !== undefined && allowed(up.caps, kind)) {
       return `The capabilities do not permit the effect ${text} here. The kind ${typeName(up.doc.type)} around it narrows them for its parts.`;
     }
   }
@@ -422,14 +533,91 @@ function capReason(v: DocVisit, kind: readonly Key[]): string {
  * - `#NAME?`: a name that nothing binds. With the hook `known` of the machine, also a name that the language does not
  *   have, for example an operation.
  * - `#CAP!`: an effect that the capabilities of its document do not permit. A kind around the document can narrow them.
+ *   The hook `permits` of the machine decides, as in a run (CAP.PERMITS).
+ * - `#CALC!`: with the option `run`, a runner under a parent without a runner, when an effect of its runners can reach
+ *   the host. Also a kind that declares effects and has no runner (RUN.CAN-WAIT). The issue has the place and the
+ *   reason of the run.
+ * - `#TYPE!`: with the option `types`, a part whose type does not fit the type that its position needs (TYPE.CHECK).
+ *   A run does not always fail there, thus a type issue is a static finding, not an error of a run.
+ *
+ * The check asks the ladder for the verb of the options, `eval` by default (VERB.CHECK). The shapes, the paths and the
+ * names follow the contracts, thus they are the same for each verb. Only `eval` checks the declared effects.
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document, as JSON.
- * @param options - The type of a bare root value, the names of the host and the capabilities.
- * @returns The problems, in the order of the document.
+ * @param options - The type of a bare root value, the names of the host, the capabilities, the verb, the types and the run.
+ * @returns The problems, in the order of the document. The type issues come after the other issues.
  */
 export function check(machine: Machine, doc: unknown, options: CheckOptions = {}): readonly Issue[] {
+  return options.types === true ? typeCheck(machine, doc, options).issues : checkAll(machine, doc, options, undefined);
+}
+
+/**
+ * This function checks a document, and it also checks the value types (TYPE.CHECK, D25). It finds each issue of
+ * `check`. Then it synthesizes the type of each document from the types of its parts. It also checks each part
+ * against the type that its position needs. The type rule of the parent, the signature of an operation or the shape
+ * of the contract gives that type. A part with an issue gets the type `unknown`, thus one
+ * problem does not give a chain of issues.
+ *
+ * A type issue has the code `#TYPE!`, the type that the position needs (`expected`) and the type that the check found
+ * (`found`). It is a static finding: the evaluation of the document does not change.
+ *
+ * The option `rootTypes` gives the types of the roots and of the names of the host (TYPE.ROOTS). A reference then gets
+ * the type that its path reaches, and a field that a closed record does not have is a type issue (TYPE.CLOSED).
+ *
+ * @param machine - The world and the code of the evaluators, with their type rules.
+ * @param doc - The document, as JSON.
+ * @param options - The options of `check`, the type that the root must have and the types of the roots.
+ * @returns The type of the root, each issue, and the type of each document.
+ */
+export function typeCheck(machine: Machine, doc: unknown, options: CheckOptions = {}): Typing {
+  const nodes: TypeNode[] = [];
+  const issues = checkAll(machine, doc, options, nodes);
+  const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
+  return { type: pass.type, issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues], places: pass.places };
+}
+
+/**
+ * A runner under an evaluator in a check of a run. The run drives its steps without a wait, thus only a wait for an
+ * effect of its runners fails (RUN.DRIVE-NESTED).
+ */
+interface Drive {
+  /** The issue of the run when a step waits. */
+  readonly issue: Issue;
+  /** The index of the issue in the order of the document. */
+  readonly index: number;
+  /** The node of the runner for the pass of types. */
+  readonly node: TypeNode | undefined;
+  /** `true` when an effect of its runners can reach the host, and thus wait. */
+  wait: boolean;
+}
+
+/** What the code of a document does with a wait: an evaluator stops it, and a runner passes it on. */
+type Waits = boolean | Drive;
+
+/**
+ * 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.
+ */
+function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes: TypeNode[] | undefined): readonly Issue[] {
   const issues: Issue[] = [];
+  const verb = options.verb ?? "eval";
+  const indices = nodes === undefined ? undefined : new Map<DocVisit, number>();
+  let current: TypeNode | undefined;
+  const push = (issue: Issue): void => {
+    issues.push(issue);
+    if (current !== undefined) current.marked = true;
+  };
+  // The effects of a contract are the effects of eval (VERB.CONTRACT). An effect of another verb meets its test when
+  // it happens (RUN.CAP).
+  const effects = verb === "eval";
+  const allowed = options.caps === undefined ? undefined : permitsOf(machine);
+  // In a run, a part that can wait needs a parent that can wait (RUN.CAN-WAIT). The map tells for each document with
+  // code if its code passes a wait on: false for an evaluator, true for a runner whose waits reach the driver of the
+  // run, and a drive for a runner under an evaluator. A document without code fails before its parts, thus it is not
+  // in the map.
+  const waits = options.run === true ? new Map<DocVisit, Waits>() : undefined;
+  const drives: Drive[] = [];
   const maxDepth = machine.maxDepth ?? 1000;
   const anyName = options.names === "any";
   const roots: readonly string[] = machine.roots ?? ROOTS;
@@ -438,34 +626,70 @@ export function check(machine: Machine, doc: unknown, options: CheckOptions = {}
     machine.world,
     doc,
     (v) => {
+      if (nodes !== undefined && indices !== undefined) {
+        current = { visit: v, bound: v instanceof Visit ? v.bound : [], expect: v instanceof Visit ? v.expect : undefined, children: [], evaluator: undefined, marked: false };
+        const parent = v.parent === undefined ? undefined : indices.get(v.parent);
+        if (parent !== undefined) nodes[parent]?.children.push(nodes.length);
+        indices.set(v, nodes.length);
+        nodes.push(current);
+      }
       if (v.depth > maxDepth) {
-        issues.push({ code: "#DEPTH!", place: v.place, reason: `The nesting is deeper than ${maxDepth} documents.`, at: v.at });
+        push({ code: "#DEPTH!", place: v.place, reason: `The nesting is deeper than ${maxDepth} documents.`, at: v.at });
         return "skip";
       }
       const header = v.declared ? {} : v.doc;
-      const answer = ask(machine.world, header, "eval", v.declared ? { declaredType: typeName(v.doc.type) } : {});
+      const answer = ask(machine.world, header, verb, v.declared ? { declaredType: typeName(v.doc.type) } : {});
       if (answer.error === "unknown-kind") {
-        issues.push({ code: "#KIND?", place: v.place, reason: `The world has no kind ${typeName(v.doc.type)}.`, at: v.at });
+        push({ code: "#KIND?", place: v.place, reason: `The world has no kind ${typeName(v.doc.type)}.`, at: v.at });
         return "skip";
       }
       const name = answer.evaluator;
-      if (name === undefined || (!has(machine.evaluators, name) && !has(machine.runners, name))) {
-        issues.push({ code: "#NOEVAL", place: v.place, reason: `No rung gives an evaluator for ${typeName(v.doc.type)}.`, at: v.at });
+      if (current !== undefined) current.evaluator = name;
+      // A runner hides the evaluator of its name (MACHINE.RUNNER), as in the compilation of a plan.
+      const runner = name !== undefined && has(machine.runners, name);
+      const coded = name !== undefined && (runner || has(machine.evaluators, name));
+      if (name === undefined || !coded) {
+        push({ code: "#NOEVAL", place: v.place, reason: `No rung gives an evaluator for ${typeName(v.doc.type)}.`, at: v.at });
       } else if (machine.known !== undefined) {
         // The evaluator gives #NAME? in a run for a name that the language does not have, for example an operation.
         const known = machine.known(v.typePath ?? [], name);
-        if (known !== true) issues.push({ code: "#NAME?", place: v.place, reason: known, at: v.at });
+        if (known !== true) push({ code: "#NAME?", place: v.place, reason: known, at: v.at });
       }
       const caps = v.caps;
-      if (caps !== undefined && v.kind?.effects !== undefined) {
-        const kinds: readonly (readonly Key[])[] = v.kind.effects === "type" ? [v.typePath ?? []] : v.kind.effects.map((kind) => kind.split("."));
-        for (const kind of kinds) {
-          if (!permits(caps, kind)) issues.push({ code: "#CAP!", place: v.place, reason: capReason(v, kind), at: v.at });
+      const declared = effects ? declaredEffects(v) : NO_EFFECTS;
+      if (allowed !== undefined && caps !== undefined) {
+        for (const kind of declared) {
+          if (!allowed(caps, kind)) push({ code: "#CAP!", place: v.place, reason: capReason(v, kind, allowed), at: v.at });
+        }
+      }
+      if (waits !== undefined && coded) {
+        // The parent of the root is the driver of the run, and it can wait. An evaluator gives its parts no wait.
+        const up = v.parent === undefined ? true : waits.get(v.parent);
+        let chain: Waits = false;
+        if (runner && up === false) {
+          // The run drives a runner under an evaluator, and only a real wait fails (RUN.DRIVE-NESTED). Its issue goes in
+          // here, in the order of the document, when an effect of its runners can wait.
+          const issue: Issue = { code: "#CALC!", place: v.place, reason: waitedReason(typeName(v.doc.type)), at: v.at };
+          chain = { issue, index: issues.length, node: current, wait: !effects };
+          drives.push(chain);
+        } else if (runner) {
+          chain = up ?? true;
+        }
+        waits.set(v, chain);
+        // A runner waits only for an effect that reaches the host (C6). A refused effect gives #CAP! without a wait.
+        if (typeof chain === "object" && !chain.wait) {
+          const rule = allowed ?? permits;
+          chain.wait = declared.some((kind) => caps === undefined || rule(caps, kind));
+        }
+        // In a run, the host does each effect, thus an evaluator cannot cause one.
+        const first = declared[0];
+        if (!runner && first !== undefined) {
+          push({ code: "#CALC!", place: v.place, reason: `The effect ${first.join(".")} needs a runner: in a run, the host does each effect.`, at: v.at });
         }
       }
       const isPath = isRef(v.doc);
       if (!isPath && v.typePath?.length === 1 && v.typePath[0] === "ref") {
-        issues.push({ code: "#VALUE!", place: v.place, reason: "The value of ref is a path: a list that starts with a root.", at: [...v.at, ...(v.declared ? [] : ["value"])] });
+        push({ code: "#VALUE!", place: v.place, reason: "The value of ref is a path: a list that starts with a root.", at: [...v.at, ...(v.declared ? [] : ["value"])] });
       }
       if (!isPath) return undefined;
       const path = v.doc.value as readonly Json[];
@@ -473,17 +697,17 @@ export function check(machine: Machine, doc: unknown, options: CheckOptions = {}
       // The JSON path of a problem of a path goes to its step.
       const stepAt = (index: number): readonly Key[] => [...v.at, "value", ...(index < path.length ? [index] : [])];
       if (typeof root !== "string" || !(ROOTS as readonly string[]).includes(root)) {
-        issues.push({ code: "#REF!", place: v.place, reason: `A path starts with a root: ${ROOTS.join(", ")}.`, at: stepAt(0) });
+        push({ code: "#REF!", place: v.place, reason: `A path starts with a root: ${ROOTS.join(", ")}.`, at: stepAt(0) });
         // The step documents of the path are parts, and they evaluate before the path, thus the walk visits them.
         return undefined;
       }
       if (!roots.includes(root)) {
-        issues.push({ code: "#REF!", place: v.place, reason: `The root ${root} is not open here. The open roots are ${roots.join(", ")}.`, at: stepAt(0) });
+        push({ code: "#REF!", place: v.place, reason: `The root ${root} is not open here. The open roots are ${roots.join(", ")}.`, at: stepAt(0) });
       }
       const first = path[1];
       if (root === ("names" as Root) && !anyName && isKey(first) && !v.names.has(String(first))) {
         const later = v.later.has(String(first));
-        issues.push({
+        push({
           code: "#NAME?",
           place: v.place,
           reason: later ? `The name ${String(first)} is bound by a later step.` : `Nothing binds the name ${String(first)}.`,
@@ -492,10 +716,9 @@ export function check(machine: Machine, doc: unknown, options: CheckOptions = {}
       }
       path.forEach((step, index) => {
         if (index === 0 || isKey(step)) return;
-        const found = isEnvelope(step) ? lookupKind(machine.world, step.type) : undefined;
-        const walker = found?.ok === true && Object.hasOwn(found.kind.verbs, "step") ? found.kind.verbs["step"] : undefined;
-        if (walker === undefined || !has(machine.walkers, walker)) {
-          issues.push({ code: "#STEP?", place: v.place, reason: "A step is a key, or a document of a kind with the verb step.", at: stepAt(index) });
+        // The resolution finds the walker with the same function, thus the check and a run agree (VERB.LADDER).
+        if (walkerOf(machine, step) === undefined) {
+          push({ code: "#STEP?", place: v.place, reason: "A step is a key, or a document of a kind with the verb step.", at: stepAt(index) });
         }
       });
       // The step documents of the path are parts when the kind ref has a deep shape. The walk checks them too.
@@ -504,9 +727,23 @@ export function check(machine: Machine, doc: unknown, options: CheckOptions = {}
     {
       ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }),
       ...(Array.isArray(options.names) ? { names: options.names } : {}),
-      ...(options.caps === undefined ? {} : { caps: options.caps }),
-      problem: (problem) => issues.push({ code: problem.code, place: problem.place, reason: problem.reason, at: problem.at }),
+      // Without capabilities, a check of the run narrows the least authority, as effectsOf does. Thus a mask of a kind
+      // removes the effects that cannot wait. The check of the capabilities stays off.
+      ...(options.caps === undefined ? (waits === undefined ? {} : { caps: EACH }) : { caps: options.caps }),
+      problem: (problem) => {
+        issues.push({ code: problem.code, place: problem.place, reason: problem.reason, at: problem.at });
+        // A value without the shape of its kind is a problem of the document that the walk visited last. A part that is
+        // not a document has no visit, thus it marks nothing.
+        if (problem.code === "#VALUE!" && current !== undefined) current.marked = true;
+      },
     },
   );
+  // The issue of each drive that can wait goes in at its place. The last drive goes in first, thus each index stays.
+  for (let index = drives.length - 1; index >= 0; index -= 1) {
+    const drive = drives[index] as Drive;
+    if (!drive.wait) continue;
+    issues.splice(drive.index, 0, drive.issue);
+    if (drive.node !== undefined) drive.node.marked = true;
+  }
   return issues;
 }

package/src/stdlib.ts

@@ -3,6 +3,7 @@ import { type Context, type EvalInput, type Evaluator, type Machine, type Part,
 import { Failure } from "./errors.ts";
 import { type HostThing, type Thing, type Walker, THING, isHostThing, valueOfThing } from "./deref.ts";
 import type { World } from "./ladder.ts";
+import { STD_DOMAINS } from "./types.ts";
 
 /**
  * The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
@@ -10,36 +11,43 @@ import type { World } from "./ladder.ts";
  */
 export const STD_WORLD: World = {
   kinds: {
-    number: { verbs: { eval: "data.number", view: "view.value" }, summary: "A number. Its value is the result." },
-    text: { verbs: { eval: "data.text", view: "view.value" }, summary: "A text. Its value is the result." },
-    bool: { verbs: { eval: "data.bool", view: "view.value" }, summary: "A truth value. Its value is the result." },
+    number: { verbs: { eval: "data.number", view: "view.value" }, pure: true, summary: "A number. Its value is the result." },
+    text: { verbs: { eval: "data.text", view: "view.value" }, pure: true, summary: "A text. Its value is the result." },
+    bool: { verbs: { eval: "data.bool", view: "view.value" }, pure: true, summary: "A truth value. Its value is the result." },
     add: {
       verbs: { eval: "math.add", view: "view.op" },
       parts: { shape: "list", of: "number" },
+      pure: true,
       summary: "The sum of its parts. A bare number in its list gets the type number.",
     },
     multiply: {
       verbs: { eval: "math.multiply", view: "view.op" },
       parts: { shape: "list", of: "number" },
+      pure: true,
       summary: "The product of its parts.",
     },
     greater: {
       verbs: { eval: "math.greater", view: "view.op" },
       parts: { shape: "list", of: "number" },
+      pure: true,
       summary: "True when the first part is greater than the second part.",
     },
-    list: { verbs: { eval: "list.all", view: "view.op" }, parts: { shape: "list" }, summary: "The results of its parts, as a list." },
+    list: { verbs: { eval: "list.all", view: "view.op" }, parts: { shape: "list" }, pure: true, summary: "The results of its parts, as a list." },
     if: {
       verbs: { eval: "control.if", view: "view.op" },
       parts: { shape: "record", fields: ["test", "then", "else"] },
+      pure: true,
+      lazy: [{ in: [["then"], ["else"]] }],
       summary: "It evaluates the test, then only the branch that the test selects.",
     },
     ref: {
       verbs: { eval: "ref.resolve", view: "view.ref" },
+      pure: true,
       summary: "A path from a root of the context. Each step goes up the ladder of the verb deref.",
     },
     nearest: {
       verbs: { step: "walk.nearest", view: "view.card" },
+      pure: true,
       summary: "A step of a path: it follows a key again and again, until it reaches a node of a type.",
     },
     panel: {
@@ -47,12 +55,17 @@ export const STD_WORLD: World = {
       parts: { shape: "record", fields: ["width", "height", "children"], of: "number" },
       // An attribute evaluates on demand, thus in an order that is not the order of the document. It causes no effect.
       caps: [{ rule: "mask" }],
+      // A node that nothing reads keeps its attributes without an evaluation (TREE.LAZY).
+      pure: true,
+      lazy: [{}],
       summary: "A node of a tree. Each part is an attribute that evaluates on demand, one time, with the node as self.",
     },
     box: {
       verbs: { eval: "tree.node", view: "view.op" },
       parts: { shape: "record", fields: ["width", "height", "children"], of: "number" },
       caps: [{ rule: "mask" }],
+      pure: true,
+      lazy: [{}],
       summary: "A node of a tree, as panel. A formula in a box can read its parent and its siblings.",
     },
     math: {
@@ -68,12 +81,16 @@ export const STD_WORLD: World = {
         { names: { headers: true }, in: [["*"]], sequential: true },
         { names: { fixed: ["last"] }, in: [["*"]], sequential: true },
       ],
+      pure: true,
       summary: "Its steps, in order. The result of a named step is a name for the later steps.",
     },
     pure: {
       verbs: { eval: "control.pure", view: "view.op" },
       parts: { shape: "list" },
       caps: [{ rule: "mask" }],
+      // The runner evaluates only the first part.
+      pure: true,
+      lazy: [{ after: 1 }],
       summary: "It evaluates its part without capabilities, thus an effect in it fails.",
     },
     log: {
@@ -432,7 +449,7 @@ export const STD_RUNNERS: Readonly<Record<string, Runner>> = {
   // The contract of pure masks the capabilities of its part, and the kernel applies it. Thus the runner does not.
   "control.pure": function* ({ parts }) {
     const only = parts[0];
-    if (only === undefined) return fail("#VALUE!", "pure needs one part.");
+    if (only === undefined || parts.length > 1) return fail("#VALUE!", "pure needs exactly one part.");
     return yield* only.evaluate();
   },
   "control.if": function* ({ parts }) {
@@ -464,8 +481,8 @@ export const STD_RUNNERS: Readonly<Record<string, Runner>> = {
   },
 };
 
-/** The machine of the examples: the standard world, its evaluators, its runners and its walkers. */
-export const STD_MACHINE: Machine = { world: STD_WORLD, evaluators: STD_EVALUATORS, runners: STD_RUNNERS, walkers: STD_WALKERS };
+/** The machine of the examples: the standard world, its evaluators, its runners, its walkers and the domains of the kernel. */
+export const STD_MACHINE: Machine = { world: STD_WORLD, evaluators: STD_EVALUATORS, runners: STD_RUNNERS, walkers: STD_WALKERS, domains: STD_DOMAINS };
 
 /** The capabilities of the examples at the root: the two effects of the standard world. */
 export const STD_CAPS: readonly string[] = ["log", "write"];