@mark1russell7/coeval 0.17.0 → 0.19.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "coeval: the kernel of declarative languages. Documents in envelopes, a ladder that finds the evaluator, kind contracts, compiled plans, a static kit, a formula kit and a run side with capabilities.",
   "type": "module",
   "main": "./build/index.js",
@@ -15,7 +15,8 @@
   "files": [
     "build",
     "src",
-    "!src/**/*.test.ts"
+    "!src/**/*.test.ts",
+    "!src/**/*.test-support.ts"
   ],
   "sideEffects": false,
   "license": "MIT",

package/src/codec.ts

@@ -1,7 +1,7 @@
 import { type Json, isEnvelope, isRecord } from "./doc.ts";
 import { type Result, describe, fail, ok } from "./errors.ts";
 import { type Machine, makeContext, prepare } from "./evaluate.ts";
-import { type Domain, type DomainCodec, domainOf, member } from "./types.ts";
+import { type Domain, type DomainCodec, domainOf, lineOf, member } from "./types.ts";
 
 /*
  * The codec of the values that JSON cannot write (K140, D40). A document holds such a value as a standard extension:
@@ -71,7 +71,7 @@ function setOwn(target: Record<string, Json>, key: string, value: Json): void {
 /** The state of one call of `encodeValue`. */
 interface Encoder {
   readonly domains: Domains;
-  /** The domains with a codec, in the order of their names. */
+  /** The domains with a codec, in the order of `codecOrder`. */
   readonly codecs: readonly (readonly [string, DomainCodec])[];
   /** The answer of `isJson` for each container that it examined. */
   readonly json: WeakMap<object, boolean>;
@@ -151,7 +151,8 @@ function encodeTerm(value: unknown, encoder: Encoder): Json {
  *
  * - A value that JSON writes exactly stays as it is. A literal with the shape of an envelope goes into `lit`.
  * - `NaN`, an infinity and `-0` become `ext.number`, and `undefined` becomes `ext.undefined`.
- * - A member of a domain with a codec becomes `ext.domain`. The domains go in the order of their names.
+ * - A member of a domain with a codec becomes `ext.domain`. The codec of a domain under another domain comes first
+ *   (EXT.SPECIFIC, D109). The order of the names decides between unrelated domains.
  * - A list or a plain record with such a value becomes the construct `list` or `record`.
  *
  * @param machine - The machine, or only its domains.
@@ -161,15 +162,34 @@ function encodeTerm(value: unknown, encoder: Encoder): Json {
  */
 export function encodeValue(machine: Pick<Machine, "domains">, value: unknown): Json {
   const domains = machine.domains;
+  return encodeTerm(value, { domains, codecs: codecOrder(domains), json: new WeakMap(), open: new Set() });
+}
+
+/**
+ * This function gives the domains with a codec in the order of `encodeValue` (EXT.SPECIFIC, D109). The depth of a
+ * domain is the count of the other domains with a codec in its line. A deeper domain comes first, and the order of the
+ * names decides between domains of the same depth (EXT.TIE). Thus a domain comes before each domain with a codec above it.
+ */
+function codecOrder(domains: Domains): readonly (readonly [string, DomainCodec])[] {
   const codecs: (readonly [string, DomainCodec])[] = [];
-  if (domains !== undefined) {
-    for (const name of Object.keys(domains).sort()) {
-      const domain = domainOf(name, domains);
-      const codec = domain === undefined ? undefined : codecOf(domain);
-      if (codec !== undefined) codecs.push([name, codec]);
-    }
+  if (domains === undefined) return codecs;
+  let parents = false;
+  for (const name of Object.keys(domains).sort()) {
+    const domain = domainOf(name, domains);
+    const codec = domain === undefined ? undefined : codecOf(domain);
+    if (domain === undefined || codec === undefined) continue;
+    codecs.push([name, codec]);
+    if (Array.isArray(domain.under)) parents = true;
+  }
+  // Without a parent of a domain with a codec, each depth is zero, thus the order of the names stays.
+  if (!parents) return codecs;
+  const depth = new Map<string, number>();
+  for (const [name] of codecs) {
+    const line = lineOf(name, domains);
+    depth.set(name, codecs.filter(([other]) => other !== name && line.has(other)).length);
   }
-  return encodeTerm(value, { domains, codecs, json: new WeakMap(), open: new Set() });
+  // The sort is stable, thus the order of the names stays between domains of the same depth.
+  return codecs.sort(([a], [b]) => (depth.get(b) as number) - (depth.get(a) as number));
 }
 
 /**

package/src/conform.ts

@@ -33,7 +33,7 @@ import { type Definitions, STD_DEFINITIONS } from "./reference.ts";
 import { STD_EVALUATORS } from "./stdlib.ts";
 import { sameValue } from "./agree.ts";
 import { declaredTruthOf } from "./formula.ts";
-import { membersOf, typeIssues, typeText } from "./types.ts";
+import { falseCovers, membersOf, typeIssues, typeText } from "./types.ts";
 import { type Random, random } from "./generate.ts";
 import { type Kind, type LazyRule, type Shape, type World, type WorldEntry, effectsOfVerb, isKind, isNamespace, lookupKind } from "./world.ts";
 
@@ -60,8 +60,10 @@ import { type Kind, type LazyRule, type Shape, type World, type WorldEntry, effe
  * - `agree`: compiled code gives the result of its definition for the reference interpreter.
  * - `truth`: the own `truthy` of a formula profile gives `true` or `false` for each member of its `truthType` (D86).
  *   Only `formula.if`, `formula.and` and `formula.or` of the formula kit get this check.
+ * - `cover`: each sample of a covered domain of the machine is in one domain of each cover of the domain (D94). Each
+ *   evaluator and each runner gets this check, because `fits` trusts the covers for each program.
  */
-export type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree" | "truth";
+export type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree" | "truth" | "cover";
 
 /** The probe of a finding: the document, the result of each probe part, the capabilities and the handler. */
 export interface ConformProbe {
@@ -136,7 +138,7 @@ export interface ConformOptions {
 }
 
 /** The order of the obligations in the list of findings. */
-const ORDER: readonly Obligation[] = ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "local", "agree", "truth"];
+const ORDER: readonly Obligation[] = ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "local", "agree", "truth", "cover"];
 
 /** A function in the results of the probe parts. It gives the count of its arguments. */
 const PROBE_FN = (...args: readonly unknown[]): number => args.length;
@@ -1032,7 +1034,8 @@ function examine(env: Env, sample: Sample, contract: Contract): void {
 /**
  * This function checks the declared truth of a profile (D86). The function `truthy` must give `true` or `false` for
  * each member of `truthType`, and it must not throw. The members come from the lists `values` of the domains of the
- * type. A type without such a list gets the values of the results of the palette that are its members.
+ * type. A type without such a list gets its members from the results of the palette and from the samples of the
+ * domains (D99).
  */
 function checkTruth(env: Env, code: unknown, probe: (value: unknown) => ConformProbe): void {
   const truth = declaredTruthOf(code);
@@ -1057,6 +1060,27 @@ function checkTruth(env: Env, code: unknown, probe: (value: unknown) => ConformP
   }
 }
 
+/**
+ * This function checks the covers of the domains of the machine from samples (D94). Each sample of a covered domain
+ * must be in one domain of each valid cover. The samples of a domain come from its list `values`. A domain without
+ * that list gets its members from the palette and from the samples of the domains, as for the check `truth`.
+ */
+function checkCovers(env: Env, probe: (value: unknown) => ConformProbe): void {
+  const domains = env.machine.domains;
+  if (domains === undefined) return;
+  const palette = env.results.flatMap((result) => (result.ok ? [result.value] : []));
+  const samples: Record<string, readonly unknown[]> = {};
+  for (const [name, domain] of Object.entries(domains)) if (domain.covers !== undefined) samples[name] = membersOf(name, domains, palette);
+  const found = falseCovers(domains, samples)[0];
+  if (found === undefined) return;
+  report(
+    env,
+    "cover",
+    `The member ${valueText(found.value)} of the domain ${found.domain} is in no domain of its cover ${found.cover.join(", ")}. The check of types trusts the cover, thus it is unsound for ${found.domain}.`,
+    () => probe(found.value),
+  );
+}
+
 /**
  * This function examines one evaluator or runner of a machine against the obligations of host code (K92, D36). It
  * starts the code directly, without the kernel, with probe parts and a probe runtime. It generates probe documents from
@@ -1067,7 +1091,8 @@ function checkTruth(env: Env, code: unknown, probe: (value: unknown) => ConformP
  * compiled code with its definition. The finding of an obligation names the first probe that breaks it. An empty list
  * means that each probe conforms.
  *
- * The check `truth` tests the declared truth of a formula profile (D86).
+ * The check `truth` tests the declared truth of a formula profile (D86). The check `cover` tests the covers of the
+ * domains of the machine from samples (D94).
  *
  * @param machine - The machine with the code and the world of the kinds.
  * @param name - The name of the evaluator or of the runner. A runner wins over an evaluator of the same name.
@@ -1110,11 +1135,12 @@ export function conforms(machine: Machine, name: string, options: ConformOptions
       examine(env, sample, contract);
     }
   }
-  // A probe of the truth gives the member to each part of the first probe document.
-  checkTruth(env, code, (value) =>
+  // A probe of the truth or of a cover gives the value to each part of the first probe document.
+  const probeWith = (value: unknown): ConformProbe =>
     first === undefined
       ? { type: typeName(types[0] as TypeRef), doc: { type: types[0] as TypeRef, value: null }, results: {}, waits: [], caps: NO_CAPS, running: runner }
-      : probeOf(first, { results: first.split.parts.map(() => ok(value)), waits: [], caps: NO_CAPS, running: runner }),
-  );
+      : probeOf(first, { results: first.split.parts.map(() => ok(value)), waits: [], caps: NO_CAPS, running: runner });
+  checkTruth(env, code, probeWith);
+  checkCovers(env, probeWith);
   return ORDER.filter((obligation) => env.found.has(obligation)).map((obligation) => env.found.get(obligation) as Finding);
 }

package/src/durable.ts

@@ -2,7 +2,7 @@ import type { Context } from "./deref.ts";
 import type { Result } from "./errors.ts";
 import { type Machine, type Plan, type PrepareOptions, type Read, prepare } from "./evaluate.ts";
 import { type DocFacts, type FactsOptions, factsOf } from "./facts.ts";
-import { type VerifyOptions, verifyReads } from "./reads.ts";
+import { type PrintOptions, type ReadPrints, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
 
 /*
  * Two levels of durability (R4 P7, D30). The plan and the facts of a document depend only on the structure: the
@@ -42,6 +42,11 @@ export interface DurableOptions {
   readonly volatile?: FactsOptions["volatile"];
   /** The rule of the host for two things, as in `verifyReads`. */
   readonly equal?: VerifyOptions["equal"];
+  /**
+   * The check of changes in place (READS.IN-PLACE, D112). With it, the cache keeps the prints of the reads of each
+   * pure document, and a verification compares them. `true` gives the default limit. Without it, the cache makes no prints.
+   */
+  readonly inPlace?: true | PrintOptions;
 }
 
 /**
@@ -154,10 +159,11 @@ function byDocument<T>(make: (doc: unknown) => T): (doc: unknown) => T {
  *   and each result (DURABLE.STRUCTURE).
  *
  * The host keeps two promises. In one data epoch, the context of a key gives the same data. The values of a
- * context and the documents do not change in place, as PLAN.CACHE and `verifyReads` say.
+ * context and the documents do not change in place, as PLAN.CACHE and `verifyReads` say. The option `inPlace`
+ * finds a change in place of a value that a pure document read (READS.IN-PLACE).
  *
  * @param machine - The machine of the first structure epoch.
- * @param options - The type of a bare root value, the verb, the volatile reads and the rule of the host for two things.
+ * @param options - The type of a bare root value, the verb, the volatile reads, the rule of the host and the check of changes in place.
  * @returns The cache.
  */
 export function durable(machine: Machine, options: DurableOptions = {}): Durable {
@@ -167,6 +173,9 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
   };
   const factsOptions: FactsOptions = { ...prepareOptions, ...(options.volatile === undefined ? {} : { volatile: options.volatile }) };
   const verifyOptions: VerifyOptions = options.equal === undefined ? {} : { equal: options.equal };
+  const printOptions: PrintOptions | undefined = options.inPlace === true ? {} : options.inPlace;
+  // The prints of the reads of each entry, only with the option `inPlace`. Thus an entry keeps its shape (PLAN.LEAN).
+  const printsOf = printOptions === undefined ? undefined : new WeakMap<Entry, ReadPrints>();
   const counts = { compiles: 0, facts: 0, evaluations: 0, verifications: 0, reuses: 0 };
   const results = new Map<unknown, Entry>();
   let current = machine;
@@ -205,7 +214,8 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
         }
         if (entry.reads !== undefined) {
           counts.verifications += 1;
-          if (verifyReads(plan, entry.reads, context, verifyOptions).same) {
+          const prints = printsOf?.get(entry);
+          if (verifyReads(plan, entry.reads, context, prints === undefined ? verifyOptions : { ...verifyOptions, prints }).same) {
             entry.data = epochs.data;
             counts.reuses += 1;
             return entry.result;
@@ -217,7 +227,9 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
       counts.evaluations += 1;
       const result = plan.evaluate(context, reads === undefined ? undefined : { reads });
       // A list that grows by push keeps room for more reads. A copy of a short list is smaller (PLAN.LEAN).
-      results.set(key, { plan, result, reads: reads === undefined ? undefined : reads.length === 0 ? NO_READS : reads.slice(), data: epochs.data });
+      const made: Entry = { plan, result, reads: reads === undefined ? undefined : reads.length === 0 ? NO_READS : reads.slice(), data: epochs.data };
+      results.set(key, made);
+      if (printsOf !== undefined && made.reads !== undefined) printsOf.set(made, printReads(made.reads, printOptions));
       return result;
     },
     changeData() {

package/src/evaluate.ts

@@ -1053,6 +1053,11 @@ class Session implements Runtime {
   private list: Effect[] | undefined;
   tick = 0;
   nextId = 0;
+  /**
+   * The count of the drives without a wait that are active at this time. In a run, an effect under such a drive does
+   * not reach the host (RUN.HELD).
+   */
+  held = 0;
   current: Building | undefined;
   readonly holder: Building | undefined;
   /**
@@ -1265,6 +1270,13 @@ class Session implements Runtime {
     if ("ok" in made) return made;
     const perform = this.perform;
     if (!this.running || perform === undefined) return this.answer(made, place);
+    if (this.held > 0) {
+      // The parent cannot wait for the answer of the host, thus the host does not get the effect (RUN.HELD).
+      made.outcome = fail("#CALC!", heldReason(made.kind), { place });
+      // The drive stops at this wait, and gives the #CALC! of the runner.
+      yield HELD;
+      return made.outcome;
+    }
     let done: unknown;
     try {
       done = perform(made);
@@ -1452,6 +1464,21 @@ export function waitedReason(kindText: string): string {
   return `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`;
 }
 
+/**
+ * This function gives the reason of an effect that a run does not give to the host: the parent of its runner cannot
+ * wait (RUN.HELD). The plan and the reference give the same reason.
+ *
+ * @param kind - The kind of the effect.
+ * @returns The reason.
+ */
+export function heldReason(kind: Cap): string {
+  const text = typeof kind === "string" ? kind : kind.join(".");
+  return `The parent of the runner cannot wait, thus the host does not get the effect ${text}.`;
+}
+
+/** The wait of an effect that a run does not give to the host. A drive without a wait stops at it (RUN.HELD). */
+const HELD: Promise<unknown> = /* @__PURE__ */ Promise.resolve(undefined);
+
 /** This function drives steps that cannot wait. A step that waits stops the steps, and gives `#CALC!`. */
 function drive(steps: Steps, kindText: string): Result {
   const step = steps.next();
@@ -2148,10 +2175,19 @@ function placedRun(inner: RunCode, place: readonly Key[], name: string): RunCode
 /**
  * This function gives the code of a runner under a parent that cannot wait: its steps, driven without a wait. An
  * evaluation and a run both drive them (RUN.DRIVE-NESTED). Only a step that really waits gives `#CALC!`, at the place
- * of the runner, where the error started (RUN.WAIT).
+ * of the runner, where the error started (RUN.WAIT). In a run, an effect under the runner does not reach the host,
+ * because the parent cannot wait for its answer (RUN.HELD).
  */
 function runnerCode(run: RunCode, place: readonly Key[], kindText: string): Code {
-  return (ctx, rt) => placed(drive(run(ctx, rt), kindText), place);
+  return (ctx, rt) => {
+    if (!rt.running || !(rt instanceof Session)) return placed(drive(run(ctx, rt), kindText), place);
+    rt.held += 1;
+    try {
+      return placed(drive(run(ctx, rt), kindText), place);
+    } finally {
+      rt.held -= 1;
+    }
+  };
 }
 
 /**

package/src/facts.ts

@@ -1,5 +1,5 @@
 import { type Json, type Key, isEnvelope, isKey } from "./doc.ts";
-import { type Kind, type LazyRule, type Side, type World, equationType, lookupKind } from "./world.ts";
+import { type Kind, type KindFacts, type LazyRule, type Side, type World, equationType, lookupKind } from "./world.ts";
 import { answerOf } from "./ladder.ts";
 import { pathMatches, splitParts } from "./parts.ts";
 import { type Root, ROOTS, isRef } from "./deref.ts";
@@ -43,9 +43,12 @@ export interface DocFacts {
    * here. The roots that a kind declares in `reads` are here too, each one at the place of its document.
    */
   readonly reads: readonly StaticRead[];
-  /** `"run"` when one kind of the document is on the run side (FACTS.SIDE). */
+  /** `"run"` when one kind of the document is on the run side for the verb of the facts (FACTS.SIDE, FACTS.VERB-SIDE). */
   readonly side: Side;
-  /** The kinds of the effects that the contracts declare, as texts with dots, each one time (FACTS.EFFECTS). */
+  /**
+   * The kinds of the effects that the contracts declare for the verb of the facts, as texts with dots, each one time
+   * (FACTS.EFFECTS, FACTS.VERB-EFFECTS).
+   */
   readonly effects: readonly string[];
   /**
    * `true` when each kind of the document declares `pure`, and the document has no effect and is not volatile. Then
@@ -63,8 +66,10 @@ export interface FactsOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
   /**
-   * The verb whose evaluators the facts describe, as in `prepare`. The default is `eval`. The contract of a kind
-   * describes the code of `eval` only. For another verb, only the hook `facts` describes the code (FACTS.VERB).
+   * The verb whose evaluators the facts describe, as in `prepare`. The default is `eval`. The marks `pure`,
+   * `volatile` and `lazy` of a contract describe the code of `eval` only. For another verb, only the hook `facts`
+   * describes the code (FACTS.VERB). The side and the effects come from the entry of the verb in `verbEffects`
+   * (FACTS.VERB-EFFECTS, D111).
    */
   readonly verb?: string;
   /**
@@ -92,7 +97,7 @@ function tight<T>(list: readonly T[]): readonly T[] {
 }
 
 /** What a document gives to its parts: its own lazy mark, and the lazy rules of its kind for the parts. */
-interface Above {
+export interface Above {
   readonly lazy: boolean;
   readonly rules: readonly LazyRule[] | typeof EACH | undefined;
   /** The position of each part among the parts that a rule `after` covers. It is made at the first need. */
@@ -136,7 +141,7 @@ function positionOf(above: Above, parent: DocVisit, rule: LazyRule, slot: readon
 }
 
 /** This function tells if the lazy rules of a document cover one of its parts. */
-function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean {
+export function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean {
   const rules = above.rules;
   if (rules === undefined) return false;
   if (rules === EACH) return true;
@@ -148,6 +153,32 @@ function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean
   return false;
 }
 
+/** The code of a document for the facts: the answer of the hook, and the lazy rules that the code gives its parts. */
+export interface CodeFacts {
+  /** `true` when the contract of the kind describes the code. */
+  readonly described: boolean;
+  /** The answer of the hook `facts` of the machine for the code. */
+  readonly answer: KindFacts | undefined;
+  /** The lazy rules of the parts (FACTS.LAZY). Code that the contract and the hook do not describe makes each part lazy. */
+  readonly rules: Above["rules"];
+}
+
+/**
+ * This function gives the code of a document of a kind for the facts (FACTS.LAZY). `factsOf` and the graph of
+ * attribute instances read the lazy rules with this one function (D107).
+ *
+ * @param machine - The world and the hook `facts`.
+ * @param v - The visit of the document.
+ * @param kind - The kind of the document.
+ * @param verb - The verb whose code the facts describe.
+ * @returns The answer of the hook and the lazy rules.
+ */
+export function codeFactsOf(machine: Machine, v: DocVisit, kind: Kind, verb: string): CodeFacts {
+  const code = codeOf(machine.world, v.declared ? undefined : v.doc.own, kind, verb, "eval");
+  const answer = code.name === undefined ? undefined : machine.facts?.(v.typePath ?? [], code.name);
+  return { described: code.described, answer, rules: code.described ? (answer?.lazy ?? kind.lazy) : (answer?.lazy ?? EACH) };
+}
+
 /**
  * This function gives the static facts of a document, for a schedule (R4 P2, D24). It walks the document one time,
  * by the contracts of its kinds:
@@ -157,7 +188,7 @@ function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean
  *   declares `reads` adds a read of each of its roots at each document of the kind. The first document of a tree
  *   kind also gets the lazy reads of the equations of its kind (FACTS.EQUATIONS). A read from `self` or from a name
  *   of a rung is not one of them, because it is not free (READS.EQUATION).
- * - `side` and `effects`: from the contract of each kind.
+ * - `side` and `effects`: from the contract of each kind, for the verb of the facts.
  * - `pure`: each kind declares `pure`, also in an equation, and the document has no effect and is not volatile.
  * - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
  *
@@ -166,9 +197,11 @@ function partLazy(above: Above, parent: DocVisit, slot: readonly Key[]): boolean
  * entry. Thus a document with an own entry for another evaluator is not pure, and each of its parts is lazy. The
  * hook can still answer for that evaluator.
  *
- * The option `verb` names the verb whose code the facts describe (FACTS.VERB). A contract describes the code of
- * `eval`, thus the rule of an own entry applies to each document for another verb. The side and the effects come
- * from the contracts for each verb.
+ * The option `verb` names the verb whose code the facts describe (FACTS.VERB). The marks of a contract describe the
+ * code of `eval`, thus the rule of an own entry applies to each document for another verb. For another verb, the
+ * effects are the effects that the entry of the verb in `verbEffects` declares (FACTS.VERB-EFFECTS, D111). A kind is
+ * on the run side for that verb when its entry declares an effect (FACTS.VERB-SIDE). A kind without an entry for the
+ * verb adds no effect, as in `check` (FACTS.VERB-UNDECLARED). Its code is still not pure without an answer of the hook.
  *
  * A read is one resolution of its path. A reference that the resolution reaches and follows is a part of that read
  * (DEREF.COLLAPSE), not a separate read. The facts depend only on the document and the machine. Thus a host computes
@@ -220,17 +253,15 @@ export function factsOf(machine: Machine, doc: unknown, options: FactsOptions =
           above.set(v, { lazy, rules: undefined });
           return undefined;
         }
-        const code = codeOf(world, v.declared ? undefined : v.doc.own, kind, verb, "eval");
-        const answer = code.name === undefined ? undefined : hook?.(v.typePath ?? [], code.name);
+        const { described, answer, rules } = codeFactsOf(machine, v, kind, verb);
+        above.set(v, { lazy, rules });
         let roots: readonly Root[] | undefined;
-        if (code.described) {
+        if (described) {
           note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
-          above.set(v, { lazy, rules: answer?.lazy ?? kind.lazy });
           roots = answer?.reads ?? kind.reads;
         } else {
           // The contract of the kind does not describe this code. Only the hook can.
           note(answer?.pure, answer?.volatile);
-          above.set(v, { lazy, rules: answer?.lazy ?? EACH });
           roots = answer?.reads;
         }
         // The code of the kind resolves each of these roots as a whole, at the place of its document (FACTS.KIND-READS).
@@ -239,13 +270,18 @@ export function factsOf(machine: Machine, doc: unknown, options: FactsOptions =
           if (node !== undefined && root === "self") continue;
           add({ root, keys: NONE, exact: true, lazy, address: false, path: [root], place: tight(place.place), at: tight(place.at) });
         }
+        // check and effectsOf read the declared effects with the same function (D27). The verb of the facts selects the
+        // declaration: effects for eval, and the entry of verbEffects for another verb (D49, D111).
+        const declared = declaredEffects(v, verb);
+        // The field side gives the side of eval. For another verb, a declared effect needs a runner, as in check, thus
+        // the run side (FACTS.VERB-SIDE).
+        const runs = verb === "eval" ? kind.side === "run" : declared.length > 0;
         // An equation evaluates without capabilities, thus an effect in it never reaches the host. It is still not pure.
-        if (kind.side === "run") {
+        if (runs) {
           if (node === undefined) side = "run";
           else pure = false;
         }
-        // check and effectsOf read the declared effects with the same function (D27).
-        for (const keys of declaredEffects(v)) {
+        for (const keys of declared) {
           if (node !== undefined) {
             pure = false;
             continue;

package/src/formula.ts

@@ -5,7 +5,7 @@ import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } f
 import { type Code, type CompileInput, type CompiledEvaluator, type CompiledPart, type Evaluator, type Machine, type Runtime, resolveCompiled, totalCode } from "./evaluate.ts";
 import { type MachinePart, mergeMachines } from "./merge.ts";
 import { type Domain, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, member, stepType, typeIssues, typeText } from "./types.ts";
-import type { PartType, TypeInput, TypeRule } from "./typing.ts";
+import type { Declared, PartType, TypeInput, TypeRule } from "./typing.ts";
 import { decodeDomain, domainTypeOf } from "./codec.ts";
 import { type StaticRead, factsOf } from "./facts.ts";
 
@@ -31,6 +31,8 @@ export type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<str
  * - `lazy`: the operations that evaluate their arguments themselves.
  * - `ext`: the extensions of the namespace `ext`, by their name. The kit has `ext.undefined`, `ext.number` and
  *   `ext.domain`.
+ * - `extTypes`: the value type of each extension of `ext`, by its name, for a check of types (TYPE.EXT, D103). An
+ *   extension without an entry gives `unknown` (TYPE.GRADUAL). An entry for a standard extension has no effect.
  * - `truthy`: the truth of a value for `if`, `and` and `or`. `undefined` is an error `#VALUE!`. The default
  *   accepts only `true` and `false`.
  * - `truthType`: the value type of a truth for the own `truthy`, for a check of types (TYPE.TRUTH, D81). A test of
@@ -54,12 +56,13 @@ export type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<str
  *
  * A check of types trusts the signatures. Each operation must give a member of the result of each signature that
  * its arguments match. The hook `check` must keep each result in that type. The function `truthy` must give a truth
- * for each member of `truthType`.
+ * for each member of `truthType`. Each extension must give a member of its type in `extTypes`.
  */
 export interface FormulaProfile {
   readonly ops?: Readonly<Record<string, OpFn>> | ((name: string) => OpFn | undefined);
   readonly lazy?: Readonly<Record<string, LazyOp>>;
   readonly ext?: Readonly<Record<string, ExtFn>>;
+  readonly extTypes?: Readonly<Record<string, ValueType>>;
   readonly truthy?: (value: unknown) => boolean | undefined;
   readonly truthType?: ValueType;
   readonly otherwise?: unknown;
@@ -232,6 +235,12 @@ function isSignature(value: unknown): value is Signature {
   return typeof value === "object" && value !== null && Array.isArray((value as { readonly params?: unknown }).params) && Object.hasOwn(value, "to");
 }
 
+/** This function tells if two signatures have the same parameters and the same rest parameter. */
+function sameParams(a: Signature, b: Signature): boolean {
+  if (!docEquals(a.params, b.params)) return false;
+  return a.rest === undefined ? b.rest === undefined : b.rest !== undefined && docEquals(a.rest, b.rest);
+}
+
 /** This function gives the text of a signature, for the reason of an issue. */
 function signatureText(sig: Signature): string {
   const params = sig.params.map(typeText);
@@ -272,7 +281,7 @@ function paramsOf(value: unknown): readonly string[] {
 /**
  * This function makes the type rules of the formula kit for one profile (TYPE.SYNTH, D25). Each evaluator of the kit
  * holds its rule. The rules read the rules of the profile that change a type: `truthy`, `truthType`, `logic`,
- * `otherwise`, `omit` and `sigs`.
+ * `otherwise`, `omit`, `sigs` and `extTypes`.
  */
 function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule>> {
   // The default truth needs a truth value. An own truth needs its declared type, or nothing without a declaration (D81).
@@ -322,6 +331,32 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     }
     return { sigs, bad: sigs.length !== raw.length };
   };
+  /**
+   * The declarations of the signatures, for `checkWorld` (TYPE.WORLD, D110). Only a record of signatures lists them.
+   * An overload with the parameters of an earlier overload is a problem: the earlier one always fits first.
+   */
+  const sigsDeclared = (): readonly Declared[] => {
+    const sigs = profile.sigs;
+    if (sigs === undefined || typeof sigs === "function") return [];
+    const out: Declared[] = [];
+    for (const name of Object.keys(sigs)) {
+      const raw: unknown = sigs[name];
+      const list: readonly unknown[] = Array.isArray(raw) ? raw : [raw];
+      list.forEach((sig, index) => {
+        const at: readonly Key[] = Array.isArray(raw) ? ["sigs", name, index] : ["sigs", name];
+        if (!isSignature(sig)) {
+          out.push({ at, problem: `A signature of ops.${name} is not a record with params and to. The check does not read it.` });
+          return;
+        }
+        sig.params.forEach((param, position) => out.push({ at: [...at, "params", position], type: param, what: `parameter ${position + 1} of a signature of ops.${name}` }));
+        if (sig.rest !== undefined) out.push({ at: [...at, "rest"], type: sig.rest, what: `rest parameter of a signature of ops.${name}` });
+        out.push({ at: [...at, "to"], type: sig.to, what: `result of a signature of ops.${name}` });
+        const earlier = list.slice(0, index).findIndex((other) => isSignature(other) && sameParams(other, sig));
+        if (earlier >= 0) out.push({ at, problem: `The overload ${index + 1} of ops.${name} has the parameters of the overload ${earlier + 1}. Thus the check never selects it.` });
+      });
+    }
+    return out;
+  };
   const logic = (word: "and" | "or"): TypeRule => ({
     part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
     synth: (input) => {
@@ -453,6 +488,8 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     },
 
     "formula.if": {
+      // The rule of if declares the truth type of the profile, thus one bad truth type gives one issue in checkWorld.
+      declared: () => (declared ? [{ at: ["truthType"], type: truth, what: "truth type of the profile" }] : []),
       part: (input, path) => {
         if (path[0] === "test") return truthPart(input, "test of if");
         return isUnknown(input.expected, input.machine.domains) ? {} : { expect: input.expected, what: `${String(path[0])} branch of if` };
@@ -468,6 +505,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     "formula.or": logic("or"),
 
     "formula.op": {
+      declared: sigsDeclared,
       part: (input, path) => {
         const read = signatures(input);
         // Only one signature gives the types of the arguments before their check. Overloads select after it.
@@ -507,10 +545,26 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     },
 
     "formula.ext": {
+      declared: () => {
+        const types = profile.extTypes;
+        const own = profile.ext;
+        if (types === undefined || own === undefined) return [];
+        // Only the type of an own extension counts. An entry for a standard extension has no effect (D103).
+        return Object.keys(types)
+          .filter((name) => Object.hasOwn(own, name))
+          .map((name) => ({ at: ["extTypes", name], type: types[name], what: `type of ext.${name} in extTypes` }));
+      },
       synth: (input) => {
         const name = nameOf(input);
         const own = profile.ext !== undefined && Object.hasOwn(profile.ext, name);
-        if (own) return "unknown";
+        if (own) {
+          // The declared type is a contract. A type with a problem gives unknown, thus one problem gives one issue (D103).
+          const types = profile.extTypes;
+          const declared = types !== undefined && Object.hasOwn(types, name) ? types[name] : undefined;
+          if (declared === undefined) return "unknown";
+          const type = input.contract(declared, `type of ext.${name} in extTypes`);
+          return typeIssues(type, input.machine.domains).length > 0 ? "unknown" : type;
+        }
         // The standard extensions give the values that JSON cannot write, thus each has a base type (D48).
         if (name === "undefined") return "undefined";
         if (name === "number") return "number";
@@ -580,6 +634,7 @@ const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
   "ops",
   "lazy",
   "ext",
+  "extTypes",
   "truthy",
   "truthType",
   "otherwise",