@mark1russell7/coeval 0.17.0 → 0.19.0

package/src/stdlib.ts

@@ -236,7 +236,7 @@ export const STD_EVALUATORS: Readonly<Record<string, Evaluator>> = {
     const found = resolve(data as readonly Json[]);
     return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
   },
-  "tree.node": (input) => treeNode(input),
+  "tree.node": (input) => treeNode(input, undefined),
 };
 
 /*
@@ -316,6 +316,57 @@ interface NodeState {
   json(path: Set<object>): Result;
 }
 
+/** The answer of the ladder for one attribute of one node (TREE.CELL, D108). */
+export interface AttributeAnswer {
+  /** The result of the attribute. It is `undefined` when no rung answered. */
+  readonly result: Result | undefined;
+  /** The rung that answered. It is `undefined` when no rung answered. */
+  readonly by: AttributeRung | undefined;
+}
+
+/**
+ * This function gives the memo cell of one attribute of one node, for a host that keeps its cells between evaluations
+ * (TREE.CELL, D108). The kit uses it at each demand of an attribute in an evaluation.
+ *
+ * The array `place` is one object for each document of a plan, and it stays the same across the evaluations of that
+ * plan. A new plan gives new arrays. Thus a host keeps its cells by the identity of `place` and by `attribute`.
+ * A host that keeps its cells by the keys of `place` can give a stale answer after a change of the document.
+ *
+ * The function gives the answer of `compute`, or a kept answer. A host with signals gives a computed signal: a change
+ * of its store then makes only the attributes that read the store compute again. Each demand gives a new `compute`, and
+ * a cell that computes again uses the last one.
+ *
+ * The kit marks an attribute in evaluation before it uses the cell. Thus a cycle gives `#CYCLE!` before it reaches the
+ * cell again. An exception of the function that `compute` did not throw gives `#CYCLE!` with the chain of the demands.
+ *
+ * @param place - The keys from the root document to the document of the node.
+ * @param attribute - The name of the attribute.
+ * @param compute - The function that visits the rungs of the ladder.
+ * @returns The answer.
+ */
+export type AttributeCell = (place: readonly Key[], attribute: string, compute: () => AttributeAnswer) => AttributeAnswer;
+
+/** The options of the tree kit (D108). */
+export interface TreeOptions {
+  /**
+   * The memo cells of the host (TREE.CELL). The default is a plain memo for each node and attribute, for one
+   * evaluation (TREE.MEMO).
+   */
+  readonly cell?: AttributeCell;
+}
+
+/**
+ * This function gives the code of the kind of a node of the decorated tree, with the options of the host. A host puts
+ * the code at the name `tree.node` of its machine. Without a cell, the code is the standard code.
+ *
+ * @param options - The options, for example the memo cells of the host.
+ * @returns The code.
+ */
+export function treeNodeEvaluator(options: TreeOptions = {}): Evaluator {
+  const host = options.cell;
+  return host === undefined ? (STD_EVALUATORS["tree.node"] as Evaluator) : (input: EvalInput) => treeNode(input, host);
+}
+
 /**
  * The memo cell of one attribute: in evaluation, or done with its result and the rung that answered. A done cell
  * without a result tells that no rung answered.
@@ -373,6 +424,31 @@ function contractOf(machine: Machine | undefined, typePath: readonly Key[]): Nod
 
 const BUSY: Cell = /* @__PURE__ */ Object.freeze({ busy: true });
 
+/** The answer of the ladder when no rung answers. */
+const NO_ANSWER: AttributeAnswer = /* @__PURE__ */ Object.freeze({ result: undefined, by: undefined });
+
+/**
+ * The marks of the attributes in evaluation, for each place of a plan, with the cells of a host (TREE.CELL). Nodes of
+ * two evaluations share their place and their kept cells, thus they share their marks.
+ */
+const marksByPlace = /* @__PURE__ */ new WeakMap<readonly Key[], Map<string, Cell>>();
+
+/** The trees of the cells of a host, for each place of a root in a plan. Nodes of two evaluations stay in one tree. */
+const buildsByPlace = /* @__PURE__ */ new WeakMap<readonly Key[], TreeBuild>();
+
+/** This function gives the value of a weak map, or puts a new value in it. */
+function keptAt<T>(map: WeakMap<readonly Key[], T>, place: readonly Key[], make: () => T): T {
+  let value = map.get(place);
+  if (value === undefined) {
+    value = make();
+    map.set(place, value);
+  }
+  return value;
+}
+
+/** A value that no exception has. */
+const NOT_THROWN: unique symbol = /* @__PURE__ */ Symbol("coeval.tree.not-thrown") as never;
+
 /** One attribute in evaluation. The text names it in the reason of a cycle. */
 interface Demand {
   readonly cells: Map<string, Cell>;
@@ -451,8 +527,10 @@ function plainOf(value: unknown, path: Set<object>): Result {
  * the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
  * fold or a default, come last. A failed attribute throws `Failure` with its own error, thus a reference to it gives that error.
  * The argument `outer` is the self of the context, that `treeNode` resolved. The node reads no root of the context directly (C4).
+ *
+ * The argument `host` gives the memo cells of the host (TREE.CELL), or `undefined` for the plain memo of the node.
  */
-function treeThing(input: EvalInput, build: TreeBuild, outer: Thing | undefined): HostThing {
+function treeThing(input: EvalInput, build: TreeBuild, outer: Thing | undefined, host: AttributeCell | undefined): HostThing {
   const { parts, context, kind: type, place, machine } = input;
   // The equations evaluate in the evaluation that made the node, thus their reads go in its list (READS.EQUATION).
   const runtime = (input as InputWithRuntime)[RUNTIME];
@@ -461,6 +539,8 @@ function treeThing(input: EvalInput, build: TreeBuild, outer: Thing | undefined)
   // Only a node of the same tree is a parent for the rungs `parent` and `copy`.
   const up = above !== undefined && above.build === build ? above : undefined;
   const cells = new Map<string, Cell>();
+  // With the cells of a host, the marks of a place serve each node of the place (TREE.CELL).
+  const marks = host === undefined ? cells : keptAt(marksByPlace, place, () => new Map<string, Cell>());
   /** The positions of the items of the list `children`, for the names of the children. */
   let positions: { readonly list: readonly unknown[]; readonly at: Map<unknown, number> } | undefined;
 
@@ -505,7 +585,45 @@ function treeThing(input: EvalInput, build: TreeBuild, outer: Thing | undefined)
     return undefined;
   };
 
+  /**
+   * This function gives an attribute through the cell of the host (TREE.CELL). The cell is the memo. The node keeps
+   * the last answer only for `has` and `trace`.
+   */
+  const through =
+    host === undefined
+      ? undefined
+      : (key: string): Result | undefined => {
+          const text = attributeText(key, type, place);
+          if (marks.has(key)) return cycleAt(marks, key, text);
+          if (tree === undefined && up?.tree === undefined && !parts.some((item) => item.key === key)) return undefined;
+          marks.set(key, BUSY);
+          demands.push({ cells: marks, key, text });
+          let thrown: unknown = NOT_THROWN;
+          let answer: AttributeAnswer;
+          try {
+            answer = host(place, key, () => {
+              try {
+                return climb(key) ?? NO_ANSWER;
+              } catch (error) {
+                thrown = error;
+                throw error;
+              }
+            });
+          } catch (error) {
+            // An exception of the kit or of the stack goes on, as without a host. Another exception is a cycle of the host.
+            if (error === thrown) throw error;
+            const chain = demands.map((demand) => demand.text).join(" -> ");
+            answer = { result: fail("#CYCLE!", `The cells of the host found a cycle in the demands: ${chain}.`, { cause: error }), by: undefined };
+          } finally {
+            demands.pop();
+            marks.delete(key);
+          }
+          cells.set(key, { busy: false, result: answer.result, by: answer.by });
+          return answer.result;
+        };
+
   const read = (key: string): Result | undefined => {
+    if (through !== undefined) return through(key);
     const cell = cells.get(key);
     if (cell !== undefined) return cell.busy ? cycleAt(cells, key, attributeText(key, type, place)) : cell.result;
     // A node without a contract has only its parts, as before D42. Thus a missing part needs no cell.
@@ -635,14 +753,17 @@ const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
  * This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
  * thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree. The
  * node reads `self` through `resolve` (C4, D44). A machine that closes the root `self` thus gives no nested trees.
+ * The argument `host` gives the memo cells of the host (TREE.CELL), or `undefined` for the plain memo of each node.
  */
-function treeNode(input: EvalInput): Result {
+function treeNode(input: EvalInput, host: AttributeCell | undefined): Result {
   const found = input.resolve(SELF_PATH, NO_HOPS);
   const outer = found.ok ? found.thing : undefined;
   const above = stateOf(outer);
-  if (above !== undefined && above.build.open) return ok(treeThing(input, above.build, outer));
-  const build: TreeBuild = { open: true };
-  const root = treeThing(input, build, outer);
+  if (above !== undefined && above.build.open) return ok(treeThing(input, above.build, outer, host));
+  // With the cells of a host, a kept value can hold a node of an earlier evaluation. Thus that node stays in the tree.
+  const build: TreeBuild = host === undefined ? { open: true } : keptAt(buildsByPlace, input.place, () => ({ open: true }));
+  build.open = true;
+  const root = treeThing(input, build, outer, host);
   try {
     return (stateOf(root) as NodeState).json(new Set());
   } finally {

package/src/types.ts

@@ -66,6 +66,12 @@ export interface Domain {
    * domain does not count. The check reads a list of at most 64 values.
    */
   readonly values?: readonly unknown[];
+  /**
+   * Some members of the domain for the tests of `conforms`, for example `0` and `-1` of `number` (D99). The checks
+   * `truth` and `cover` add the samples of each domain to the palette. A sample that fails a test of a type does not
+   * count. The list is not a full list of the members, thus `fits` does not read it.
+   */
+  readonly samples?: readonly unknown[];
   /**
    * The covers of the domain (TYPE.FITS-COVER, D85). A cover is a list of domains under this domain, and its domains
    * together hold each member of this domain. An example is a domain of negative numbers and a domain of the other
@@ -73,7 +79,7 @@ export interface Domain {
    *
    * A split of a record also narrows a field of the domain to each domain of a cover (D90).
    * The language keeps each cover true, and `fits` trusts it, as it trusts `values`. A cover that is empty, or that
-   * names this domain or a name that is not under it, does not count.
+   * names this domain or a name that is not under it, does not count. `conforms` tests each cover from samples (D94).
    */
   readonly covers?: readonly (readonly string[])[];
 }
@@ -115,7 +121,7 @@ export const STD_DOMAINS: Readonly<Record<string, Domain>> = {
   // JSON has no undefined, thus a document holds it as ext.undefined (D48). The domain has no codec: the codec of values writes undefined first.
   undefined: { is: (value) => value === undefined, values: [undefined], summary: "The value undefined. A document holds it as the extension ext.undefined." },
   bool: { is: (value) => typeof value === "boolean", values: [true, false], summary: "A truth value: true or false." },
-  number: { is: (value) => typeof value === "number", summary: "A number of the host, also NaN, an infinity and -0." },
+  number: { is: (value) => typeof value === "number", samples: [0, -1], summary: "A number of the host, also NaN, an infinity and -0." },
   text: { is: (value) => typeof value === "string", summary: "A text." },
 };
 
@@ -199,8 +205,12 @@ function formOf(type: unknown, domains: Readonly<Record<string, Domain>> | undef
   return { t: "record", fields: fields as Readonly<Record<string, ValueType>>, optional: new Set(names), closed };
 }
 
-/** This function gives each base type that holds the members of a base type: the type itself and each parent, through each level. */
-function lineOf(name: string, domains: Readonly<Record<string, Domain>> | undefined): ReadonlySet<string> {
+/**
+ * This function gives each base type that holds the members of a base type: the type itself and each parent, through
+ * each level. A cycle of parents ends at a name that the line has, and a parent that is not a domain ends its branch.
+ * The function is internal: `encodeValue` uses it too (D109).
+ */
+export function lineOf(name: string, domains: Readonly<Record<string, Domain>> | undefined): ReadonlySet<string> {
   const seen = new Set<string>([name]);
   const queue = [name];
   while (queue.length > 0) {
@@ -421,7 +431,8 @@ function membersAt(type: unknown, domains: Readonly<Record<string, Domain>> | un
 /**
  * This function gives members of a type for a test of a declaration (D86). A type with at most 64 members gives each
  * member, from the lists `values` of its domains (TYPE.FITS-FINITE). A union gives the members of each of its types.
- * Each other type gives the samples that are its members. The kernel does not export the function.
+ * Each other type gives the samples that are its members. The samples of the domains come after the given samples (D99).
+ * The kernel does not export the function.
  *
  * @param type - The type.
  * @param domains - The domains of the machine.
@@ -429,7 +440,61 @@ function membersAt(type: unknown, domains: Readonly<Record<string, Domain>> | un
  * @returns Distinct members of the type.
  */
 export function membersOf(type: ValueType, domains: Readonly<Record<string, Domain>> | undefined, samples: readonly unknown[]): readonly unknown[] {
-  return membersAt(type, domains, samples, 0);
+  return membersAt(type, domains, withDomainSamples(samples, domains), 0);
+}
+
+/**
+ * This function adds the samples of the domains to a palette (D99). It reads the list `samples` of each domain of the
+ * table and of each standard domain that the table does not replace. The result holds each value one time.
+ */
+function withDomainSamples(palette: readonly unknown[], domains: Readonly<Record<string, Domain>> | undefined): readonly unknown[] {
+  const out: unknown[] = [];
+  for (const value of palette) addValue(out, value);
+  const names = new Set([...Object.keys(STD_DOMAINS), ...(domains === undefined ? [] : Object.keys(domains))]);
+  for (const name of names) {
+    const samples: unknown = domainOf(name, domains)?.samples;
+    if (Array.isArray(samples)) for (const value of samples as readonly unknown[]) addValue(out, value);
+  }
+  return out;
+}
+
+/** A false cover that a sample shows (D94): a member of a covered domain that no domain of the cover holds. */
+export interface FalseCover {
+  /** The name of the covered domain. */
+  readonly domain: string;
+  /** The cover: the names of its domains. */
+  readonly cover: readonly string[];
+  /** The sample. It is a member of the covered domain. */
+  readonly value: unknown;
+}
+
+/**
+ * This function finds the false covers of a language from samples (D94). A cover is false when a sample of the covered
+ * domain is in no domain of the cover. The function tests each valid cover of each domain of the table. It ignores a
+ * cover that does not count by the line rule of D85, because `fits` ignores it too. It also ignores a sample outside
+ * the covered domain.
+ *
+ * The samples of the domains come after the given samples (D99). `conforms` and a test of `fits` use the function. The
+ * kernel does not export it.
+ *
+ * @param domains - The domains of the language, by their names.
+ * @param samples - The samples of each covered domain, by the name of the domain.
+ * @returns Each sample that breaks a cover, in the order of the domains, the covers and the samples.
+ */
+export function falseCovers(domains: Readonly<Record<string, Domain>>, samples: Readonly<Record<string, readonly unknown[]>>): readonly FalseCover[] {
+  const out: FalseCover[] = [];
+  for (const [name, domain] of Object.entries(domains)) {
+    const covers: unknown = domain.covers;
+    if (!Array.isArray(covers)) continue;
+    const values = withDomainSamples((Object.hasOwn(samples, name) ? samples[name] : undefined) ?? [], domains);
+    for (const cover of covers as readonly unknown[]) {
+      if (!validCover(name, cover, domains)) continue;
+      for (const value of values) {
+        if (member(value, name, domains) && !cover.some((part) => member(value, part, domains))) out.push({ domain: name, cover, value });
+      }
+    }
+  }
+  return out;
 }
 
 /** This function holds the rules of the shapes of `fits`: base types, lists, records and functions. */
@@ -542,12 +607,13 @@ function partFits(part: string, expected: unknown, domains: Readonly<Record<stri
 /**
  * A field that the split rule can split: the path of keys to it, its cases, and if the field is optional. A value
  * split has the members of the field type. A type split has case types: the domains of a cover, or the members of a
- * union (TYPE.FITS-SPLIT-TYPE, D90).
+ * union (TYPE.FITS-SPLIT-TYPE, D90). A cover split has each valid cover of the field, in the order of the line (D102).
  */
 interface Split {
   readonly path: readonly string[];
   readonly values?: readonly unknown[];
   readonly types?: readonly ValueType[];
+  readonly covers?: readonly (readonly string[])[];
   readonly optional: boolean;
 }
 
@@ -563,7 +629,8 @@ interface SplitBudget {
  * cases is a split. An optional field also has the absent case.
  *
  * The type splits follow each value split, in the same order (D90). A base type with a valid cover in its line splits
- * into the domains of the cover. A union without a finite list splits into its members. The prefix is the path of `a`.
+ * into the domains of a cover, and it tries each valid cover (D102). A union without a finite list splits into its
+ * members. The prefix is the path of `a`.
  */
 function splitsOf(
   a: Extract<Form, { readonly t: "record" }>,
@@ -588,8 +655,8 @@ function splitsOf(
         if (inner.t === "record") deeper.push({ path: [...path, key], form: inner });
         else if (inner.t === "union") later.push({ path: [...path, key], types: inner.members, optional });
         else if (inner.t === "base") {
-          const cover = coverOf(inner.name, domains, false);
-          if (cover !== undefined) later.push({ path: [...path, key], types: cover, optional });
+          const covers = coversOf(inner.name, domains, false);
+          if (covers.length > 0) later.push({ path: [...path, key], covers, optional });
         }
       }
     }
@@ -604,17 +671,17 @@ function validCover(name: string, cover: unknown, domains: Readonly<Record<strin
 }
 
 /**
- * This function gives the cover of a base type for a type split (D90). The cover is the first valid cover of the first
- * domain in the line with a valid cover. With `own`, only the domain of the type itself counts. Each other type gives
- * `undefined`.
+ * This function gives the valid covers of a base type for a type split (D90, D102). The order is the order of the line,
+ * then the order of the covers of each domain. With `own`, only the domain of the type itself counts.
  */
-function coverOf(name: string, domains: Readonly<Record<string, Domain>> | undefined, own: boolean): readonly string[] | undefined {
+function coversOf(name: string, domains: Readonly<Record<string, Domain>> | undefined, own: boolean): readonly (readonly string[])[] {
+  const out: (readonly string[])[] = [];
   for (const each of own ? [name] : lineOf(name, domains)) {
     const covers: unknown = domainOf(each, domains)?.covers;
     if (!Array.isArray(covers)) continue;
-    for (const cover of covers as readonly unknown[]) if (validCover(each, cover, domains)) return cover;
+    for (const cover of covers as readonly unknown[]) if (validCover(each, cover, domains)) out.push(cover);
   }
-  return undefined;
+  return out;
 }
 
 /**
@@ -629,8 +696,8 @@ function againOf(type: ValueType, path: readonly string[], domains: Readonly<Rec
   const form = formOf(type, domains);
   if (form.t === "record") return splitsOf(form, domains, at, path);
   if (form.t === "union") return [{ path, types: form.members, optional: false }];
-  const cover = form.t === "base" ? coverOf(form.name, domains, true) : undefined;
-  return cover === undefined ? [] : [{ path, types: cover, optional: false }];
+  const covers = form.t === "base" ? coversOf(form.name, domains, true) : [];
+  return covers.length === 0 ? [] : [{ path, covers, optional: false }];
 }
 
 /**
@@ -663,6 +730,8 @@ function narrowAt(type: unknown, path: readonly string[], at: number, narrowed:
  * A record of the split that does not fit splits the next such field. A record of a type split first splits its case
  * again, at the same path. One budget of 64 records serves the outer split and each split inside its work, at each
  * depth. Thus nested splits do not multiply the work.
+ *
+ * A cover split tries each valid cover of its field until one fits (D102). Each try takes from the same budget.
  */
 function splitFits(
   found: unknown,
@@ -692,6 +761,15 @@ function casesFit(
 ): boolean {
   const split = splits[index];
   if (split === undefined) return false;
+  // A cover split tries each valid cover in its order. A failed try keeps the records that it took from the budget (D102).
+  if (split.covers !== undefined) {
+    for (const cover of split.covers) {
+      const tried = [...splits];
+      tried[index] = { path: split.path, types: cover, optional: split.optional };
+      if (casesFit(type, closed, tried, index, expected, domains, depth, gradual, budget)) return true;
+    }
+    return false;
+  }
   const types: readonly ValueType[] = split.values?.map((value) => ({ one: [value as Json] })) ?? split.types ?? [];
   const cases: ValueType[] = types.map((each) => narrowAt(type, split.path, 0, each, domains));
   if (split.optional) cases.push(narrowAt(type, split.path, 0, undefined, domains));
@@ -743,16 +821,18 @@ function casesFit(
  *   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
  *   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
  * - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
- *   its line splits into the domains of the first such cover. A field of a union without a finite list splits into its
- *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only a
- *   cover of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ *   its line splits into the domains of a cover. A field of a union without a finite list splits into its
+ *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only the
+ *   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ * - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
+ *   is the order of the line, then the order of the covers of each domain.
  *
  * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
  * (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
  * or a false cover makes the relation unsound for that domain.
  *
- * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. A
- * type split uses one cover of a field, not each cover of its line. A domain without `values` gets no finite rule, and
+ * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. The
+ * failed tries of covers take from these 64 records too. A domain without `values` gets no finite rule, and
  * neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
  * covers. The function does not throw.
  *

package/src/typing.ts

@@ -1,7 +1,8 @@
 import { type Envelope, type Key, isRecord, typeName } from "./doc.ts";
 import type { Machine } from "./evaluate.ts";
-import type { DocVisit, Issue } from "./static.ts";
-import { type ValueType, fits, isUnknown, typeIssues, typeText } from "./types.ts";
+import type { DocVisit, Issue, WorldIssue } from "./static.ts";
+import { type ValueType, domainOf, fits, isUnknown, typeIssues, typeText } from "./types.ts";
+import { type Kind, type Shape, eachKind, kindAt } from "./world.ts";
 
 /*
  * The check of value types (R5 P3, D25). The pass reads the documents that the walk of `check` visited. It goes down
@@ -133,8 +134,36 @@ export interface TypeRule {
    * @returns The type of the document.
    */
   readonly synth: (input: TypeInput, report: (problem: TypeProblem) => void) => ValueType;
+  /**
+   * This function lists the declarations that the rule reads, for example the signatures of a formula profile
+   * (TYPE.WORLD, D110). `checkWorld` with the option `types` examines each one before a document exists. A rule
+   * without this function declares nothing.
+   *
+   * @returns The value types that the rule reads, and the problems that the rule finds in its declarations.
+   */
+  readonly declared?: () => readonly Declared[];
 }
 
+/**
+ * One declaration of a type rule (TYPE.WORLD, D110). It is a value type that the rule reads, with what it is. Or it is
+ * a problem that the rule finds in a declaration, for example an overload that the check does not select at any time.
+ */
+export type Declared =
+  | {
+      /** The keys of the declaration in the declarations of the rule, for example `["sigs", "add", "to"]`. */
+      readonly at: readonly Key[];
+      /** The value type. `checkWorld` examines it with `typeIssues`. */
+      readonly type: unknown;
+      /** What the type is, for the reason of an issue, for example "result of a signature of ops.add". */
+      readonly what: string;
+    }
+  | {
+      /** The keys of the declaration in the declarations of the rule. */
+      readonly at: readonly Key[];
+      /** The reason of the problem. */
+      readonly problem: string;
+    };
+
 /** The type of one document of a check of types. */
 export interface Typed {
   /** The keys from the root document to the document. */
@@ -206,7 +235,7 @@ function pathKey(path: readonly Key[]): string {
 }
 
 /** This function gives the type rule of an evaluator name. A runner hides the evaluator of its name, and a runner has no rule yet (K29). */
-function ruleOf(machine: Machine, name: string | undefined): TypeRule | undefined {
+export function ruleOf(machine: Machine, name: string | undefined): TypeRule | undefined {
   if (name === undefined || (machine.runners !== undefined && Object.hasOwn(machine.runners, name))) return undefined;
   const evaluator = Object.hasOwn(machine.evaluators, name) ? machine.evaluators[name] : undefined;
   const rule = typeof evaluator === "object" && evaluator !== null ? (evaluator as { readonly type?: unknown }).type : undefined;
@@ -388,3 +417,114 @@ export function typePass(machine: Machine, nodes: readonly TypeNode[], verb: str
   const issues = found.sort((a, b) => a.index - b.index).map((item) => item.issue);
   return { type: types[0] ?? "unknown", issues, places };
 }
+
+/** The owner of a value type of a machine: a kind, a domain or a type rule. */
+type Owner = Pick<WorldIssue, "kind" | "fallback" | "domain" | "evaluator">;
+
+/**
+ * This function examines each value type of a machine before a document exists (TYPE.WORLD, D110). It reads the
+ * `result` and each `expect` of each kind, the parents and the steps of each domain, and the declarations of each type
+ * rule. Each problem of `typeIssues` gives one issue with the keys of the bad term.
+ *
+ * A term shape with `kinds` and `expect` also gets an issue for each kind of its list whose `result` does not fit
+ * `expect`. A check of types gives `#TYPE!` at each document of that kind there.
+ *
+ * @param machine - The machine.
+ * @returns The issues: the kinds in the order of the world, then the domains, then the type rules.
+ */
+export function machineTypeIssues(machine: Machine): readonly WorldIssue[] {
+  const domains = machine.domains;
+  const world = machine.world;
+  const out: WorldIssue[] = [];
+  const add = (owner: Owner, at: readonly Key[], reason: string): void => {
+    out.push({ code: "#TYPE!", ...owner, verb: "eval", at, reason });
+  };
+  /** This function examines one value type. It gives `true` when the type has no problem. */
+  const examine = (owner: Owner, at: readonly Key[], type: unknown, what: string): boolean => {
+    const problems = typeIssues(type, domains);
+    for (const problem of problems) add(owner, [...at, ...problem.at], `The ${what} is not a correct value type. ${problem.reason}`);
+    return problems.length === 0;
+  };
+  /**
+   * This function finds each kind of the list `kinds` of a term whose result does not fit the `expect` of the term.
+   * Only a kind at the path itself counts. A path through an alias or to a fallback kind gives no issue.
+   */
+  const results = (owner: Owner, kinds: readonly (readonly Key[])[], at: readonly Key[], expect: ValueType): void => {
+    if (isUnknown(expect, domains)) return;
+    kinds.forEach((path, index) => {
+      const found: Kind | undefined = Array.isArray(path) ? kindAt(world, path) : undefined;
+      const result = found?.result;
+      if (result === undefined || typeIssues(result, domains).length > 0 || fits(result, expect, domains)) return;
+      const text = path.join(".");
+      add(owner, [...at, "kinds", index], `The kind ${text} has the result ${typeText(result)}, and the part needs the type ${typeText(expect)}. Each document of ${text} here gets #TYPE!.`);
+    });
+  };
+
+  eachKind(world, (kind, path, fallback) => {
+    const owner: Owner = fallback ? { kind: path, fallback: true } : { kind: path };
+    const name = fallback ? (path.length === 0 ? "fallback kind of the world" : `fallback kind of ${path.join(".")}`) : `kind ${path.join(".")}`;
+    if (kind.result !== undefined) examine(owner, ["result"], kind.result, `result of the ${name}`);
+    // The set holds the shapes on the way, thus a shape that holds itself does not loop.
+    const way = new Set<Shape>();
+    const shape = (spec: Shape | undefined, at: readonly Key[]): void => {
+      if (typeof spec !== "object" || spec === null || way.has(spec)) return;
+      way.add(spec);
+      const expect = (spec as { readonly expect?: unknown }).expect;
+      const where = [...at, "expect"];
+      if (expect !== undefined && examine(owner, where, expect, `expected type at ${where.join(".")} of the ${name}`) && spec.shape === "term" && Array.isArray(spec.kinds)) {
+        results(owner, spec.kinds, at, expect as ValueType);
+      }
+      if (spec.shape === "list" || spec.shape === "map") shape(spec.item, [...at, "item"]);
+      if (spec.shape === "record") {
+        const fields: unknown = spec.fields;
+        if (typeof fields === "object" && fields !== null && !Array.isArray(fields)) {
+          for (const key of Object.keys(fields)) shape((fields as Readonly<Record<string, Shape>>)[key], [...at, "fields", key]);
+        }
+        shape(spec.rest, [...at, "rest"]);
+      }
+      way.delete(spec);
+    };
+    shape(kind.parts, ["parts"]);
+  });
+
+  const table = domains ?? {};
+  for (const name of Object.keys(table)) {
+    // A table entry with the name of the top or the bottom has no effect (TYPE.OPEN).
+    if (name === "unknown" || name === "never") continue;
+    const owner: Owner = { kind: [], domain: name };
+    const domain = domainOf(name, domains);
+    if (domain === undefined) {
+      add(owner, ["is"], `The domain ${name} has no test is. Each use of the name ${name} reads as unknown.`);
+      continue;
+    }
+    const under: unknown = domain.under;
+    if (Array.isArray(under)) {
+      under.forEach((parent: unknown, index) => {
+        if (parent === "unknown" || parent === "never") return;
+        if (typeof parent !== "string" || domainOf(parent, domains) === undefined) add(owner, ["under", index], `The parent ${String(parent)} of the domain ${name} is not a domain of the machine.`);
+      });
+    }
+    const steps: unknown = domain.steps;
+    if (typeof steps === "object" && steps !== null) {
+      for (const key of Object.keys(steps)) examine(owner, ["steps", key], (steps as Readonly<Record<string, unknown>>)[key], `type of the step ${key} of the domain ${name}`);
+    }
+  }
+
+  for (const name of Object.keys(machine.evaluators)) {
+    const declared = ruleOf(machine, name)?.declared;
+    if (typeof declared !== "function") continue;
+    const owner: Owner = { kind: [], evaluator: name };
+    let list: readonly Declared[];
+    try {
+      list = declared();
+    } catch (error) {
+      add(owner, [], `The type rule of ${name} fails: ${message(error)}`);
+      continue;
+    }
+    for (const item of list) {
+      if ("problem" in item) add(owner, item.at, item.problem);
+      else examine(owner, item.at, item.type, item.what);
+    }
+  }
+  return out;
+}

package/src/world.ts

@@ -323,6 +323,55 @@ export function isNamespace(entry: WorldEntry | undefined): entry is Namespace {
   return entry !== undefined && !isKind(entry) && !isAlias(entry) && Object.hasOwn(entry, "kinds");
 }
 
+/**
+ * This function visits each kind of a world. These are the kinds 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. A
+ * fallback kind has the keys of its namespace. It comes after the entries of that namespace. `checkWorld` reads the
+ * kinds with this one function.
+ *
+ * @param world - The world.
+ * @param visit - The function that gets each kind, its keys from the root of the world, and `true` for a fallback kind.
+ */
+export function eachKind(world: World, visit: (kind: Kind, path: readonly Key[], fallback: boolean) => void): void {
+  // 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);
+      }
+    }
+  };
+  entries(world.kinds, []);
+  if (world.fallback !== undefined) visit(world.fallback, [], true);
+}
+
+/**
+ * This function gives the kind at a path of a world, without an alias and without a fallback kind. A namespace on the
+ * way gives its entries.
+ *
+ * @param world - The world.
+ * @param path - The keys from the root of the world.
+ * @returns The kind, or `undefined` when no kind is at the path.
+ */
+export function kindAt(world: World, path: readonly Key[]): Kind | undefined {
+  let entries = world.kinds;
+  let entry: WorldEntry | undefined;
+  for (let index = 0; index < path.length; index += 1) {
+    entry = entryAt(entries, path[index] as Key);
+    if (index === path.length - 1) break;
+    if (!isNamespace(entry)) return undefined;
+    entries = entry.kinds;
+  }
+  return isKind(entry) ? entry : undefined;
+}
+
 function entryAt(entries: Readonly<Record<string, WorldEntry>>, key: Key): WorldEntry | undefined {
   const name = String(key);
   return Object.hasOwn(entries, name) ? entries[name] : undefined;