@mark1russell7/coeval 0.15.0 → 0.17.0

package/build/index.d.ts

@@ -302,6 +302,17 @@ interface HostThing {
   resolve?(keys: readonly Key[]): {
     readonly thing: Thing;
   } | undefined;
+  /**
+   * This optional function answers one step only when the host has its value without new work (SCHED.CLOSURE). A
+   * kept read of a closure uses it, because the evaluation did not ask for that read. A schedule gives the value of
+   * a node that has its result in the data epoch. A throw gives the error of the step.
+   *
+   * @param key - The key of the step.
+   * @returns What the step reaches, or `undefined` when the host does not know it yet. Then the kept read ends at the thing.
+   */
+  known?(key: Key): {
+    readonly thing: Thing;
+  } | undefined;
 }
 /** Something that a path can reach: any value of the host, or a host thing. */
 type Thing = unknown;
@@ -337,8 +348,31 @@ interface Context {
   readonly event: Thing;
   readonly caps: readonly Cap[];
 }
-/** The code of a `deref` evaluator: it answers one step of a path on a document of its kind. */
-type DerefCode = (doc: Envelope, key: Key) => Thing | undefined;
+/**
+ * The code of a `deref` evaluator: it answers one step of a path on a document of its kind. A field that holds
+ * `undefined` also gives `undefined`. The optional function `has` of the code tells the two cases apart
+ * (DEREF.KIND-UNDEFINED). A host gives the code a `has` with `Object.assign(code, { has })`.
+ */
+interface DerefCode {
+  /**
+   * This function answers one step on a document.
+   *
+   * @param doc - The document.
+   * @param key - The key of the step.
+   * @returns What the step reaches, or `undefined` when it reaches nothing.
+   */
+  (doc: Envelope, key: Key): Thing | undefined;
+  /**
+   * This optional function tells if a document has a field for a key. The kernel asks it only when the code gives
+   * `undefined`. Then `true` tells that the field holds `undefined`. A code without `has` reads `undefined` as a
+   * missing field, as a host thing does (DEREF.HOST-UNDEFINED).
+   *
+   * @param doc - The document.
+   * @param key - The key of the step.
+   * @returns `true` when the document has the field.
+   */
+  readonly has?: (doc: Envelope, key: Key) => boolean;
+}
 /**
  * The result of a step document: what it reached, or the reason of a failure. A failure can give its code, for
  * example `#REF!` for a position outside a space. The default code is `#N/A`.
@@ -359,13 +393,32 @@ interface WalkInput {
   readonly here: Thing;
   readonly context: Context;
   /**
-   * This function answers one step on a thing, through the ladder.
+   * This function answers one step on a thing, through the ladder. A field that holds `undefined` also gives
+   * `undefined`. The function `has` tells the two cases apart (DEREF.WALKER-UNDEFINED).
    *
    * @param thing - The thing.
    * @param key - The key.
    * @returns What the step reaches, or `undefined`.
    */
   deref(thing: Thing, key: Key): Thing | undefined;
+  /**
+   * This optional function tells if a step on a thing reaches a field, through the ladder. A walker needs it only
+   * when `deref` gives `undefined`. Then `true` tells that the field holds `undefined` (DEREF.WALKER-UNDEFINED).
+   * Each resolution of the kernel gives it. The function asks the ladder again, thus a host thing answers the step again.
+   *
+   * @param thing - The thing.
+   * @param key - The key.
+   * @returns `true` when the step reaches a field, also a field that holds `undefined`.
+   */
+  has?(thing: Thing, key: Key): boolean;
+  /**
+   * This optional function records one hop inside the walk (HOP.EACH-STEP). The resolution gives it only when it
+   * records hops. The hop of the whole walk comes after these hops, as before.
+   *
+   * @param key - The key that the walk followed.
+   * @param thing - The thing that the key reached.
+   */
+  readonly visit?: (key: Key, thing: Thing) => void;
 }
 /** A walker: the code of the verb `step` of a kind of step documents. */
 type Walker = (input: WalkInput) => WalkResult;
@@ -545,6 +598,23 @@ interface Domain {
    * standard extension `ext.domain`. A domain without a codec has no such document.
    */
   readonly codec?: DomainCodec;
+  /**
+   * The full list of the members of the domain, when the domain holds few values, for example `true` and `false` of
+   * `bool` (TYPE.FITS-FINITE). `fits` reads it: a base type with a list fits a type that holds each member of the list.
+   * The language keeps the list complete: each member of the domain is in the list. A value that fails a test of the
+   * domain does not count. The check reads a list of at most 64 values.
+   */
+  readonly values?: 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
+   * numbers as a cover of `number`. `fits` reads it: a base type fits a union when each domain of a cover fits it.
+   *
+   * 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.
+   */
+  readonly covers?: readonly (readonly string[])[];
 }
 /**
  * The codec of a domain: it writes a member of the domain as JSON, and it reads the JSON again (D40). Both functions
@@ -609,9 +679,33 @@ export declare function member(value: unknown, type: ValueType, domains?: Readon
  *   field is `unknown`.
  * - A function fits when it has the same or fewer parameters, each expected parameter fits its parameter, and its
  *   result fits.
- *
- * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types. It is not
- * complete. For example, `bool` does not fit `{ "one": [true, false] }`. The function does not throw.
+ * - The finite rule comes after these rules (TYPE.FITS-FINITE). A type with at most 64 members fits when each member
+ *   is a member of `expected`. Thus `bool` fits `{ "one": [true, false] }`.
+ * - A base type has few members when its domain or a parent declares `values`, as `null`, `undefined` and `bool` do.
+ *   A union, a `one`, a closed record of such types and a list of `never` also have few members.
+ * - The cover rule comes next (TYPE.FITS-COVER, D85). A base type fits a union or a `one` when each domain of a cover
+ *   fits. The cover is in `covers` of a domain of its line. Each domain of a cover is under the covered
+ *   domain. Thus a cover of `number` by `neg` and `nonneg` gives `number` a fit against `neg | nonneg`.
+ * - The split rule comes last (D84). An open record, or a closed record with more than 64 members, splits a field with
+ *   few members over a union. A closed record also splits over a `one`. Each record of the split narrows the field to
+ *   one member, and each record must fit.
+ *   Thus `{ "record": { "a": "bool" } }` fits a union of a record for each value of `a`.
+ * - A split also narrows a field of a record in a field, by its path (TYPE.FITS-PATH, D89). The fields of the record
+ *   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`.
+ *
+ * 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
+ * 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.
  *
  * @param found - The type that a part has.
  * @param expected - The type that the position needs.
@@ -1523,9 +1617,12 @@ interface StaticRead {
   readonly address: boolean;
   /** The path of the reference: its root and its steps. */
   readonly path: readonly Json[];
-  /** The keys from the root document to the reference document, through the parts. */
+  /**
+   * The keys from the root document to the reference document, through the parts. A read of an equation has the
+   * place of the first document of its tree kind (FACTS.EQUATIONS).
+   */
   readonly place: readonly Key[];
-  /** The keys from the root JSON value to the reference document. */
+  /** The keys from the root JSON value to the reference document, or to the document of the kind for an equation. */
   readonly at: readonly Key[];
 }
 /** The static facts of one document (D24). They depend only on the document and the machine, not on a context. */
@@ -1573,9 +1670,11 @@ interface FactsOptions {
  *
  * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
  *   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
- *   declares `reads` adds a read of each of its roots at each document of the kind.
+ *   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.
- * - `pure`: each kind declares `pure`, and the document has no effect and is not volatile.
+ * - `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.
  *
  * The hook `facts` of the machine answers for a name that a fallback kind covers, for example an operation. Its
@@ -1743,9 +1842,11 @@ interface Journal {
    *
    * @param all - The address of the `all`.
    * @param waiting - The indices of the items that wait.
+   * @param before - The number of the waits of this `all` that settled before this call. The kernel gives it, thus a
+   *   replayer keeps no state of a run (RUN.REPLAY-RUNS). An older copy of the kernel does not give it.
    * @returns The index of an item that waits, or `undefined` for the order of the host.
    */
-  readonly next?: (all: string, waiting: readonly number[]) => number | undefined;
+  readonly next?: (all: string, waiting: readonly number[], before?: number) => number | undefined;
 }
 /**
  * The runtime of one evaluation or run. Compiled code gets it with the context, and asks it to resolve paths and
@@ -2178,6 +2279,17 @@ interface PrepareOptions {
    * evaluates one time, when the plan compiles. Its result is one frozen value for each evaluation (PLAN.FOLD).
    */
   readonly fold?: boolean;
+  /**
+   * The values that the host declares fixed for each evaluation of the plan (PLAN.FIXED, D60). The field `names` gives
+   * a value for each fixed name. A path from a fixed name then resolves one time, when the plan compiles, and a pure
+   * part that reads only fixed names folds. Only a deeply frozen value of plain data fixes its name.
+   *
+   * Each folded part compares the value of its names with one own-key test and `Object.is`. A different value gives
+   * the code without the fold. A plan without folds ignores this option.
+   */
+  readonly fixed?: {
+    readonly names?: Readonly<Record<string, unknown>>;
+  };
 }
 /** A compiled document. It evaluates many times, and it does the work of the ladder one time. */
 interface Plan {
@@ -2320,25 +2432,34 @@ export declare class MergeError extends Error {
    */
   constructor(conflicts: readonly MergeConflict[]);
 }
-/** What `extendDomain` adds to a domain: more parents, and the types of more steps. */
+/** What `extendDomain` adds to a domain: more parents, the types of more steps, and more covers. */
 interface DomainExtension {
   /** The names of the parents to add. A member of the domain then also passes the test of each new parent. */
   readonly under?: readonly string[];
   /** The types of the steps to add. A step with the key of an earlier step replaces its type. */
   readonly steps?: Readonly<Record<string, ValueType>>;
+  /**
+   * The covers to add (TYPE.FITS-COVER, D85). A cover that the domain has already does not change. The language that
+   * adds a cover keeps it true, because `fits` trusts it.
+   */
+  readonly covers?: readonly (readonly string[])[];
 }
 /**
- * This function makes a part of a merge that adds parents or steps to a domain of an earlier part (TYPE.PARENTS). An
- * example is a domain of another language. The part reads the domain from the merge before it (`prev`). It gives a
- * copy with the same test and summary, and it names `["domains", name]` in `replaces` (D17). A domain of the kernel
- * that the earlier parts do not name comes from `STD_DOMAINS`.
+ * This function makes a part of a merge that adds parents, steps or covers to a domain of an earlier part
+ * (TYPE.PARENTS). An example is a domain of another language. The part reads the domain from the merge before it
+ * (`prev`). It gives a copy with the same test, summary, codec and list of values, and it names `["domains", name]`
+ * in `replaces` (D17).
+ * A domain of the kernel that the earlier parts do not name comes from `STD_DOMAINS`.
+ *
+ * An extension does not change the codec. Thus each member keeps its document (D80).
  *
  * A new parent adds its test to the domain (TYPE.MEMBER). Thus `fits` stays sound, but a value that fails the test of
  * the parent is no longer a member. The language that adds the parent keeps the signatures of the other language
- * true. A name without a domain gives an empty part, and `typeIssues` reports each use of that name.
+ * true. A new parent of a domain in a cover of another domain can make that cover false (D85). A name without a
+ * domain gives an empty part, and `typeIssues` reports each use of that name.
  *
  * @param name - The name of the domain.
- * @param more - The parents and the steps to add.
+ * @param more - The parents, the steps and the covers to add.
  * @returns The part, as a function of the merge before it.
  */
 export declare function extendDomain(name: string, more: DomainExtension): (prev: Machine) => MachinePart;
@@ -2535,12 +2656,222 @@ export declare function partsOf(world: World, value: unknown, declaredType?: str
  */
 export declare function pathMatches(path: readonly Key[], pattern: readonly Key[]): boolean;
 //#endregion
+//#region src/syntax.d.ts
+/** The place of an operator: before its term, between two terms, or after its term. */
+type SyntaxFixity = "prefix" | "infix" | "postfix";
+/**
+ * The grouping of a chain of one infix operator. `left` reads `a - b - c` as `(a - b) - c`, and `right` reads
+ * `a ^ b ^ c` as `a ^ (b ^ c)`. `none` refuses a chain. `flat` reads a chain as one document with each term.
+ */
+type SyntaxAssoc = "left" | "right" | "none" | "flat";
+/** One operator of a syntax profile. */
+interface SyntaxOperator {
+  /** The text of the operator, for example `+`, `<>` or `and`. A word operator is a plain name. */
+  readonly symbol: string;
+  /** The place of the operator. */
+  readonly fixity: SyntaxFixity;
+  /** The precedence. A larger number binds more tightly. */
+  readonly prec: number;
+  /** The grouping of a chain of an infix operator. The default is `left`. */
+  readonly assoc?: SyntaxAssoc;
+  /** The type of the document that the operator makes, with dots between the keys, for example `ops.add` or `and`. */
+  readonly kind: string;
+}
+/** The literal rules of a syntax profile. */
+interface SyntaxLiterals {
+  /** `false` removes the decimal numbers. The default is `true`. */
+  readonly numbers?: boolean;
+  /** `true` puts a minus sign right before a digit into the number, where a term starts. The default is `true`. */
+  readonly signed?: boolean;
+  /** The texts: the quote and the escape of a quote. `false` removes the texts. The default is `"` with backslashes. */
+  readonly strings?: false | {
+    readonly quote?: "\"" | "'";
+    readonly escape?: "backslash" | "double";
+  };
+  /** The words that are literals, with their values. The default is `true`, `false` and `null`. */
+  readonly words?: Readonly<Record<string, unknown>>;
+  /**
+   * The kinds of the data envelopes of a text, a number and a truth value, with dots between the keys (K159, D65). A
+   * literal in a place that takes a document gets its envelope. Such a place is the whole text, the document after a
+   * header name, or an argument that its form names in `wrap`. Thus `list(1)` gives `list(number(1))`, and `print`
+   * writes the envelope as the bare literal there. Without this field, a literal stays bare in each place.
+   */
+  readonly envelopes?: SyntaxEnvelopes;
+}
+/** The kinds of the data envelopes of the literals (K159, D65). A literal without a kind stays bare, for example `null`. */
+interface SyntaxEnvelopes {
+  /** The kind of a finite number, for example `number`. */
+  readonly number?: string;
+  /** The kind of a text, for example `text`. */
+  readonly text?: string;
+  /** The kind of a truth value, for example `bool`. */
+  readonly bool?: string;
+}
+/** A reference syntax that a pattern gives, for example the address `A1` of a cell. */
+interface SyntaxRefPattern {
+  /** The pattern of the text of a reference. The parser tries it before a name. */
+  readonly pattern: RegExp;
+  /** This function gives the path of the reference from its text. */
+  readonly read: (text: string) => readonly Key[];
+  /** This function gives the text of a path, or `undefined` when the pattern does not write the path. */
+  readonly write: (path: readonly unknown[]) => string | undefined;
+}
+/** The reference syntax of a syntax profile. */
+interface SyntaxRefs {
+  /** The root of a bare name. The default is `names`. Thus `x` is the path `["names", "x"]`. */
+  readonly bare?: string;
+  /** The roots that the text names first, for example `self.price`. The default is `self`, `world`, `event` and `caps`. */
+  readonly roots?: readonly string[];
+  /** `false` removes the field steps `a.b`. The default is `true`. */
+  readonly fields?: boolean;
+  /** The patterns of other references. */
+  readonly patterns?: readonly SyntaxRefPattern[];
+}
+/** A call form: a name with arguments in parentheses that makes a construct, for example `if(test, then, else)`. */
+interface SyntaxForm {
+  /**
+   * The name in the text: a plain name, or plain names with dots between them, for example `math.product` (K161). A
+   * name with dots needs the field steps of `refs.fields`, and its first key is not a word operator.
+   */
+  readonly name: string;
+  /** The type of the document, with dots between the keys. */
+  readonly kind: string;
+  /**
+   * The fields of the value, in the order of the arguments. Without them, the value is the list of the arguments. A
+   * form `named` permits only these keys, and without them it permits each key.
+   */
+  readonly fields?: readonly string[];
+  /** The smallest number of arguments. The default is the number of the fields, or `0`. Only `list` and `fields` read it. */
+  readonly min?: number;
+  /**
+   * The way that the arguments make the value (D63). The default is `fields` with fields, or `list`.
+   *
+   * - `list`: the value is the list of the arguments, for example `list(1, 2)`.
+   * - `fields`: the arguments go into the fields, in order, for example `if(test, then, else)`.
+   * - `named`: each argument is a key and a document, and the value is a record, for example `panel(width: 300)`.
+   * - `literal`: the one argument is a literal, and the value is its data, for example `text("big")`.
+   */
+  readonly args?: SyntaxFormArgs;
+  /**
+   * The arguments that take a document (K159, D65): `true` for each argument, or the names of some fields. A literal
+   * in such an argument gets its data envelope of `literals.envelopes`. Without that field, `wrap` changes nothing. A
+   * form `literal` takes no `wrap`, and a form `list` takes only `true`.
+   */
+  readonly wrap?: boolean | readonly string[];
+}
+/** The way that the arguments of a call form make the value of its document (D63). */
+type SyntaxFormArgs = "list" | "fields" | "named" | "literal";
+/** The call syntax of a syntax profile. */
+interface SyntaxCalls {
+  /** The operations that a call `name(args)` can name. `true` permits each name. The default is `true`. */
+  readonly ops?: boolean | readonly string[];
+  /** The call forms of constructs. A form wins over an operation with the same name. */
+  readonly forms?: readonly SyntaxForm[];
+  /** The text between two arguments. The default is `,`. */
+  readonly separator?: string;
+}
+/** The text of the header of a document (K157, D62). */
+interface SyntaxHeader {
+  /**
+   * The symbol between a name and its document, for example `=` in `total = 2 + 3`. The text gives the document the
+   * header `name`. Without the symbol, a document with a name has no text. The symbol is a group of symbols, and no
+   * infix or postfix operator is the symbol or the start of it.
+   */
+  readonly bind?: string;
+}
+/**
+ * The text syntax of a language (D41): an operator table, literal rules, reference syntax and call syntax. `parse`
+ * reads a text into a document, and `print` writes a document as text. The profile is data, thus a site, an editor
+ * and a language read the same rules.
+ */
+interface SyntaxProfile {
+  /** The operators. */
+  readonly operators?: readonly SyntaxOperator[];
+  /** The literal rules. */
+  readonly literals?: SyntaxLiterals;
+  /** The reference syntax. */
+  readonly refs?: SyntaxRefs;
+  /** The call syntax. */
+  readonly calls?: SyntaxCalls;
+  /** The text of the header of a document. */
+  readonly header?: SyntaxHeader;
+  /** The deepest nesting that `parse` accepts. The default is `256`. */
+  readonly maxDepth?: number;
+}
+/** A problem of a text: its character offset, its length and a message. */
+interface SyntaxIssue {
+  /** The 0-based character offset of the problem. */
+  readonly offset: number;
+  /** The number of characters of the problem. `0` marks a place between two characters. */
+  readonly length: number;
+  /** The message. */
+  readonly message: string;
+}
+/** The result of `parse`: a document, or the problems of the text. */
+type ParseResult = {
+  readonly ok: true;
+  readonly doc: Json;
+} | {
+  readonly ok: false;
+  readonly issues: readonly SyntaxIssue[];
+};
+/**
+ * The standard syntax of the formula kit. It gives the site and the playground a text form. The operators are
+ * `or`, `and`, `not`, the comparisons, `+ - * / %`, a minus sign and `^`, from the loosest to the tightest. A call
+ * `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs. The
+ * text `total = 2 + 3` gives the document the header name `total` (D62).
+ */
+export declare const STD_SYNTAX: SyntaxProfile;
+/**
+ * This function reads a text into a document with the rules of a profile (SYNTAX.PARSE). It does not throw for a
+ * bad text. The issue gives the offset, the length and a message (SYNTAX.SPAN).
+ *
+ * @param profile - The syntax profile.
+ * @param text - The text.
+ * @returns The document, or the issues of the text.
+ * @throws {TypeError} The profile is not valid, for example an operator has two entries of the same place.
+ */
+export declare function parse(profile: SyntaxProfile, text: string): ParseResult;
+/**
+ * This function writes a document as text with the rules of a profile (SYNTAX.PRINT). It writes the fewest
+ * parentheses that keep the tree. `parse` reads the text back to the same document (SYNTAX.ROUNDTRIP).
+ *
+ * @param profile - The syntax profile.
+ * @param doc - The document.
+ * @returns The text, or `#VALUE!` at the place of a document that the profile cannot write.
+ * @throws {TypeError} The profile is not valid.
+ */
+export declare function print(profile: SyntaxProfile, doc: unknown): Result<string>;
+/**
+ * This function makes the part of a merge that adds the verb `format` to a machine (D23, D41). Its default writes
+ * each document with the printer of the profile. A part gives its own text through the ladder, thus an own entry or
+ * a kind entry of `format` still wins.
+ *
+ * @param profile - The syntax profile.
+ * @returns The part for `mergeMachines`.
+ */
+export declare function syntaxFormat(profile: SyntaxProfile): MachinePart;
+//#endregion
 //#region src/stdlib.d.ts
 /**
  * The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
  * Each kind names an evaluator for `eval` and a view for `view`. The site draws each document with its view.
  */
 export declare const STD_WORLD: World;
+/**
+ * The text syntax of the standard world (K162, D64). The syntax kit (D41) reads it, thus a host of `STD_WORLD` does
+ * not write its own profile. The operators `>`, `+` and `*` make `greater`, `add` and `multiply`. A call form makes
+ * each other kind, and `ref` uses the reference syntax of the kit.
+ *
+ * A literal in a place that takes a document gets its data envelope (K159, D65). Such a place is a part of `if`,
+ * `list`, `seq` or `pure`, the value of `write`, or the whole text. The document after a header name is such a place
+ * too. Thus `list(1, "a")` evaluates to `[1, "a"]`. The forms `add`, `multiply` and `greater` write an operator document that its operator
+ * does not write, for example `add(5)` (K163).
+ *
+ * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
+ * the formula kit.
+ */
+export declare const WORLD_SYNTAX: SyntaxProfile;
 /** The code of the evaluators of the standard world, by name. */
 export declare const STD_EVALUATORS: Readonly<Record<string, Evaluator>>;
 /** The rungs of the ladder of an attribute, in their order (TREE.LADDER, D42). */
@@ -2564,6 +2895,15 @@ interface AttributeTrace {
  * @returns The record, or `undefined` for a thing that is not a node or an attribute that no demand reached.
  */
 export declare function attributeTrace(node: Thing, attribute: string): AttributeTrace | undefined;
+/**
+ * This function gives the place of a node of the decorated tree: the keys from the root document to the document of
+ * the node (HOP.PLACE). A view puts each hop of a resolution on its node with it. The node keeps its place already,
+ * thus the function adds no record.
+ *
+ * @param thing - A thing, for example the thing of a hop.
+ * @returns The keys of the place, or `undefined` for a thing that is not a node of the decorated tree.
+ */
+export declare function placeOf(thing: Thing): readonly Key[] | undefined;
 /** The options of a walker `nearest`. */
 interface NearestOptions {
   /**
@@ -2576,13 +2916,18 @@ interface NearestOptions {
   readonly matches?: (node: Thing, wanted: Json | undefined) => boolean;
   /** The most hops of one walk. The default is 256. */
   readonly maxHops?: number;
+  /**
+   * `true`: the walk records one hop for each node on the way before the node that it reaches (HOP.EACH-STEP). Each
+   * such hop has the followed key as its step. The default is `false`: one hop for the whole walk.
+   */
+  readonly eachStep?: boolean;
 }
 /**
  * This function makes a walker `nearest`. The walker follows a key (the default is `parent`) until the node that it
  * reaches has the wanted type. With `self: true`, the node where the walk starts is the first candidate. A node
- * without that key ends the walk with an error.
+ * without that key ends the walk with an error. With `eachStep`, a resolution with hops gets a hop for each node on the way.
  *
- * @param options - The test of a type and the most hops.
+ * @param options - The test of a type, the most hops and the record of each step.
  * @returns The walker.
  */
 export declare function nearestWalker(options?: NearestOptions): Walker;
@@ -2768,6 +3113,9 @@ type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<string, Do
  *   `ext.domain`.
  * - `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
+ *   `if` and each term of `and` and `or` must fit it. Without it, the check accepts each type there. A profile without
+ *   `truthy` ignores it, because the default truth needs `bool`.
  * - `otherwise`: the value of an `if` without `else`. The default is `null`. A profile with this key gives its value,
  *   also `undefined`.
  * - `logic`: what `and` and `or` give: a truth value (the default), or the value that decided.
@@ -2785,13 +3133,15 @@ type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<string, Do
  *   overloads. An operation without a signature takes and gives `unknown` (TYPE.GRADUAL).
  *
  * 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.
+ * 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`.
  */
 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 truthy?: (value: unknown) => boolean | undefined;
+  readonly truthType?: ValueType;
   readonly otherwise?: unknown;
   readonly logic?: "boolean" | "value";
   readonly omit?: (error: EvalError) => boolean;
@@ -2950,159 +3300,14 @@ export declare function encodeValue(machine: Pick<Machine, "domains">, value: un
  */
 export declare function decodeValue(machine: Machine, doc: unknown): Result;
 //#endregion
-//#region src/syntax.d.ts
-/** The place of an operator: before its term, between two terms, or after its term. */
-type SyntaxFixity = "prefix" | "infix" | "postfix";
+//#region src/reference.d.ts
 /**
- * The grouping of a chain of one infix operator. `left` reads `a - b - c` as `(a - b) - c`, and `right` reads
- * `a ^ b ^ c` as `a ^ (b ^ c)`. `none` refuses a chain. `flat` reads a chain as one document with each term.
+ * The definitional code of the reference, by evaluator name. The reference cannot read compiled code, thus each
+ * compiled evaluator or runner of a machine needs a definition here. A function evaluator needs none.
  */
-type SyntaxAssoc = "left" | "right" | "none" | "flat";
-/** One operator of a syntax profile. */
-interface SyntaxOperator {
-  /** The text of the operator, for example `+`, `<>` or `and`. A word operator is a plain name. */
-  readonly symbol: string;
-  /** The place of the operator. */
-  readonly fixity: SyntaxFixity;
-  /** The precedence. A larger number binds more tightly. */
-  readonly prec: number;
-  /** The grouping of a chain of an infix operator. The default is `left`. */
-  readonly assoc?: SyntaxAssoc;
-  /** The type of the document that the operator makes, with dots between the keys, for example `ops.add` or `and`. */
-  readonly kind: string;
-}
-/** The literal rules of a syntax profile. */
-interface SyntaxLiterals {
-  /** `false` removes the decimal numbers. The default is `true`. */
-  readonly numbers?: boolean;
-  /** `true` puts a minus sign right before a digit into the number, where a term starts. The default is `true`. */
-  readonly signed?: boolean;
-  /** The texts: the quote and the escape of a quote. `false` removes the texts. The default is `"` with backslashes. */
-  readonly strings?: false | {
-    readonly quote?: "\"" | "'";
-    readonly escape?: "backslash" | "double";
-  };
-  /** The words that are literals, with their values. The default is `true`, `false` and `null`. */
-  readonly words?: Readonly<Record<string, unknown>>;
-}
-/** A reference syntax that a pattern gives, for example the address `A1` of a cell. */
-interface SyntaxRefPattern {
-  /** The pattern of the text of a reference. The parser tries it before a name. */
-  readonly pattern: RegExp;
-  /** This function gives the path of the reference from its text. */
-  readonly read: (text: string) => readonly Key[];
-  /** This function gives the text of a path, or `undefined` when the pattern does not write the path. */
-  readonly write: (path: readonly unknown[]) => string | undefined;
-}
-/** The reference syntax of a syntax profile. */
-interface SyntaxRefs {
-  /** The root of a bare name. The default is `names`. Thus `x` is the path `["names", "x"]`. */
-  readonly bare?: string;
-  /** The roots that the text names first, for example `self.price`. The default is `self`, `world`, `event` and `caps`. */
-  readonly roots?: readonly string[];
-  /** `false` removes the field steps `a.b`. The default is `true`. */
-  readonly fields?: boolean;
-  /** The patterns of other references. */
-  readonly patterns?: readonly SyntaxRefPattern[];
-}
-/** A call form: a name with arguments in parentheses that makes a construct, for example `if(test, then, else)`. */
-interface SyntaxForm {
-  /** The name in the text. */
-  readonly name: string;
-  /** The type of the document, with dots between the keys. */
-  readonly kind: string;
-  /** The fields of the value, in the order of the arguments. Without them, the value is the list of the arguments. */
-  readonly fields?: readonly string[];
-  /** The smallest number of arguments. The default is the number of the fields, or `0`. */
-  readonly min?: number;
-}
-/** The call syntax of a syntax profile. */
-interface SyntaxCalls {
-  /** The operations that a call `name(args)` can name. `true` permits each name. The default is `true`. */
-  readonly ops?: boolean | readonly string[];
-  /** The call forms of constructs. A form wins over an operation with the same name. */
-  readonly forms?: readonly SyntaxForm[];
-  /** The text between two arguments. The default is `,`. */
-  readonly separator?: string;
-}
-/**
- * The text syntax of a language (D41): an operator table, literal rules, reference syntax and call syntax. `parse`
- * reads a text into a document, and `print` writes a document as text. The profile is data, thus a site, an editor
- * and a language read the same rules.
- */
-interface SyntaxProfile {
-  /** The operators. */
-  readonly operators?: readonly SyntaxOperator[];
-  /** The literal rules. */
-  readonly literals?: SyntaxLiterals;
-  /** The reference syntax. */
-  readonly refs?: SyntaxRefs;
-  /** The call syntax. */
-  readonly calls?: SyntaxCalls;
-  /** The deepest nesting that `parse` accepts. The default is `256`. */
-  readonly maxDepth?: number;
-}
-/** A problem of a text: its character offset, its length and a message. */
-interface SyntaxIssue {
-  /** The 0-based character offset of the problem. */
-  readonly offset: number;
-  /** The number of characters of the problem. `0` marks a place between two characters. */
-  readonly length: number;
-  /** The message. */
-  readonly message: string;
-}
-/** The result of `parse`: a document, or the problems of the text. */
-type ParseResult = {
-  readonly ok: true;
-  readonly doc: Json;
-} | {
-  readonly ok: false;
-  readonly issues: readonly SyntaxIssue[];
-};
-/**
- * The standard syntax of the formula kit. It gives the site and the playground a text form. The operators are
- * `or`, `and`, `not`, the comparisons, `+ - * / %`, a minus sign and `^`, from the loosest to the tightest. A call
- * `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs.
- */
-export declare const STD_SYNTAX: SyntaxProfile;
-/**
- * This function reads a text into a document with the rules of a profile (SYNTAX.PARSE). It does not throw for a
- * bad text. The issue gives the offset, the length and a message (SYNTAX.SPAN).
- *
- * @param profile - The syntax profile.
- * @param text - The text.
- * @returns The document, or the issues of the text.
- * @throws {TypeError} The profile is not valid, for example an operator has two entries of the same place.
- */
-export declare function parse(profile: SyntaxProfile, text: string): ParseResult;
-/**
- * This function writes a document as text with the rules of a profile (SYNTAX.PRINT). It writes the fewest
- * parentheses that keep the tree. `parse` reads the text back to the same document (SYNTAX.ROUNDTRIP).
- *
- * @param profile - The syntax profile.
- * @param doc - The document.
- * @returns The text, or `#VALUE!` at the place of a document that the profile cannot write.
- * @throws {TypeError} The profile is not valid.
- */
-export declare function print(profile: SyntaxProfile, doc: unknown): Result<string>;
-/**
- * This function makes the part of a merge that adds the verb `format` to a machine (D23, D41). Its default writes
- * each document with the printer of the profile. A part gives its own text through the ladder, thus an own entry or
- * a kind entry of `format` still wins.
- *
- * @param profile - The syntax profile.
- * @returns The part for `mergeMachines`.
- */
-export declare function syntaxFormat(profile: SyntaxProfile): MachinePart;
-//#endregion
-//#region src/reference.d.ts
-/**
- * The definitional code of the reference, by evaluator name. The reference cannot read compiled code, thus each
- * compiled evaluator or runner of a machine needs a definition here. A function evaluator needs none.
- */
-interface Definitions {
-  readonly evaluators?: Readonly<Record<string, EvalFn>>;
-  readonly runners?: Readonly<Record<string, RunFn>>;
+interface Definitions {
+  readonly evaluators?: Readonly<Record<string, EvalFn>>;
+  readonly runners?: Readonly<Record<string, RunFn>>;
 }
 /** The options of the reference interpreter. */
 interface ReferenceOptions {
@@ -3119,6 +3324,12 @@ interface ReferenceOptions {
    * each verb by the same rules (VERB.AGREE).
    */
   readonly verb?: string;
+  /**
+   * A list that gets each read of a resolution, in its order (REF.READS). A read has the shape of a read of a plan:
+   * the path, what it reached and the mark `free`. The reads of a closure and of an equation of a tree go in the
+   * same list. The reference adds no kept reads, because it has no static reads of a closure.
+   */
+  readonly reads?: Read[];
 }
 /** The options of a run of the reference: the options of an evaluation, with the host and a signal (REF.RUN). */
 interface ReferenceRunOptions extends ReferenceOptions {
@@ -3185,9 +3396,11 @@ export declare function formulaDefinitions(profile?: FormulaProfile): Definition
  * - `again`: a second evaluation of the same plan.
  * - `folds`: a second plan with the other choice of folds (PLAN.FOLD). It has no folds when the plan has them, and
  *   it has folds when the option `observe` stops the folds of the plan.
+ * - `fixed`: a plan that declares each name of plain data fixed (PLAN.FIXED). It evaluates with a frozen copy of
+ *   each such name, and then with the context of `agree`. `agreeRun` does not have this tier.
  * - `other`: the second tier of a language, from the option `other`.
  */
-type Tier = "reference" | "traced" | "again" | "folds" | "other";
+type Tier = "reference" | "traced" | "again" | "folds" | "fixed" | "other";
 /** What a second tier gives: its result, and its effects when it records them. */
 interface TierResult {
   readonly result: Result;
@@ -3213,8 +3426,8 @@ interface AgreeOptions {
   /** The definitional code of the compiled evaluators of the machine, for the reference. */
   readonly definitions?: Definitions;
   /**
-   * The tiers to compare with the plan. The default is the reference, the traced evaluation, a second evaluation and
-   * the plan with the other choice of folds.
+   * The tiers to compare with the plan. The default is the reference, the traced evaluation, a second evaluation, the
+   * plan with the other choice of folds and the plan with fixed names.
    */
   readonly tiers?: readonly Exclude<Tier, "other">[];
   /**
@@ -3256,6 +3469,11 @@ type Agreement = {
   readonly ok: true;
   readonly result: Result;
   readonly effects: readonly Effect[];
+  /**
+   * The free reads of the plan that `agreeRun` compared with the reference run (RUN.AGREES-READS). It is absent
+   * when no read compared, for example in `agree`.
+   */
+  readonly reads?: readonly Read[];
 } | {
   readonly ok: false;
   readonly tier: Tier;
@@ -3314,6 +3532,13 @@ interface AgreeRunOptions extends Omit<AgreeOptions, "other" | "perform"> {
  * The rules of `agree` compare the results and the effects, with their addresses and outcomes. A tier must also
  * settle the waits of each `all` in the order of the plan, thus a replay keeps the order of the waits.
  *
+ * The reference run must also give the free reads of the plan, in their order (RUN.AGREES-READS). Another replay of
+ * the plan records these reads. A kept read does not compare. When the plan keeps each root, its reads are not known,
+ * and no read compares.
+ *
+ * One replayer of the log serves each tier and the replay for the reads (RUN.AGREES-ONE-REPLAYER). The replayer keeps
+ * no state of a run (RUN.REPLAY-RUNS), thus each tier replays the same log as with a replayer of its own.
+ *
  * @param machine - The world, the evaluators and the runners.
  * @param doc - The document.
  * @param context - The names and the capabilities at the root.
@@ -3337,8 +3562,10 @@ export declare function agreeRun(machine: Machine, doc: unknown, context?: Conte
  * - `C8`: compiled code gives the result of code that compiles again at the time of the evaluation.
  * - `local`: the code keeps no state from one call to the next.
  * - `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.
  */
-type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree";
+type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree" | "truth";
 /** The probe of a finding: the document, the result of each probe part, the capabilities and the handler. */
 interface ConformProbe {
   /** The text of the type of the document. */
@@ -3415,8 +3642,10 @@ interface ConformOptions {
  *
  * The checks follow the obligations C1 to C8 of `docs/SEMANTICS.md`. Two more checks follow the premises of the
  * simulation of the plan. The check `local` finds state that stays from one call to the next. The check `agree` compares
- * 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.
+ * 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).
  *
  * @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.
@@ -3765,6 +3994,269 @@ export declare function edgesOf(facts: DocFacts): readonly NodeEdge[];
  */
 export declare function schedule(machine: Machine, options?: ScheduleOptions): Schedule;
 //#endregion
+//#region src/generate.d.ts
+/** A source of random numbers with a seed. The same seed gives the same numbers. */
+interface Random {
+  /** This function gives a number from 0 up to 1, without 1. */
+  next(): number;
+  /** This function gives a whole number from 0 up to `below`, without `below`. */
+  int(below: number): number;
+  /** This function gives `true` with the chance `p`. */
+  chance(p: number): boolean;
+  /** This function gives one item of a list that is not empty. */
+  pick<T>(items: readonly T[]): T;
+}
+/**
+ * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
+ *
+ * @param seed - The seed: a whole number.
+ * @returns The source.
+ */
+export declare function random(seed: number): Random;
+/** The options of `generate`. */
+interface GenerateOptions {
+  /** The seed. The same seed and the same options give the same document. */
+  readonly seed: number;
+  /** The types that a document can have. The default is `typesOf(world)`. A namespace with a fallback needs its keys here. */
+  readonly types?: readonly (readonly Key[])[];
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+  /** The names that the host binds at the root. */
+  readonly names?: readonly string[];
+  /** The deepest nesting of documents. The default is 4. */
+  readonly maxDepth?: number;
+  /** The most documents in one document. The default is 24. */
+  readonly maxSize?: number;
+  /** The chance of a malformed choice at each document. The default is 0.05. */
+  readonly malformed?: number;
+  /**
+   * This function gives the data of a document of a type without parts, for example a number for the kind `number`.
+   *
+   * @param type - The keys of the type.
+   * @param random - The source of random numbers.
+   * @returns The data, or `undefined` for a random JSON value.
+   */
+  readonly data?: (type: readonly Key[], random: Random) => Json | undefined;
+  /**
+   * This function gives the types to prefer for a part, for example a function for the field `fn` of `call`.
+   *
+   * @param type - The keys of the type of the parent.
+   * @param path - The path of the part in the value of the parent.
+   * @returns The types, or `undefined` for no preference.
+   */
+  readonly hints?: (type: readonly Key[], path: readonly Key[]) => readonly (readonly Key[])[] | undefined;
+  /** The evaluator names for own entries. The default is none. */
+  readonly own?: readonly string[];
+  /** The keys for the steps of a path after its root and its name. */
+  readonly keys?: readonly Key[];
+  /** The roots that a path can start at. The default is each root. */
+  readonly roots?: readonly Root[];
+  /** The most steps of a path after its root and its name. The default is 2. */
+  readonly steps?: number;
+}
+/**
+ * This function lists the types of a world: each kind and each alias, also in a namespace. A namespace with a
+ * fallback gives no types, because each key names a kind.
+ *
+ * @param world - The world.
+ * @returns The keys of each type.
+ */
+export declare function typesOf(world: World): readonly (readonly Key[])[];
+/**
+ * This function builds a random document for a world from the contracts of its kinds. It reads the shapes of the
+ * parts, the declared types, the permitted kinds and the names that the scope rules bind. Some choices are malformed
+ * on purpose, for example an unknown kind or an unknown name under a namespace with a fallback. Other examples are a
+ * value without its shape, a bare value without a type and a name that nothing binds. The depth and the size have
+ * limits.
+ *
+ * @param world - The world.
+ * @param options - The seed, the types, the limits and the data of the leaves.
+ * @returns The document, as JSON.
+ */
+export declare function generate(world: World, options: GenerateOptions): unknown;
+//#endregion
+//#region src/meaning.d.ts
+/**
+ * The smallest interface of the engine of a host that `agreeSchedule` examines (SCHED.AGREES). The demand schedule of
+ * `schedule` has this interface.
+ */
+interface ScheduleEngine {
+  /**
+   * This function adds a node, or gives a node a new document. The harness also gives the same document object again:
+   * a change of the structure without an edit.
+   *
+   * @param id - The name of the node.
+   * @param doc - The document of the node. It does not change in place.
+   */
+  set(id: string, doc: unknown): void;
+  /**
+   * This function removes a node. A later read of the node by another node gives the error of a missing step.
+   *
+   * @param id - The name of the node.
+   */
+  remove(id: string): unknown;
+  /**
+   * This function gives the engine the new context of the host. The values of a context do not change in place. The
+   * same context object again is a change of data that changes no value.
+   *
+   * @param context - The context of the host, without the root `world`.
+   */
+  changeData(context: Context): void;
+  /**
+   * This function gives the engine a new machine. The harness gives no new machine to an engine without this function.
+   *
+   * @param machine - The new machine.
+   */
+  changeMachine?(machine: Machine): void;
+  /**
+   * This function demands a node and gives its answer.
+   *
+   * @param id - The name of the node. The engine has the node.
+   * @returns The result of the node.
+   */
+  read(id: string): Result;
+}
+/** What a new engine gets beside its machine: the context of the host, and the type of a bare root value. */
+interface ScheduleEngineStart {
+  /** The first context of the host, without the root `world`. */
+  readonly context: Context;
+  /** The type of a bare root value, when the options of the harness name one. */
+  readonly declaredType?: string;
+}
+/**
+ * This function makes a new engine with no nodes. The harness makes one engine for each run. The function `schedule`
+ * has this form.
+ */
+type ScheduleEngineFactory = (machine: Machine, start: ScheduleEngineStart) => ScheduleEngine;
+/**
+ * The options of `agreeSchedule`. The defaults fit `STD_MACHINE`. A host with another machine also gives `generate`,
+ * `value` and `wire`, and it sets `runs` to `false` when its world has no kind `log`.
+ */
+interface AgreeScheduleOptions {
+  /** The machines. The first machine starts each run, and the command of a new machine takes the next one. The default is `STD_MACHINE` and a copy. */
+  readonly machines?: readonly Machine[];
+  /** The type of a bare root value, for each engine, each plan and each fact. */
+  readonly declaredType?: string;
+  /** The options of the document generator. Each generated path from `names` to a node changes into a path from `world`. */
+  readonly generate?: Omit<GenerateOptions, "seed" | "names">;
+  /**
+   * This function gives a small value document.
+   *
+   * @param rng - The source of random numbers.
+   * @returns The document.
+   */
+  readonly value?: (rng: Random) => unknown;
+  /**
+   * This function gives a document that reads one or two nodes, for dense graphs with many cycles.
+   *
+   * @param rng - The source of random numbers.
+   * @param node - This function gives a reference to a random node.
+   * @returns The document.
+   */
+  readonly wire?: (rng: Random, node: () => Json) => unknown;
+  /** The share of the nodes that `wire` gives. The default is 0.2. */
+  readonly wired?: number;
+  /** `true`: one generated document in ten goes into the kind `log`, thus the node is on the run side. The default is `true`. */
+  readonly runs?: boolean;
+  /** The names of the nodes. The default is five names. */
+  readonly nodes?: readonly string[];
+  /** The names that the context of the host binds at the root `names`. The default is `a`, `b`, `x` and `n`. */
+  readonly names?: readonly string[];
+  /** The values that a change of data gives a name of the host. The default has equal values, host values and a `Held` error. */
+  readonly values?: readonly unknown[];
+  /** The contexts of the host at the start of the runs, one after the other. */
+  readonly contexts?: readonly Context[];
+  /** The number of runs. The default is 100. */
+  readonly count?: number;
+  /** The number of commands in one run. The default is 30. */
+  readonly steps?: number;
+  /** The seed of the first run, and one more for each later run. The default is 9000011. */
+  readonly seed?: number;
+  /**
+   * This function compares two values that the rules of `sameResult` do not know. It answers first. Without an answer,
+   * two closures of `fn` are the same when they have the same parameters.
+   *
+   * @param a - The value of the engine, or of the first evaluation from scratch.
+   * @param b - The value from scratch.
+   * @returns `true` or `false`, or `undefined` for the other rules.
+   */
+  readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
+}
+/** What the harness reached: the commands, the reads, and the kinds of answers that it compared. */
+interface ScheduleAgreementCounts {
+  /** The reads of a node. */
+  readonly reads: number;
+  /** The reads with one answer from scratch, which the harness compared. */
+  readonly compared: number;
+  /** The reads whose answer from scratch is new at each evaluation. The harness does not compare them. */
+  readonly unrepeatable: number;
+  /** The compared answers that are a value. */
+  readonly values: number;
+  /** The compared answers that are the `#CYCLE!` of the node. */
+  readonly cycles: number;
+  /** The compared answers that are the `#REF!` of a node on the run side. */
+  readonly runs: number;
+  /** The changes of data with new names of the host. */
+  readonly data: number;
+  /** The changes of data that change no value. */
+  readonly empty: number;
+  /** The new documents of a node. */
+  readonly edits: number;
+  /** The new nodes. */
+  readonly additions: number;
+  /** The removed nodes. */
+  readonly removes: number;
+  /** The changes of the structure with the same document object. */
+  readonly same: number;
+  /** The new machines. */
+  readonly machines: number;
+}
+/** The outcome of `agreeSchedule`: what the harness reached, or the first disagreement. */
+type ScheduleAgreement = {
+  readonly ok: true;
+  readonly counts: ScheduleAgreementCounts;
+} | {
+  readonly ok: false;
+  /** The seed of the run. */
+  readonly seed: number;
+  /** The index of the command in the run. */
+  readonly step: number;
+  /** The node of the read. */
+  readonly node: string;
+  /** The answer of the engine. */
+  readonly engine: Result;
+  /** The answer of the evaluation from scratch. */
+  readonly scratch: Result;
+  /** The documents of the nodes at the read. */
+  readonly docs: ReadonlyMap<string, unknown>;
+  /** The context of the host at the read. */
+  readonly context: Context;
+  /** The machine at the read. */
+  readonly machine: Machine;
+  /** One sentence that tells the difference. */
+  readonly reason: string;
+  /** What the harness reached up to the read. */
+  readonly counts: ScheduleAgreementCounts;
+};
+/**
+ * This function examines an engine of a host against an evaluation from scratch (SCHED.AGREES, R4 P4, D58). Each run
+ * makes a new engine and a random graph of named nodes from the document generator. Then it gives random commands:
+ * edits, new nodes, removed nodes, the same document again, new machines and changes of data.
+ *
+ * - Each read command evaluates the whole graph from scratch two times, with the meaning of D31.
+ * - It then demands each node in a random order, or one node, and compares each answer with `sameResult`.
+ * - A read whose answer from scratch differs between the two evaluations is not compared.
+ * - Two errors agree when they have the same code, reason and place. Thus an engine gives the `#CYCLE!` and the
+ *   `#REF!` of D31.
+ *
+ * The same seed and the same options give the same commands, thus a disagreement occurs again.
+ *
+ * @param engine - This function makes a new engine for each run, for example `schedule`.
+ * @param options - The machines, the generator, the contexts, the number of runs and the rule for host values.
+ * @returns What the harness reached, or the first read whose answer differs from the answer from scratch.
+ */
+export declare function agreeSchedule(engine: ScheduleEngineFactory, options?: AgreeScheduleOptions): ScheduleAgreement;
+//#endregion
 //#region src/graph.d.ts
 /** One edge of a graph of nodes: a read of a node by another node. `NodeEdge` of a schedule is such an edge. */
 interface GraphEdge<Id> {
@@ -3909,12 +4401,21 @@ interface ReplayOptions {
    * value, because it does not wait. The default is `true`: an effect waits when it waited in the recorded run.
    */
   readonly wait?: boolean;
+  /**
+   * The rule of the host for two payloads that are not the same by `Object.is`: one of the run and one of the log.
+   * It works as the rule of `sameResult`. Its `undefined` gives the rules of `docEquals`. A log from `decodeLog` holds new copies
+   * of the members of a domain, for example of a time. The rule tells that two such copies are the same.
+   */
+  readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
 }
 /**
  * This function makes a recorder (RUN.RECORD). The recorder gives each effect to the function `perform` of the host.
  * Its log keeps each effect with its address, its kind, its payload and the outcome that the kernel gives it. The log
  * also keeps the order in which the waits of each `all` settle.
  *
+ * The recorder gives each call of its journal to the journal of the inner function, for example of a replayer. Thus a
+ * recording of a replay settles the waits in the order of the replayer, and it gives the same log (RUN.REPLAY-ORDER).
+ *
  * @param perform - The function of the host. Without it, each effect gives its payload, as in a run without a host.
  * @returns The function `perform` for the run, and the log.
  */
@@ -3924,94 +4425,172 @@ export declare function recorder(perform?: Perform): Recorder;
  * recorded error comes again with its code, its reason, its place and its cause. The waits of each `all` settle in the
  * recorded order. An effect that the log does not have at its address gives `#REPLAY!` (RUN.REPLAY-MISMATCH).
  *
- * A replayer keeps its place in the order of the waits, thus each run needs a new replayer.
+ * One replayer serves more than one run, also two runs at the same time (RUN.REPLAY-RUNS). The kernel tells the journal
+ * the number of the waits of each `all` that settled before, thus the replayer keeps no state of a run. When the
+ * recorded item of a wait does not wait in the run, that wait follows the order of the host.
  *
- * @param log - The log of a recorder.
- * @param options - `wait: false` for an evaluation.
+ * @param log - The log of a recorder, or of `decodeLog`.
+ * @param options - `wait: false` for an evaluation, and the rule of the host for payloads.
  * @returns The function `perform` for the replay.
  */
 export declare function replayer(log: ReplayLog, options?: ReplayOptions): Perform;
-//#endregion
-//#region src/generate.d.ts
-/** A source of random numbers with a seed. The same seed gives the same numbers. */
-interface Random {
-  /** This function gives a number from 0 up to 1, without 1. */
-  next(): number;
-  /** This function gives a whole number from 0 up to `below`, without `below`. */
-  int(below: number): number;
-  /** This function gives `true` with the chance `p`. */
-  chance(p: number): boolean;
-  /** This function gives one item of a list that is not empty. */
-  pick<T>(items: readonly T[]): T;
+/** The JSON form of a log (RUN.REPLAY-JSON). `encodeLog` writes it, and `decodeLog` reads it. */
+interface ReplayLogJson {
+  /** The version of the form. Only the version 1 exists. */
+  readonly version: 1;
+  readonly effects: readonly ReplayEntryJson[];
+  readonly settles: readonly ReplaySettle[];
+}
+/** The JSON form of one effect of a log. A value is a term document of `encodeValue` (D40). */
+interface ReplayEntryJson {
+  readonly address: string;
+  readonly kind: string;
+  /** The term document of the payload. The value `undefined` is `ext.undefined`. */
+  readonly payload: Json;
+  /** The JSON form of the outcome. It is absent when the recorded run stopped before the answer came. */
+  readonly outcome?: ReplayResultJson;
+  readonly waited: boolean;
+}
+/** The JSON form of an outcome: the term document of the value, or the JSON form of the error. */
+type ReplayResultJson = {
+  readonly ok: true;
+  readonly value: Json;
+} | {
+  readonly ok: false;
+  readonly error: ReplayErrorJson;
+};
+/** The JSON form of an error value. It has `cause`, `exception` or `causeParts` only when the error has a cause. */
+interface ReplayErrorJson {
+  readonly code: ErrorCode;
+  readonly reason: string;
+  readonly place?: readonly Key[];
+  /** The term document of the cause, when `encodeValue` writes the cause. */
+  readonly cause?: Json;
+  /** The JSON form of a cause that is an exception, when no domain with a codec holds it. */
+  readonly exception?: ReplayExceptionJson;
+  /**
+   * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
+   * (RUN.REPLAY-CAUSE-PARTS, D87). It is a list of parts, the part `record` or the part `share`. The index 0 of `loop` is its
+   * first exception, and the index 0 of `share` is its first list or record.
+   */
+  readonly causeParts?: ReplayCausePartsJson;
+  /** The names of the items of `causeParts` without a form, for example `cause.send`. This list is only a note. */
+  readonly dropped?: readonly string[];
 }
 /**
- * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
- *
- * @param seed - The seed: a whole number.
- * @returns The source.
+ * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
+ * (D87). It is a list of parts, the part `record` or the part `share`, as a field in `parts` (D82, D88).
  */
-export declare function random(seed: number): Random;
-/** The options of `generate`. */
-interface GenerateOptions {
-  /** The seed. The same seed and the same options give the same document. */
-  readonly seed: number;
-  /** The types that a document can have. The default is `typesOf(world)`. A namespace with a fallback needs its keys here. */
-  readonly types?: readonly (readonly Key[])[];
-  /** The type of a bare root value. */
-  readonly declaredType?: string;
-  /** The names that the host binds at the root. */
-  readonly names?: readonly string[];
-  /** The deepest nesting of documents. The default is 4. */
-  readonly maxDepth?: number;
-  /** The most documents in one document. The default is 24. */
-  readonly maxSize?: number;
-  /** The chance of a malformed choice at each document. The default is 0.05. */
-  readonly malformed?: number;
+type ReplayCausePartsJson = readonly ReplayPartsJson[] | {
+  readonly record: Readonly<Record<string, ReplayPartsJson>>;
+} | {
+  readonly share: number;
+};
+/**
+ * The JSON form of an exception (RUN.REPLAY-CAUSES, D76). The exceptions of an error and of their causes are a chain.
+ * The index 0 of the chain is the exception of the error. Each field after `message` is optional, thus a log of the
+ * version 1 without them stays correct.
+ */
+interface ReplayExceptionJson {
+  readonly name: string;
+  readonly message: string;
+  /** The term documents of the own fields of the exception that `encodeValue` writes, for example `code` or `errno`. */
+  readonly fields?: Readonly<Record<string, Json>>;
   /**
-   * This function gives the data of a document of a type without parts, for example a number for the kind `number`.
-   *
-   * @param type - The keys of the type.
-   * @param random - The source of random numbers.
-   * @returns The data, or `undefined` for a random JSON value.
+   * The own enumerable fields without a term document that are an exception, a list or a plain record (RUN.REPLAY-FIELDS,
+   * D78, D82). An example is a list `errors` on an `Error`. A list is a list of parts, and a record is the part `record`.
+   * Each exception in them has the rule of a cause. A container without a form in it is a name in `dropped`. A container
+   * that an earlier place holds is the part `share` (D88).
    */
-  readonly data?: (type: readonly Key[], random: Random) => Json | undefined;
+  readonly parts?: Readonly<Record<string, ReplayPartsJson>>;
   /**
-   * This function gives the types to prefer for a part, for example a function for the field `fn` of `call`.
-   *
-   * @param type - The keys of the type of the parent.
-   * @param path - The path of the part in the value of the parent.
-   * @returns The types, or `undefined` for no preference.
+   * The names of the own fields without a form, and `cause` for a cause without a form. An item of a container has the
+   * name of the container, a dot and its key or index, for example `errors.1` or `cause.send`. This list is only a note:
+   * `decodeLog` does not give these fields back.
    */
-  readonly hints?: (type: readonly Key[], path: readonly Key[]) => readonly (readonly Key[])[] | undefined;
-  /** The evaluator names for own entries. The default is none. */
-  readonly own?: readonly string[];
-  /** The keys for the steps of a path after its root and its name. */
-  readonly keys?: readonly Key[];
-  /** The roots that a path can start at. The default is each root. */
-  readonly roots?: readonly Root[];
-  /** The most steps of a path after its root and its name. The default is 2. */
-  readonly steps?: number;
+  readonly dropped?: readonly string[];
+  /**
+   * The own fields of the standard classes that are not enumerable (RUN.REPLAY-HIDDEN, D77): `errors` of an
+   * `AggregateError`, `error` and `suppressed` of a `SuppressedError`. A list is a list of parts.
+   */
+  readonly hidden?: Readonly<Record<string, ReplayPartsJson>>;
+  /** The term document of the cause, when `encodeValue` writes the cause. */
+  readonly cause?: Json;
+  /** The JSON form of a cause that is an exception, when no domain with a codec holds it. */
+  readonly exception?: ReplayExceptionJson;
+  /** The index in the chain of an earlier exception that is the cause. Thus a cycle of causes stays exact. */
+  readonly loop?: number;
+  /**
+   * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
+   * (RUN.REPLAY-CAUSE-PARTS, D87). Each exception in it has the rule of a cause, also a `loop`.
+   */
+  readonly causeParts?: ReplayCausePartsJson;
 }
 /**
- * This function lists the types of a world: each kind and each alias, also in a namespace. A namespace with a
- * fallback gives no types, because each key names a kind.
+ * The JSON form of one value of a field in `parts` or `hidden` (D77, D78, D82). It is a term document, an exception, a
+ * loop, a record of parts, or a share (D88). The walk is depth
+ * first: the fields in `parts` in their order, the hidden fields, then the cause. The mark `dropped` keeps the place of
+ * an item of a list without a form, and `decodeLog` gives a hole there.
  *
- * @param world - The world.
- * @returns The keys of each type.
+ * The part `share` is a list or a record of parts that an earlier place of the walk holds (RUN.REPLAY-SHARED, D88). Its
+ * index counts the lists and the records of parts in the order of the walk. Thus `decodeLog` gives one object for both places.
  */
-export declare function typesOf(world: World): readonly (readonly Key[])[];
+type ReplayPartJson = {
+  readonly value: Json;
+} | {
+  readonly exception: ReplayExceptionJson;
+} | {
+  readonly loop: number;
+} | {
+  readonly record: Readonly<Record<string, ReplayPartsJson>>;
+} | {
+  readonly share: number;
+} | {
+  readonly dropped: true;
+};
 /**
- * This function builds a random document for a world from the contracts of its kinds. It reads the shapes of the
- * parts, the declared types, the permitted kinds and the names that the scope rules bind. Some choices are malformed
- * on purpose, for example an unknown kind or an unknown name under a namespace with a fallback. Other examples are a
- * value without its shape, a bare value without a type and a name that nothing binds. The depth and the size have
- * limits.
+ * The JSON form of a value in `parts`, in `hidden` or in a record of parts (D82). It is one part, or a list of them. A
+ * list in a list is a JSON list in a JSON list, thus the rule is the same at each depth.
+ */
+type ReplayPartsJson = ReplayPartJson | readonly ReplayPartsJson[];
+/**
+ * This function writes a log as JSON (RUN.REPLAY-JSON, D75). Then `JSON.stringify` gives the text of a golden file.
+ *
+ * - Each payload and each value of an outcome is a term document of `encodeValue`. Thus `NaN`, `-0` and `undefined`
+ *   stay exact, and a member of a domain with a codec is `ext.domain`.
+ * - An error keeps its code, its reason, its place and its cause. A cause that `encodeValue` cannot write and that is
+ *   an exception keeps its name and its message in the field `exception`.
+ * - An exception also keeps its own fields that `encodeValue` writes, and the chain of its causes (RUN.REPLAY-CAUSES).
+ *   The list `dropped` names each other own field. A cause that is an earlier exception of the chain is its index in `loop`.
+ * - An exception keeps the hidden fields of the standard classes in `hidden`, for example `errors` of an
+ *   `AggregateError` (RUN.REPLAY-HIDDEN, D77). Each exception in them has the rule of a cause.
+ * - An enumerable field without a term document that is an exception, a list or a plain record is in `parts`
+ *   (RUN.REPLAY-FIELDS, D78, D82). An item of a list without a form is the mark `dropped` at its place.
+ * - A cause without a term document that is a list or a plain record with an exception is in `causeParts`
+ *   (RUN.REPLAY-CAUSE-PARTS, D87). The rule is the same for the cause of an exception and of an error value.
+ * - A list or a record of parts that an earlier place of one error holds is the part `share` with its index
+ *   (RUN.REPLAY-SHARED, D88). This rule also covers a container that holds itself.
+ * - An outcome that the log does not have stays absent.
+ *
+ * @param machine - The machine of the run, or only its domains.
+ * @param log - The log of a recorder.
+ * @returns The JSON form. `decodeLog` gives the log again.
+ * @throws {TypeError} A value has no term document, for example a closure, a host thing, a symbol, or a value that no
+ *   domain with a codec holds. The message names the effect and its address. A part of an exception is not a refusal.
+ */
+export declare function encodeLog(machine: Pick<Machine, "domains">, log: ReplayLog): ReplayLogJson;
+/**
+ * This function reads the JSON form of a log again (RUN.REPLAY-JSON). It reads each term document with the formula kit
+ * and the domains of the machine. A cause in the field `exception` becomes an exception with that name and message.
+ * The exception gets its fields and the chain of its causes again, also a cycle (RUN.REPLAY-CAUSES). A list gets a
+ * hole at the place of the mark `dropped`, thus each later item keeps its index (D78). Each share of a list or a record
+ * gives the same object (RUN.REPLAY-SHARED).
  *
- * @param world - The world.
- * @param options - The seed, the types, the limits and the data of the leaves.
- * @returns The document, as JSON.
+ * @param machine - The machine of the run, or only its domains.
+ * @param data - The JSON form, for example from `JSON.parse` of a golden file.
+ * @returns The log for `replayer`, or `#VALUE!` with the place of the first field that it cannot read.
  */
-export declare function generate(world: World, options: GenerateOptions): unknown;
+export declare function decodeLog(machine: Pick<Machine, "domains">, data: unknown): Result<ReplayLog>;
 //#endregion
 //#region src/providers.d.ts
 /** The type that a provider reads, and the problems of the reading. Each problem tells what the type does not test. */
@@ -4061,5 +4640,5 @@ interface SampleOptions {
  */
 export declare function typeFromSamples(values: readonly unknown[], options?: SampleOptions): ValueType;
 //#endregion
-export type { AgreeOptions, AgreeRunOptions, Agreement, Alias, AllOptions, Answer, AskOptions, AttributeDeclaration, AttributeRung, AttributeTrace, Cap, CapsRule, CheckOptions, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, DomainCodec, DomainExtension, Durable, DurableCounts, DurableOptions, Edge, Effect, EffectsOptions, Envelope, Epochs, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, EvaluateOptions, Evaluator, ExtFn, FactsOptions, Failed, Finding, FormulaProfile, GenerateOptions, Give, GraphCycle, GraphEdge, GraphNode, GraphOptions, Header, Hop, HopBy, HostThing, Issue, Journal, Json, JsonRecord, KernelCode, Key, Kind, KindFacts, KindSource, LazyOp, LazyRule, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, NodeEdge, NodeGraph, NodeInfo, NodeRunOptions, Obligation, OpFn, OrderProblem, Outcome, ParseResult, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PlanRunOptions, PrepareOptions, Random, Read, ReadsCheck, Recorder, RefUse, ReferenceOptions, ReferenceRunOptions, ReplayEntry, ReplayLog, ReplayOptions, ReplaySettle, Resolution, ResolveCode, ResolveOptions, Result, Root, RootTypes, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, SampleOptions, Schedule, ScheduleCounts, ScheduleOptions, ScopeRule, Shape$1 as Shape, Side, Signature, Split, StaticRead, Step, StepSpec, Steps, StopSignal, Stored, SyntaxAssoc, SyntaxCalls, SyntaxFixity, SyntaxForm, SyntaxIssue, SyntaxLiterals, SyntaxOperator, SyntaxProfile, SyntaxRefPattern, SyntaxRefs, Thing, Tier, TierInput, TierResult, TraceNode, TreeContract, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerbEffects, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldIssue, WorldPart };
+export type { AgreeOptions, AgreeRunOptions, AgreeScheduleOptions, Agreement, Alias, AllOptions, Answer, AskOptions, AttributeDeclaration, AttributeRung, AttributeTrace, Cap, CapsRule, CheckOptions, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, DomainCodec, DomainExtension, Durable, DurableCounts, DurableOptions, Edge, Effect, EffectsOptions, Envelope, Epochs, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, EvaluateOptions, Evaluator, ExtFn, FactsOptions, Failed, Finding, FormulaProfile, GenerateOptions, Give, GraphCycle, GraphEdge, GraphNode, GraphOptions, Header, Hop, HopBy, HostThing, Issue, Journal, Json, JsonRecord, KernelCode, Key, Kind, KindFacts, KindSource, LazyOp, LazyRule, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, NodeEdge, NodeGraph, NodeInfo, NodeRunOptions, Obligation, OpFn, OrderProblem, Outcome, ParseResult, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PlanRunOptions, PrepareOptions, Random, Read, ReadsCheck, Recorder, RefUse, ReferenceOptions, ReferenceRunOptions, ReplayCausePartsJson, ReplayEntry, ReplayEntryJson, ReplayErrorJson, ReplayExceptionJson, ReplayLog, ReplayLogJson, ReplayOptions, ReplayPartJson, ReplayPartsJson, ReplayResultJson, ReplaySettle, Resolution, ResolveCode, ResolveOptions, Result, Root, RootTypes, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, SampleOptions, Schedule, ScheduleAgreement, ScheduleAgreementCounts, ScheduleCounts, ScheduleEngine, ScheduleEngineFactory, ScheduleEngineStart, ScheduleOptions, ScopeRule, Shape$1 as Shape, Side, Signature, Split, StaticRead, Step, StepSpec, Steps, StopSignal, Stored, SyntaxAssoc, SyntaxCalls, SyntaxEnvelopes, SyntaxFixity, SyntaxForm, SyntaxFormArgs, SyntaxHeader, SyntaxIssue, SyntaxLiterals, SyntaxOperator, SyntaxProfile, SyntaxRefPattern, SyntaxRefs, Thing, Tier, TierInput, TierResult, TraceNode, TreeContract, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerbEffects, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldIssue, WorldPart };
 //# sourceMappingURL=index.d.ts.map