@mark1russell7/coeval 0.6.2 → 0.7.0

package/build/index.d.ts

@@ -151,8 +151,8 @@ export declare function fromJson(value: unknown): Envelope | undefined;
  * with this function does not keep a stale host value.
  *
  * The function does not use the stack for the depth, thus a deep document cannot overflow it. A cycle of lists or
- * records does not make it loop. `sameValue` of `agree` uses the same rules, and it adds rules for closures and for
- * a rule of the caller.
+ * records does not make it loop. `sameValue` of `agree` and `sameResult` use the same walk, and each adds its rules
+ * for other values (D20).
  *
  * @param a - The first value.
  * @param b - The second value.
@@ -162,7 +162,7 @@ export declare function docEquals(a: unknown, b: unknown): boolean;
 //#endregion
 //#region src/errors.d.ts
 /** The codes that the kernel gives. */
-type KernelCode = "#KIND?" | "#NOEVAL" | "#PART?" | "#NAME?" | "#REF!" | "#N/A" | "#CYCLE!" | "#STEP?" | "#VALUE!" | "#NUM!" | "#ARGS" | "#CAP!" | "#CALC!" | "#DEPTH!" | "#ABORT";
+type KernelCode = "#KIND?" | "#NOEVAL" | "#PART?" | "#NAME?" | "#REF!" | "#N/A" | "#CYCLE!" | "#STEP?" | "#VALUE!" | "#NUM!" | "#ARGS" | "#CAP!" | "#CALC!" | "#DEPTH!" | "#ABORT" | "#REPLAY!" | "#TYPE!";
 /** The code of an error value. A language can add its own codes. Each code starts with `#`. */
 type ErrorCode = KernelCode | `#${string}`;
 /**
@@ -270,12 +270,22 @@ interface HostThing {
   /** A short text for a reader, for example `node card`. */
   readonly label: string;
   /**
-   * This function answers one step.
+   * This function answers one step. A field that holds `undefined` also gives `undefined`. The function `has` tells
+   * the two cases apart (DEREF.HOST-UNDEFINED).
    *
    * @param key - The key of the step.
    * @returns What the step reaches, or `undefined` when it reaches nothing.
    */
   deref(key: Key): Thing | undefined;
+  /**
+   * This optional function tells if the thing has a field for a key. The kernel asks it only when `deref` gives
+   * `undefined`. Then `true` tells that the field holds `undefined`. A thing without `has` reads `undefined` as a
+   * missing field.
+   *
+   * @param key - The key of the step.
+   * @returns `true` when the thing has the field.
+   */
+  has?(key: Key): boolean;
   /**
    * This function gives the thing as a value, when a reference ends on it.
    *
@@ -287,7 +297,7 @@ interface HostThing {
    * path without one call for each step.
    *
    * @param keys - The keys.
-   * @returns What the keys reach, or `undefined` when they reach nothing.
+   * @returns What the keys reach, or `undefined` when they reach nothing. `{ thing: undefined }` tells that the keys reach a field that holds `undefined`.
    */
   resolve?(keys: readonly Key[]): {
     readonly thing: Thing;
@@ -404,8 +414,10 @@ interface ResolveOptions {
 }
 /**
  * This function answers one step of a path on a thing, through the ladder of the verb `deref`. A host thing
- * answers for itself (own). A document asks its own entry, then its kind. The default goes into the value: an own
- * field of an object, or an item of a list.
+ * answers for itself (own). A document asks its own entry, then its kind, then the default of the world
+ * (VERB.LADDER). A rung answers only with a `deref` that the navigator has. When no rung answers, the step goes into
+ * the value: an own field of an object, or an item of a list. A value without a type is data, thus the step goes
+ * into it at once.
  *
  * @param nav - The world and the code of the evaluators.
  * @param thing - The thing that the path reached.
@@ -445,9 +457,9 @@ export declare function context(parts?: Partial<Context>): Context;
  * This function resolves a path from a context, and records each hop.
  *
  * The first step is a root of the context. Each later step is a key or a step document. A key goes up the ladder
- * of the verb `deref` on the thing that the path reached. A step document is evaluated by the walker of its kind,
- * with the thing that the path reached. After each hop, a reference document is followed until the path reaches
- * something else (collapse), except in a plain navigation.
+ * of the verb `deref` on the thing that the path reached. A step document is evaluated by the walker that the
+ * ladder of the verb `step` gives, with the thing that the path reached. After each hop, a reference document is
+ * followed until the path reaches something else (collapse), except in a plain navigation.
  *
  * The codes of a failure:
  *
@@ -472,6 +484,162 @@ export declare function resolve(nav: Navigator, ctx: Context, path: readonly unk
  */
 export declare function valueOfThing(thing: Thing): unknown;
 //#endregion
+//#region src/types.d.ts
+/**
+ * A value type: a set of values that a result can have, as a JSON term.
+ *
+ * - A text names a base type: `unknown`, `never`, a domain of the kernel (`null`, `bool`, `number`, `text`), or a
+ *   domain of a language.
+ * - `list`: a list whose items have the type.
+ * - `record`: a plain record with the named fields. `optional` names the fields that can be absent. A `closed`
+ *   record has no other fields. The other fields of an open record can hold each value.
+ * - `fn`: a function with the types of its parameters, and the type of its result (`to`).
+ * - `union`: a value of one of the types. An empty union holds no value.
+ * - `one`: one of the JSON values of the list.
+ *
+ * A term that is not in this list reads as `unknown` (TYPE.UNKNOWN). Thus a later version can add a term.
+ */
+type ValueType = string | {
+  readonly list: ValueType;
+} | {
+  readonly record: Readonly<Record<string, ValueType>>;
+  readonly optional?: readonly string[];
+  readonly closed?: boolean;
+} | {
+  readonly fn: readonly ValueType[];
+  readonly to: ValueType;
+} | {
+  readonly union: readonly ValueType[];
+} | {
+  readonly one: readonly Json[];
+};
+/**
+ * A value domain: a base type of a language, with its membership test. A machine holds its domains by their names
+ * (`Machine.domains`). A value is a member of a domain only when the test of the domain and the test of each parent
+ * accept it (TYPE.MEMBER).
+ *
+ * A path does not follow a member of a domain as a reference (DEREF.COLLAPSE). Thus the test `is` must refuse each
+ * reference document.
+ */
+interface Domain {
+  /**
+   * This function tells if a value is a member of the domain. It must be pure. A test that throws gives `false`.
+   *
+   * @param value - The value.
+   * @returns `true` for a member.
+   */
+  readonly is: (value: unknown) => boolean;
+  /** The names of the parents: the base types that hold each member of the domain. A base type fits each parent. */
+  readonly under?: readonly string[];
+  /** One sentence that tells what the domain holds. */
+  readonly summary?: string;
+  /**
+   * The value type of each step into a member, by its key, for example the field `x` of a point (TYPE.STEPS). The
+   * check of a path reads the steps of the domain first, then the steps of each parent. The language keeps them true:
+   * a step with the key into a member reaches a member of the type. A key without a type gives `unknown`.
+   */
+  readonly steps?: Readonly<Record<string, ValueType>>;
+}
+/** A problem of a value type: the keys from the root of the term to the problem, and the reason. */
+interface TypeIssue {
+  readonly at: readonly Key[];
+  readonly reason: string;
+}
+/**
+ * The domains of the kernel. `unknown` and `never` are not domains: they are the top and the bottom of the types.
+ * A machine that does not name one of these domains gets it from this table.
+ */
+export declare const STD_DOMAINS: Readonly<Record<string, Domain>>;
+/**
+ * This function tells if a value is a member of a value type (TYPE.MEMBER). It is the membership test that a cast
+ * at run time uses.
+ *
+ * - Each value is a member of `unknown`, and no value is a member of `never`.
+ * - A value is a member of a domain when the test `is` of the domain and of each parent accepts it.
+ * - A list, a record, a union and `one` test their values at each depth.
+ * - A function type tests only that the value is a function. Its parameters need a test at each call.
+ *
+ * The function does not throw. A term that is not a value type, or a base type without a domain, holds each value.
+ *
+ * @param value - The value.
+ * @param type - The value type.
+ * @param domains - The domains of the machine. A domain of the kernel that the table does not name comes from `STD_DOMAINS`.
+ * @returns `true` when the value is a member of the type.
+ */
+export declare function member(value: unknown, type: ValueType, domains?: Readonly<Record<string, Domain>>): boolean;
+/**
+ * This function tells if each value of the type `found` can be where the type `expected` must be (TYPE.FITS). Each
+ * check of a type uses it.
+ *
+ * - `unknown` fits each type, and each type fits `unknown` (TYPE.UNKNOWN). This is the gradual top.
+ * - `never` fits each type. Only `never`, an empty union and an empty `one` fit `never`.
+ * - A union fits when each of its types fits. A type fits a union when it fits one of its types.
+ * - `one` fits when each of its values is a member of `expected`.
+ * - A base type fits itself and each parent of its domain, through each level (TYPE.DOMAIN).
+ * - A list fits a list when its items fit.
+ * - A record fits a record with fewer fields. A field that `expected` needs is not optional in `found`, and each field
+ *   fits. Only a closed record fits a closed record. An open record without an optional field fits only when that
+ *   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.
+ *
+ * @param found - The type that a part has.
+ * @param expected - The type that the position needs.
+ * @param domains - The domains of the machine. A domain of the kernel that the table does not name comes from `STD_DOMAINS`.
+ * @returns `true` when `found` fits `expected`.
+ */
+export declare function fits(found: ValueType, expected: ValueType, domains?: Readonly<Record<string, Domain>>): boolean;
+/**
+ * This function gives the join of two value types (TYPE.JOIN): a type that holds each member of both types. The check
+ * of a type uses it for the branches of an `if` and for the items of a list.
+ *
+ * - `unknown` with each type gives `unknown`, and `never` with a type gives that type.
+ * - When one type fits the other by the strict form of `fits`, the join is the wider type. The strict form reads
+ *   `unknown` only as the top.
+ * - Two lists give a list of the join of their items.
+ * - Two records give a record of the join of their common fields. A field of one closed record is optional in the
+ *   join of two closed records. The join of an open record leaves out the fields that only one record has.
+ * - Each other pair gives a union. The union puts the values of `one` together and leaves out each member that fits
+ *   another member.
+ *
+ * The join is sound: a member of `a` or of `b` is a member of the join. It is not always the least such type. The
+ * function does not throw.
+ *
+ * @param a - The first type.
+ * @param b - The second type.
+ * @param domains - The domains of the machine. A domain of the kernel that the table does not name comes from `STD_DOMAINS`.
+ * @returns The join.
+ */
+export declare function join(a: ValueType, b: ValueType, domains?: Readonly<Record<string, Domain>>): ValueType;
+/**
+ * This function gives the text of a value type (TYPE.TEXT), for the reason of an issue. The function does not throw.
+ *
+ * - A base type gives its name.
+ * - `list<T>` is a list, `{a: T, b?: U}` is a closed record, and `{a: T, ...}` is an open record.
+ * - `(T, U) => V` is a function, and `T | U` is a union.
+ * - `one` gives its values as JSON, and an empty union gives `never`.
+ * - A term that is not a value type gives `unknown`.
+ *
+ * The text shows at most 8 values of `one`, and it cuts a long value.
+ *
+ * @param type - The value type.
+ * @returns The text.
+ */
+export declare function typeText(type: ValueType): string;
+/**
+ * This function lists the problems of a value type (TYPE.ISSUES). A problem is a term that is not a value type, a
+ * base type without a domain, or a term that is too deep. `fits` and `member` read each such term as `unknown`.
+ * Thus a check that reads a type from a contract can report it first.
+ *
+ * @param type - The value type, as JSON.
+ * @param domains - The domains of the machine. A domain of the kernel that the table does not name comes from `STD_DOMAINS`.
+ * @returns The problems. A term comes before its parts, and the parts keep their order.
+ */
+export declare function typeIssues(type: unknown, domains?: Readonly<Record<string, Domain>>): readonly TypeIssue[];
+//#endregion
 //#region src/world.d.ts
 /** The two sides of evaluation. `derive` is pure. `run` causes effects in order. */
 type Side = "derive" | "run";
@@ -491,6 +659,9 @@ type Side = "derive" | "run";
  * A `term` with `address: true` is an address: a reference there gives what its path reaches, not the value. A
  * `term` with `kinds` permits only a part whose type starts with one of the paths. A `record` with `closed: true`
  * permits only its named fields. A `list` with `distinct: true` permits no two equal items.
+ *
+ * `expect` is the value type that a part must have, as `of` is its type (TYPE.CHECK). A shape with parts gives it to
+ * each part that `of` covers. Only a check of types reads it, and it describes the verb `eval`.
  */
 type Shape = {
   readonly shape: "none";
@@ -499,15 +670,18 @@ type Shape = {
   readonly of?: string;
   readonly address?: boolean;
   readonly kinds?: readonly (readonly Key[])[];
+  readonly expect?: ValueType;
 } | {
   readonly shape: "list";
   readonly of?: string;
   readonly item?: Shape;
   readonly distinct?: boolean;
+  readonly expect?: ValueType;
 } | {
   readonly shape: "map";
   readonly of?: string;
   readonly item?: Shape;
+  readonly expect?: ValueType;
 } | {
   readonly shape: "record";
   readonly fields: readonly string[] | Readonly<Record<string, Shape>>;
@@ -515,9 +689,11 @@ type Shape = {
   readonly required?: readonly string[];
   readonly rest?: Shape;
   readonly closed?: boolean;
+  readonly expect?: ValueType;
 } | {
   readonly shape: "deep";
   readonly of?: string;
+  readonly expect?: ValueType;
 } | {
   readonly shape: "text";
 } | {
@@ -585,8 +761,44 @@ type CapsRule = {
   readonly caps: readonly Cap[];
   readonly in?: readonly (readonly Key[])[];
 };
-/** A kind gives the name of an evaluator for each verb, and the contract of its value. */
-interface Kind {
+/**
+ * A lazy rule of a kind names the parts that an evaluation can skip and still give a value. An example is the
+ * branches of `if`. The static facts mark each read under such a part (D24).
+ *
+ * `in` names the parts, as patterns of their paths in the value. The key `"*"` matches each key. A rule without `in`
+ * covers each part. With `after: n`, the rule covers only the parts after the first `n` parts that its patterns
+ * match. Thus `{ after: 1 }` makes each part lazy except the first part, as in `and`.
+ */
+interface LazyRule {
+  readonly in?: readonly (readonly Key[])[];
+  readonly after?: number;
+}
+/**
+ * The static facts that a kind declares for its code (D24). The contract of a kind holds them, and the hook `facts`
+ * of a machine can give them for a name under a fallback kind. The facts describe the code of `eval`, and of `step`
+ * for a step document.
+ *
+ * - `pure`: `true` when the code of the kind causes no effect. Its result depends only on its data, the results
+ *   of its parts and what its paths reach. A kind that reads the context in another way does not declare it,
+ *   because the static facts do not see that read.
+ * - `volatile`: `true` when its result can change while each read gives the same thing, for example a clock.
+ * - `lazy`: the parts that an evaluation can skip and still give a value.
+ */
+interface KindFacts {
+  readonly pure?: boolean;
+  readonly volatile?: boolean;
+  readonly lazy?: readonly LazyRule[];
+}
+/**
+ * A kind gives the name of an evaluator for each verb, and the contract of its value. The contract serves each verb.
+ * For each verb, the kernel splits the parts and narrows their capabilities by it, and `check` reads its scope rules.
+ * `side` and `effects` tell what the verb `eval` does (VERB.CONTRACT).
+ */
+interface Kind extends KindFacts {
+  /**
+   * The evaluator names, by verb. `eval` evaluates a document, `deref` answers a step on it, and `step` names the
+   * walker of a step document. A language adds its own verbs, for example `view` or `format`.
+   */
   readonly verbs: Readonly<Record<string, string>>;
   /** Where the parts of the value are. The default is `none`. */
   readonly parts?: Shape;
@@ -599,13 +811,20 @@ interface Kind {
    * itself.
    */
   readonly caps?: readonly CapsRule[];
-  /** The side of the kind. A kind of the run side causes effects. The default is `derive`. */
+  /** The side of the verb `eval` of the kind. A kind of the run side causes effects. The default is `derive`. */
   readonly side?: Side;
   /**
-   * The effects that a document of this kind can cause. It is a list of the kinds of the effects. The text
-   * `"type"` means that the kind of the effect is the type of the document itself, as for a call.
+   * The effects that the verb `eval` of a document of this kind can cause. It is a list of the kinds of the effects.
+   * The text `"type"` means that the kind of the effect is the type of the document itself, as for a call. For a
+   * procedure entry, the list holds the latent effects of the procedure, and `checkLatent` compares them with its body
+   * (CAP.LATENT).
    */
   readonly effects?: "type" | readonly string[];
+  /**
+   * The value type of the result of the verb `eval`, when it is fixed (TYPE.SYNTH). A check of types gives it to each
+   * document of the kind, in the place of the type that the rule of the evaluator synthesizes.
+   */
+  readonly result?: ValueType;
   /** One sentence that tells what the kind is. */
   readonly summary?: string;
 }
@@ -627,6 +846,10 @@ type WorldEntry = Kind | Namespace | Alias;
  */
 interface World {
   readonly kinds: Readonly<Record<string, WorldEntry>>;
+  /**
+   * The default evaluator of each verb: the last rung of the ladder (LADDER.DEFAULT). It serves each verb, also
+   * `deref` and `step`. Without a default of `deref`, a step goes into the value of a document (VERB.LADDER).
+   */
   readonly defaults: Readonly<Record<string, string>>;
   readonly fallback?: Kind;
 }
@@ -770,7 +993,8 @@ export declare function kindNamed(world: World, name: TypeRef): Kind | undefined
  *
  * The question visits the rungs in order: the own entry of the envelope, then its kind, then the default of the
  * world. The type comes from the envelope, or else from the type that the position declares. The type is a
- * reference into the world. The ladder does not guess a type from the shape of a value.
+ * reference into the world. The ladder does not guess a type from the shape of a value. Each verb has this ladder:
+ * `eval`, `deref`, `step` and each verb of a language (VERB.LADDER).
  *
  * @param world - The kinds and the defaults.
  * @param doc - The header of the document: an envelope, or `{}` for a bare value.
@@ -780,59 +1004,498 @@ export declare function kindNamed(world: World, name: TypeRef): Kind | undefined
  */
 export declare function ask(world: World, doc: Header, verb: string, options?: AskOptions): Answer;
 //#endregion
-//#region src/evaluate.d.ts
+//#region src/parts.d.ts
+/** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
+interface PartSlot {
+  /** The keys from the value of the document to the part. */
+  readonly path: readonly Key[];
+  /** The path as one text, with a dot between the keys, for example `bind.x`. A part of a list has its index. */
+  readonly key: string;
+  readonly item: Json;
+  readonly of?: string;
+  /** `true` when the position of the part declares an address: a reference there gives what its path reaches. */
+  readonly address?: true;
+  /** The value type that the shape declares for the part (`expect`). Only a check of types reads it. */
+  readonly expect?: ValueType;
+}
+/** The value of a document, split into its parts, by the shape that its kind declares. */
+type Split = {
+  readonly ok: true;
+  /** The parts, in the order of the value. */
+  readonly parts: readonly PartSlot[];
+  /** The value without the parts: a field that holds a part is not in it, and a list of parts gives `null`. */
+  readonly data: Json;
+  /**
+   * This function gives the value with a handle in the place of each part.
+   *
+   * @param handles - One handle for each part, in the order of `parts`.
+   * @returns The value with the handles.
+   */
+  fill<P>(handles: readonly P[]): unknown;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+  readonly at: readonly Key[];
+};
 /**
- * This function makes a context with names and capabilities. The other roots are empty, and an evaluation sets
- * the world.
+ * This function splits a value into its parts, by the shape that its kind declares. The evaluator, the view and
+ * the static kit use the same split, thus each one sees the same parts.
  *
- * @param names - The names and their values.
- * @param caps - The effects that the term can cause.
- * @param self - The node of the term, if it has one.
- * @returns The context.
+ * @param shape - The shape of the value. The default is data.
+ * @param value - The value of the document.
+ * @returns The parts and a way to fill their places, or the reason why the value does not have the shape.
  */
-export declare function makeContext(names?: Readonly<Record<string, unknown>>, caps?: readonly Cap[], self?: Thing): Context;
+export declare function splitParts(shape: Shape | undefined, value: Json): Split;
 /**
- * This function gives the keys of a capability or of a kind of effect: a text is split at its dots.
- *
- * @param kind - The text or the keys.
- * @returns The keys, as texts.
+ * The kind and the parts of one document: what `partsOf` gives. `ok` is `false` only when the value is not a
+ * document: it has no envelope, and its position declares no type. A value without the shape of its kind gives a
+ * failed `split`.
  */
-export declare function capKeys(kind: Cap): readonly string[];
+type DocParts = {
+  readonly ok: true;
+  /** The document. A bare value gets the type that its position declares. */
+  readonly doc: Envelope;
+  /** `true` when the type came from the position and not from an envelope. */
+  readonly declared: boolean;
+  /** The kind, or `undefined` when the world has no kind for the type. Then the value is data. */
+  readonly kind: Kind | undefined;
+  /** The keys of the kind after each alias, or `undefined` without a kind. */
+  readonly typePath: readonly Key[] | undefined;
+  /**
+   * The split of the value by the shape of the kind. The reason of a failed split is the reason of the `#VALUE!`
+   * of an evaluation: it names the kind. Its `at` gives the keys from the value to the problem.
+   */
+  readonly split: Split;
+} | {
+  readonly ok: false;
+  readonly code: "#PART?";
+  readonly reason: string;
+};
 /**
- * This function tells if the capabilities permit an effect. A capability permits the kind of its name, and each kind
- * under it: `store` permits `store.update`. The comparison is key by key, thus `fs.read` does not permit the
- * kind with the keys `fs` and `read.json`.
+ * This function reads one document by the contracts of the world. It finds the kind of the type. A bare value gets
+ * the type that its position declares. Then the function splits the value by the shape of the kind. The plan, the
+ * reference interpreter and the static kit read each document with this function. Thus they see the same parts.
  *
- * @param caps - The capabilities of the context.
- * @param kind - The kind of the effect: a text with dots, or its keys.
- * @returns `true` when one capability permits it.
+ * @param world - The world of the kinds.
+ * @param value - The document, or a bare value.
+ * @param declaredType - The type that the position of a bare value declares.
+ * @returns The document, its kind and its parts, or the reason why the value is not a document.
  */
-export declare function permits(caps: readonly Cap[], kind: Cap): boolean;
+export declare function partsOf(world: World, value: unknown, declaredType?: string): DocParts;
 /**
- * This function narrows a context for a part: the part keeps only the capabilities that the context of its parent
- * permits. Thus an evaluator cannot give a part more effects than it has.
+ * This function tells if the path of a part matches a pattern of a scope rule. The key `"*"` of a pattern matches
+ * each key.
  *
- * @param parent - The context of the parent.
- * @param next - The context that the evaluator gives the part.
- * @returns The context of the part.
+ * @param path - The path of the part.
+ * @param pattern - The pattern.
+ * @returns `true` when the path matches.
  */
-export declare function narrow(parent: Context, next: Context): Context;
+export declare function pathMatches(path: readonly Key[], pattern: readonly Key[]): boolean;
+//#endregion
+//#region src/static.d.ts
+/** One document that a walk visits. */
+interface DocVisit {
+  /** The keys from the root document to this document, through the parts. It is the place of an error. */
+  readonly place: readonly Key[];
+  /** The keys from the root JSON value to this document. A change at this path changes this document. */
+  readonly at: readonly Key[];
+  /** The visit of the document that holds this document as a part. The root has none. */
+  readonly parent?: DocVisit | undefined;
+  /** The keys from the value of the parent to this document: the path of the part. The root has none. */
+  readonly slot: readonly Key[];
+  /** The document. A bare value has the type that its position declares. */
+  readonly doc: Envelope;
+  /** `true` when the type came from the position and not from an envelope. */
+  readonly declared: boolean;
+  /** The kind of the document, when the world has it. */
+  readonly kind?: Kind | undefined;
+  /** The keys of the kind after each alias. */
+  readonly typePath?: readonly Key[] | undefined;
+  /** The number of documents around this document. The root has 0. */
+  readonly depth: number;
+  /** The names that the kinds around this document bind for it. */
+  readonly names: ReadonlySet<string>;
+  /** The names that a sequence around this document binds only for the parts after it. */
+  readonly later: ReadonlySet<string>;
+  /** `true` when the position of the document declares an address: a reference there is not a read of a value. */
+  readonly address?: true | undefined;
+  /**
+   * The capabilities of the document: the capabilities of the walk, narrowed by the capability rules of the kinds
+   * around it (`Kind.caps`). A walk without capabilities gives none here.
+   */
+  readonly caps?: readonly Cap[] | undefined;
+}
+/** A position that a walk cannot read as a document. */
+interface WalkProblem {
+  /** The keys from the root document to the document with the problem. */
+  readonly place: readonly Key[];
+  /** The keys from the root JSON value to the value with the problem. */
+  readonly at: readonly Key[];
+  readonly code: "#PART?" | "#VALUE!";
+  readonly reason: string;
+}
+/** The options of a walk. */
+interface WalkOptions {
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+  /** The names that the host binds at the root. */
+  readonly names?: readonly string[];
+  /** The capabilities at the root. With them, each visit gets the capabilities of its document. */
+  readonly caps?: readonly Cap[];
+  /**
+   * This function gets each position that is not a document.
+   *
+   * @param problem - The position and the reason.
+   */
+  readonly problem?: (problem: WalkProblem) => void;
+}
 /**
- * This function gives the capabilities that two lists both permit. An effect is permitted by the result when each
- * list permits it. When the list `b` permits each capability of `a`, the result is the list `a` itself.
+ * This function visits each document of a document: the root and each part at each depth, by the contracts of the
+ * kinds. A part of a kind that the world does not have is not visited. With capabilities in the options, the walk
+ * narrows them for each part by the rules of its kind, as a run does. The walk uses no stack of the host for the
+ * depth, thus a deep document cannot overflow it. The time and the memory of a walk are linear in the size of the
+ * document. A visit makes the keys of its place and of its path only when a reader asks for them.
  *
- * @param a - The first list, for example the capabilities of a document.
- * @param b - The second list, for example the list of a rule `only`.
- * @returns The capabilities that both lists permit.
+ * @param world - The world of the kinds.
+ * @param doc - The document, as JSON.
+ * @param visit - The function that gets each document. It gives `"skip"` to not visit the parts of a document.
+ * @param options - The type of a bare root value, the names, the capabilities and a function for the problems.
  */
-export declare function intersectCaps(a: readonly Cap[], b: readonly Cap[]): readonly Cap[];
+export declare function walk(world: World, doc: unknown, visit: (visit: DocVisit) => void | "skip", options?: WalkOptions): void;
+/** One reference of a document. */
+interface RefUse {
+  /** The visit of the reference document: its parent, its depth and the names that it sees. */
+  readonly visit: DocVisit;
+  /** The place of the reference document, through the parts. */
+  readonly place: readonly Key[];
+  /** The keys from the root JSON value to the reference document. */
+  readonly at: readonly Key[];
+  /** The path of the reference: its root and its steps. */
+  readonly path: readonly Json[];
+  readonly root: string;
+  /** `false` when a kind around the reference binds its first name. A reference to another root is free. */
+  readonly free: boolean;
+  /** `true` when the reference is an address: its position declares it. An address does not read a value. */
+  readonly address: boolean;
+}
 /**
- * This function gives the capabilities that a kind gives one of its parts, by the capability rules of its contract.
- * The kernel and the static kit both use it, thus a run and a check narrow the same way.
+ * This function finds each reference of a document: each document of the type `ref` that a walk reaches. A
+ * reference to a name that a kind around it binds is not free. The others are what the document reads from
+ * outside: its dependencies. When the kind `ref` has parts, the walk also finds the references in its step documents.
  *
- * @param rules - The capability rules of the kind (`Kind.caps`).
- * @param path - The path of the part in the value of the document.
- * @param caps - The capabilities of the document.
+ * @param world - The world of the kinds.
+ * @param doc - The document, as JSON.
+ * @param options - The type of a bare root value. The names of the host do not change the result.
+ * @returns The references, in the order of the document.
+ */
+export declare function refsOf(world: World, doc: unknown, options?: WalkOptions): readonly RefUse[];
+/**
+ * This function changes the free references of a document. The document is not changed: the function gives a new
+ * document that shares each part without a change.
+ *
+ * @param world - The world of the kinds.
+ * @param doc - The document, as JSON.
+ * @param change - The function that gives the new document of a reference, or `undefined` to keep it.
+ * @param options - The type of a bare root value, and the names that the host binds at the root.
+ * @returns The new document.
+ */
+export declare function mapRefs(world: World, doc: unknown, change: (use: RefUse) => unknown, options?: WalkOptions): unknown;
+/** A problem that a check finds before a document runs. */
+interface Issue {
+  readonly code: ErrorCode;
+  /** The keys from the root document to the document with the problem. */
+  readonly place: readonly Key[];
+  readonly reason: string;
+  /** The keys from the root JSON value to the value with the problem. */
+  readonly at?: readonly Key[];
+  /** The type that the position needs, for a type issue (`#TYPE!`). */
+  readonly expected?: ValueType;
+  /** The type that the check found, for a type issue (`#TYPE!`). */
+  readonly found?: ValueType;
+}
+/** The options of a check. */
+interface CheckOptions {
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+  /** The names that the host binds at the root. `"any"` does not check the names. The default is no names. */
+  readonly names?: readonly string[] | "any";
+  /**
+   * The capabilities at the root. Without them, the check does not check the effects. The check narrows them for
+   * each part by the capability rules of the kinds, as a run does.
+   */
+  readonly caps?: readonly Cap[];
+  /**
+   * The verb that goes up the ladder at each document, as in `prepare`. The default is `eval`. `#NOEVAL` and the hook
+   * `known` follow this verb. The contract declares the effects and the value types of `eval` only, thus only `eval`
+   * checks them (VERB.CHECK). The type rule of an evaluator serves each verb.
+   */
+  readonly verb?: string;
+  /**
+   * With `true`, the check also checks the value types (TYPE.CHECK). It reads the type rules of the evaluators, the
+   * signatures of the operations and the value types of the contracts. A type issue has the code `#TYPE!`. The
+   * default is `false`, thus a host opts in.
+   */
+  readonly types?: boolean;
+  /** The type that the root document must have, for the check of the value types. */
+  readonly expect?: ValueType;
+  /**
+   * With `true`, the check also finds the problems of a run (RUN.CAN-WAIT). A runner under a parent without a runner
+   * gives `#CALC!` when an effect of its runners can reach the host. The parent cannot pass that wait through.
+   * A runner without such an effect does not wait, and the run drives it (RUN.DRIVE-NESTED). A kind that declares
+   * effects and has no runner gives `#CALC!` too, because in a run only a runner can wait for the host. The default is
+   * `false`.
+   */
+  readonly run?: boolean;
+  /**
+   * The value types of the roots and of the names of the host, for the check of the value types (TYPE.ROOTS). A
+   * reference then gets the type that its path reaches. Only a check with `types: true` reads them.
+   */
+  readonly rootTypes?: RootTypes;
+}
+/** The result of `typeCheck`. */
+interface Typing {
+  /** The type of the root document. It is `unknown` when the root has an issue. */
+  readonly type: ValueType;
+  /** Each issue of the check. The type issues come after the other issues. */
+  readonly issues: readonly Issue[];
+  /** The type of each document, in the order of the document. */
+  readonly places: readonly Typed[];
+}
+/**
+ * This function checks a document before an evaluation, by the contracts of its kinds. It finds the problems
+ * that an evaluation finds when it reaches them:
+ *
+ * - `#KIND?`: a kind that the world does not have.
+ * - `#NOEVAL`: no evaluator.
+ * - `#VALUE!`: a value without the shape of its kind.
+ * - `#PART?`: a value without a type.
+ * - `#DEPTH!`: too much nesting.
+ * - `#REF!` and `#STEP?`: a bad path.
+ * - `#NAME?`: a name that nothing binds. With the hook `known` of the machine, also a name that the language does not
+ *   have, for example an operation.
+ * - `#CAP!`: an effect that the capabilities of its document do not permit. A kind around the document can narrow them.
+ *   The hook `permits` of the machine decides, as in a run (CAP.PERMITS).
+ * - `#CALC!`: with the option `run`, a runner under a parent without a runner, when an effect of its runners can reach
+ *   the host. Also a kind that declares effects and has no runner (RUN.CAN-WAIT). The issue has the place and the
+ *   reason of the run.
+ * - `#TYPE!`: with the option `types`, a part whose type does not fit the type that its position needs (TYPE.CHECK).
+ *   A run does not always fail there, thus a type issue is a static finding, not an error of a run.
+ *
+ * The check asks the ladder for the verb of the options, `eval` by default (VERB.CHECK). The shapes, the paths and the
+ * names follow the contracts, thus they are the same for each verb. Only `eval` checks the declared effects.
+ *
+ * @param machine - The world and the code of the evaluators.
+ * @param doc - The document, as JSON.
+ * @param options - The type of a bare root value, the names of the host, the capabilities, the verb, the types and the run.
+ * @returns The problems, in the order of the document. The type issues come after the other issues.
+ */
+export declare function check(machine: Machine, doc: unknown, options?: CheckOptions): readonly Issue[];
+/**
+ * This function checks a document, and it also checks the value types (TYPE.CHECK, D25). It finds each issue of
+ * `check`. Then it synthesizes the type of each document from the types of its parts. It also checks each part
+ * against the type that its position needs. The type rule of the parent, the signature of an operation or the shape
+ * of the contract gives that type. A part with an issue gets the type `unknown`, thus one
+ * problem does not give a chain of issues.
+ *
+ * A type issue has the code `#TYPE!`, the type that the position needs (`expected`) and the type that the check found
+ * (`found`). It is a static finding: the evaluation of the document does not change.
+ *
+ * The option `rootTypes` gives the types of the roots and of the names of the host (TYPE.ROOTS). A reference then gets
+ * the type that its path reaches, and a field that a closed record does not have is a type issue (TYPE.CLOSED).
+ *
+ * @param machine - The world and the code of the evaluators, with their type rules.
+ * @param doc - The document, as JSON.
+ * @param options - The options of `check`, the type that the root must have and the types of the roots.
+ * @returns The type of the root, each issue, and the type of each document.
+ */
+export declare function typeCheck(machine: Machine, doc: unknown, options?: CheckOptions): Typing;
+//#endregion
+//#region src/typing.d.ts
+/** What a type rule gets for one document. */
+interface TypeInput {
+  /** The keys of the kind of the document, after each alias. */
+  readonly typePath: readonly Key[];
+  /** The document. A bare value has the type that its position declares. */
+  readonly doc: Envelope;
+  /** The type that the position of the document needs. It is `unknown` when the position needs no type. */
+  readonly expected: ValueType;
+  /** The paths of the parts in the value, in the order of the value. */
+  readonly paths: readonly (readonly Key[])[];
+  /** `true` when the position declares an address. A reference there gives a thing, not a value. */
+  readonly address: boolean;
+  readonly machine: Machine;
+  /**
+   * This function gives the type of a part that the check typed before. It gives `unknown` for a part that the check
+   * did not type yet, and for a part with an issue.
+   *
+   * @param path - The path of the part in the value.
+   * @returns The type of the part.
+   */
+  typeOf(path: readonly Key[]): ValueType;
+  /**
+   * This function gives the type of a name: the type that a kind around the document binds. Without such a kind, it
+   * gives the type from the option `rootTypes` of the host.
+   *
+   * @param name - The name.
+   * @returns The type, or `undefined` when neither a kind around the document nor the host gives the name a type.
+   */
+  nameType(name: string): ValueType | undefined;
+  /**
+   * This function gives the type of a root of the context at the document (TYPE.ROOTS). The host gives the types of
+   * `self`, `world` and `event` in the option `rootTypes`. A rule can give other types to its parts. The root `caps`
+   * always has the type `CAPS_TYPE`. A rule reads the type of a name with `nameType`, thus the root `names` gives
+   * `unknown`.
+   *
+   * @param root - The root.
+   * @returns The type. It is `unknown` for a root without a type.
+   */
+  rootType(root: string): ValueType;
+  /**
+   * This function examines a value type of a contract with `typeIssues`, one time in a check. The first problem of a
+   * type becomes an issue at the document. A term with a problem reads as `unknown`.
+   *
+   * @param type - The value type of the contract.
+   * @param what - What the type is, for the reason, for example "the result of ops.add".
+   * @returns The type.
+   */
+  contract(type: unknown, what: string): ValueType;
+}
+/** What a type rule tells for one part: the type that the part must have, and the types of the names of the part. */
+interface PartType {
+  /** The type that the part must have. */
+  readonly expect?: ValueType;
+  /** What the part is, for the reason of an issue, for example "argument 2 of ops.add". */
+  readonly what?: string;
+  /** The types of the names that the scope rules of the kind bind for the part. Each other name of the rules gets `unknown`. */
+  readonly names?: Readonly<Record<string, ValueType>>;
+  /**
+   * The types of the roots that the evaluator changes for the part, for example `self` for the attributes of a node.
+   * Each other root keeps its type. The parts of an evaluator without a rule get `unknown` for each of these roots.
+   */
+  readonly roots?: Omit<RootTypes, "names">;
+}
+/**
+ * The value types of the roots of a context, for a check of types (TYPE.ROOTS). The host gives them in the option
+ * `rootTypes` of `check` and `typeCheck`. A root without a type has the type `unknown`. The root `caps` always has the
+ * type `CAPS_TYPE`, because the kernel narrows it.
+ *
+ * The host keeps the types true: each root of the context holds a member of its type. A host thing, or a machine
+ * with `adopt`, keeps each step true too. The context binds each name of `names`, thus the option `names` of `check`
+ * lists it too.
+ */
+interface RootTypes {
+  /** The type of each name that the host binds. A name of the host without a type here has the type `unknown`. */
+  readonly names?: Readonly<Record<string, ValueType>>;
+  /** The type of `self`: the node or the position that the document is part of. */
+  readonly self?: ValueType;
+  /** The type of `world`, for example the schema of a store. The context then gives the world. */
+  readonly world?: ValueType;
+  /** The type of `event`: the event that started a run. */
+  readonly event?: ValueType;
+}
+/**
+ * The value type of the root `caps`: a list of capabilities. A capability is a text, or a list of keys. The kernel
+ * narrows the capabilities for each part, thus the host does not give this type.
+ */
+export declare const CAPS_TYPE: ValueType;
+/** A problem that a type rule finds. Its place is a part of the document, or the document itself. */
+interface TypeProblem {
+  /** The path of the part in the value. Without it, the problem is at the document. */
+  readonly path?: readonly Key[];
+  readonly reason: string;
+  readonly expected?: ValueType;
+  readonly found?: ValueType;
+}
+/**
+ * The type rule of an evaluator: what a check of types knows about the values that the evaluator gives. An evaluator
+ * object holds its rule in its field `type`. Thus the rule follows the evaluator that the ladder gives a document
+ * (TYPE.RULE).
+ */
+interface TypeRule {
+  /**
+   * This function tells the type that a part must have, and the types of the names for the part. The check asks it
+   * before it types the part. The parts that give the names of a rule `keysAt` come first.
+   *
+   * @param input - The document, the type that its position needs, and the types of the parts before.
+   * @param path - The path of the part in the value.
+   * @returns The type of the part and the types of its names.
+   */
+  readonly part?: (input: TypeInput, path: readonly Key[]) => PartType;
+  /**
+   * This function synthesizes the type of the document from the types of its parts. It must be sound: each value that
+   * the evaluator gives is a member of the type.
+   *
+   * @param input - The document, the type that its position needs, and the types of its parts.
+   * @param report - The function that gets each problem that the rule finds.
+   * @returns The type of the document.
+   */
+  readonly synth: (input: TypeInput, report: (problem: TypeProblem) => void) => ValueType;
+}
+/** The type of one document of a check of types. */
+interface Typed {
+  /** The keys from the root document to the document. */
+  readonly place: readonly Key[];
+  /** The keys from the root JSON value to the document. */
+  readonly at: readonly Key[];
+  /** The type that the check synthesized. A document with an issue has the type `unknown`. */
+  readonly type: ValueType;
+  /** The type that the position of the document needs, when it needs one. */
+  readonly expected?: ValueType;
+}
+//#endregion
+//#region src/evaluate.d.ts
+/**
+ * This function makes a context with names and capabilities. The other roots are empty, and an evaluation sets
+ * the world.
+ *
+ * @param names - The names and their values.
+ * @param caps - The effects that the term can cause.
+ * @param self - The node of the term, if it has one.
+ * @returns The context.
+ */
+export declare function makeContext(names?: Readonly<Record<string, unknown>>, caps?: readonly Cap[], self?: Thing): Context;
+/**
+ * This function gives the keys of a capability or of a kind of effect: a text is split at its dots.
+ *
+ * @param kind - The text or the keys.
+ * @returns The keys, as texts.
+ */
+export declare function capKeys(kind: Cap): readonly string[];
+/**
+ * This function tells if the capabilities permit an effect. A capability permits the kind of its name, and each kind
+ * under it: `store` permits `store.update`. The comparison is key by key, thus `fs.read` does not permit the
+ * kind with the keys `fs` and `read.json`.
+ *
+ * @param caps - The capabilities of the context.
+ * @param kind - The kind of the effect: a text with dots, or its keys.
+ * @returns `true` when one capability permits it.
+ */
+export declare function permits(caps: readonly Cap[], kind: Cap): boolean;
+/**
+ * This function narrows a context for a part: the part keeps only the capabilities that the context of its parent
+ * permits. Thus an evaluator cannot give a part more effects than it has.
+ *
+ * @param parent - The context of the parent.
+ * @param next - The context that the evaluator gives the part.
+ * @returns The context of the part.
+ */
+export declare function narrow(parent: Context, next: Context): Context;
+/**
+ * This function gives the capabilities that two lists both permit. An effect is permitted by the result when each
+ * list permits it. When the list `b` permits each capability of `a`, the result is the list `a` itself.
+ *
+ * @param a - The first list, for example the capabilities of a document.
+ * @param b - The second list, for example the list of a rule `only`.
+ * @returns The capabilities that both lists permit.
+ */
+export declare function intersectCaps(a: readonly Cap[], b: readonly Cap[]): readonly Cap[];
+/**
+ * This function gives the capabilities that a kind gives one of its parts, by the capability rules of its contract.
+ * The kernel and the static kit both use it, thus a run and a check narrow the same way.
+ *
+ * @param rules - The capability rules of the kind (`Kind.caps`).
+ * @param path - The path of the part in the value of the document.
+ * @param caps - The capabilities of the document.
  * @returns The capabilities of the part: the same list or a smaller one.
  */
 export declare function partCaps(rules: readonly CapsRule[] | undefined, path: readonly Key[], caps: readonly Cap[]): readonly Cap[];
@@ -844,6 +1507,7 @@ export declare function partCaps(rules: readonly CapsRule[] | undefined, path: r
 type Steps = Generator<Promise<unknown>, Result, unknown>;
 /** An effect that an evaluation caused, in the order of the effects. */
 interface Effect {
+  /** The number of effects before this effect. Under `all`, this number follows the order of the host. */
   readonly index: number;
   /** The kind of the effect, as a text with dots. */
   readonly kind: string;
@@ -858,9 +1522,75 @@ interface Effect {
   readonly place: readonly Key[];
   /** The context of the document that caused the effect: its names, its node and its capabilities. */
   readonly context: Context;
+  /**
+   * The stable address of the effect (RUN.ADDRESS). The order of the host does not change it. The address has the
+   * keys of the place, a `#` and the count of the earlier effects at that place in its scope. An example is
+   * `1/bind/x#0`. Each item of `all` is a scope, and its prefix comes first: `all0.1/` is the item 1 of the first `all`
+   * of the scope. The kernel gives each effect its address.
+   */
+  readonly address?: string;
+  /**
+   * The outcome of the effect: the result that it gave its document (RUN.OUTCOME). The kernel sets it when the answer
+   * comes. It stays `undefined` when the run stops first, for example at an abort.
+   */
+  readonly outcome?: Result;
+}
+/**
+ * One read of an evaluation: a path that code resolved, and what the path reached (READS.RECORD, D26). A schedule
+ * keeps the list of the reads of an evaluation. `verifyReads` resolves each free read again in a new context, and it
+ * tells if the old result stays valid.
+ */
+interface Read {
+  /** The path that the code resolved: its root, and its steps with the value of each step document. */
+  readonly path: readonly unknown[];
+  /**
+   * What the path reached: the thing, or the error of the resolution. A host thing stays a thing. An exception of the
+   * host gives its error value.
+   */
+  readonly reached: Result;
+  /**
+   * `true` when the read reads the context of the evaluation (READS.FREE). A read of a name that a kind binds, for
+   * example a name of `let`, is not free. A read of a `self` that a kind sets is not free either, for example a node
+   * of a tree. A path without a root is not free. `verifyReads` resolves only the free reads again.
+   */
+  readonly free: boolean;
+  /**
+   * `true` when the kernel adds the read, because a value keeps a root of the context for later (READS.KEPT). Such a
+   * read has the whole root as its path.
+   */
+  readonly kept?: true;
+  /** The hops of the resolution, only when the code asked for them. `verifyReads` then compares each hop too. */
+  readonly hops?: readonly Hop[];
 }
-/** The host side of a run: it does one effect, and gives its result. A throw or a rejection is an error value. */
+/**
+ * The host side of a run: it does one effect, and gives its result. A throw or a rejection is an error value, and a
+ * `Failure` gives its own error value. In an evaluation, this function is a mock: it answers at once, and a promise
+ * from it gives `#CALC!` (RUN.MOCK).
+ */
 type Perform = (effect: Effect) => unknown;
+/** The key of the journal of a recorder or of a replayer, on its function. Two copies of the kernel share it. */
+export declare const JOURNAL: unique symbol;
+/**
+ * The journal of a recorder or of a replayer, on its function `perform`. The kernel tells it the order in which the
+ * waits of each `all` settle. In a replay, the kernel asks the journal for that order (RUN.RECORD, RUN.REPLAY).
+ */
+interface Journal {
+  /**
+   * This function gets the item whose wait settled.
+   *
+   * @param all - The address of the `all`, for example `all0` or `all0.1/all0`.
+   * @param item - The index of the item.
+   */
+  readonly settled?: (all: string, item: number) => void;
+  /**
+   * This function gives the item whose wait settles next.
+   *
+   * @param all - The address of the `all`.
+   * @param waiting - The indices of the items that wait.
+   * @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;
+}
 /**
  * The runtime of one evaluation or run. Compiled code gets it with the context, and asks it to resolve paths and
  * to cause effects.
@@ -882,18 +1612,18 @@ interface Runtime {
    * This function causes an effect from an evaluator. In a run, an evaluator cannot cause an effect: the host does
    * each effect, thus only a runner can wait for it.
    *
-   * @param ctx - The context of the document.
+   * @param ctx - The context of the document. It gives only the capabilities that the document has (CAP.NARROW-CODE).
    * @param kind - The kind of the effect.
    * @param payload - The data of the effect.
    * @param place - The place of the document.
-   * @returns The payload, or an error value.
+   * @returns The answer of the mock, the payload without a mock, or an error value.
    */
   effect(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result;
   /**
    * This function causes an effect from a runner. In a run, the host does it, and the steps wait when the host
    * waits.
    *
-   * @param ctx - The context of the document.
+   * @param ctx - The context of the document. It gives only the capabilities that the document has (CAP.NARROW-CODE).
    * @param kind - The kind of the effect.
    * @param payload - The data of the effect.
    * @param place - The place of the document.
@@ -908,6 +1638,12 @@ interface Runtime {
    * @returns The steps that give each result, in the order of the list.
    */
   all(list: readonly (() => Steps)[], options?: AllOptions): Generator<Promise<unknown>, readonly Result[], unknown>;
+  /**
+   * This optional function tells the runtime that a value keeps the context for later, for example a closure of
+   * `fn`. A later use of the value reads that context, and no evaluation records these reads. Thus the list of reads
+   * gets a read of each root of the context (READS.KEPT).
+   */
+  keepsContext?(): void;
 }
 /**
  * The options of a drive of parts at the same time.
@@ -920,9 +1656,16 @@ interface AllOptions {
   readonly concurrency?: number;
   readonly failFast?: boolean;
 }
-/** Compiled code: the evaluation of a document in a context. */
+/**
+ * Compiled code: the evaluation of a document in a context. The code gives each part a context that it makes from
+ * its own context with a spread. The part then keeps only the capabilities of the document (CAP.NARROW-CODE). A
+ * context that the code makes without a spread gives the part no capabilities.
+ */
 type Code = (ctx: Context, rt: Runtime) => Result;
-/** Compiled code that can wait: the run of a document in a context. */
+/**
+ * Compiled code that can wait: the run of a document in a context. Its parts keep only the capabilities of the
+ * document, as for `Code`.
+ */
 type RunCode = (ctx: Context, rt: Runtime) => Steps;
 /** A compiled part: its place in its parent, its binding name, and its code. It has no field with its value. */
 interface CompiledPart {
@@ -1016,7 +1759,7 @@ interface EvalInput {
    *
    * @param kind - The kind of the effect, for example `log`.
    * @param payload - The data of the effect.
-   * @returns The payload, or the error `#CAP!`.
+   * @returns The answer of the mock, the payload without a mock, or an error value, for example `#CAP!`.
    */
   effect(kind: Cap, payload: unknown): Result;
   /**
@@ -1058,7 +1801,7 @@ interface RunInput {
   resolve(path: readonly unknown[], options?: ResolveOptions): Resolution;
   /**
    * This function causes an effect. In a run, the host does the effect, and the steps wait when the host waits. In
-   * an evaluation, the effect gives its payload. Take its result with `yield*`.
+   * an evaluation, a mock answers the effect at once, or the effect gives its payload. Take its result with `yield*`.
    *
    * @param kind - The kind of the effect, for example `log`.
    * @param payload - The data of the effect.
@@ -1094,6 +1837,11 @@ interface CompiledEvaluator {
    * @returns The code that evaluates the document.
    */
   readonly compile: (input: CompileInput) => Code;
+  /**
+   * The type rule of the evaluator: the value types that a check of types gives its documents and their parts
+   * (TYPE.RULE). Only a check reads it. An evaluator without a rule gives `unknown`.
+   */
+  readonly type?: TypeRule;
 }
 /** An evaluator: a function of its input, or a compiler. */
 type Evaluator = EvalFn | CompiledEvaluator;
@@ -1118,8 +1866,11 @@ type Runner = RunFn | CompiledRunner;
  * A machine: a world of kinds, and the code of each evaluator name, of each `deref` and of each walker.
  *
  * - `maxDepth`: the deepest nesting of documents. The default is 1000.
- * - `permits`: the rule of the host for an effect. The default is the function `permits` on the capabilities.
+ * - `permits`: the rule of the host for an effect. The default is the function `permits` on the capabilities. A run,
+ *   `check` and `effectsOf` ask it (CAP.PERMITS). In a check, its context has only the capabilities and the world.
  * - `known`: the names that the evaluators know, for `check`. Without it, `check` does not check such names.
+ * - `domains`: the value domains of the language, by the name of their base type (D22).
+ * - `facts`: the static facts of the names that a fallback kind covers, for `factsOf` (D24).
  */
 interface Machine extends Navigator {
   readonly evaluators: Readonly<Record<string, Evaluator>>;
@@ -1133,10 +1884,26 @@ interface Machine extends Navigator {
    * `check` asks it for each document with an evaluator. The function must be pure.
    *
    * @param path - The keys of the kind of the document, after each alias.
-   * @param evaluator - The name of the evaluator that the ladder gives the document.
+   * @param evaluator - The name of the evaluator that the ladder of the verb of the check gives the document.
    * @returns `true` when the evaluator knows the name, or else the reason of the `#NAME?` that a run gives.
    */
   readonly known?: (path: readonly Key[], evaluator: string) => true | string;
+  /**
+   * The value domains of the language, by the name of their base type, for example a color or a unit of length. A
+   * check reads them through `fits` and `member`. A domain of the kernel that the table does not name comes from
+   * `STD_DOMAINS`.
+   */
+  readonly domains?: Readonly<Record<string, Domain>>;
+  /**
+   * This function gives the static facts of the code of a name, for `factsOf` (D24). An example is the operation
+   * `["ops", "now"]` of a formula language: a fallback kind names it, and only the language knows that it is volatile.
+   * Each field of the answer wins over the same field of the contract of the kind. The function must be pure.
+   *
+   * @param path - The keys of the kind of the document, after each alias.
+   * @param code - The name of the evaluator of the document, or of the walker of a step document.
+   * @returns The facts, or `undefined` for the facts of the contract.
+   */
+  readonly facts?: (path: readonly Key[], code: string) => KindFacts | undefined;
 }
 /** One evaluation in a trace. The children are the evaluations of its parts, in the order that they started. */
 interface TraceNode {
@@ -1147,7 +1914,7 @@ interface TraceNode {
   readonly doc: Envelope;
   /** `true` when the type came from the container and not from an envelope. */
   readonly declared: boolean;
-  /** The answer of the ladder to the verb `eval`. */
+  /** The answer of the ladder to the verb of the plan, `eval` by default. */
   readonly answer: Answer;
   readonly side: Side;
   /** The names that the document could read when its evaluation started. */
@@ -1189,13 +1956,44 @@ interface RunOptions {
   readonly perform?: Perform;
   /** The type of a bare root value. */
   readonly declaredType?: string;
+  /**
+   * The verb of `run`, for example `format`. The default is `eval` (VERB.PREPARE). A plan keeps the verb of its
+   * `prepare`, thus `plan.run` does not read this option.
+   */
+  readonly verb?: string;
   /** A signal of the host. When it aborts, the run stops with `#ABORT`. */
   readonly signal?: StopSignal;
+  /**
+   * A list that gets each read, in the order of the resolutions (READS.RECORD). Under `all`, the order of the host
+   * decides the order of the reads of the items.
+   */
+  readonly reads?: Read[];
 }
 /** The options of an evaluation of a plan. */
 interface EvalOptions {
   /** A list that gets each effect, in its order. */
   readonly effects?: Effect[];
+  /**
+   * The mock of the host (RUN.MOCK). It answers each effect at once, and its answer is the result of the effect.
+   * Without it, an effect gives its payload (RUN.EVAL).
+   */
+  readonly perform?: Perform;
+  /**
+   * A list that gets each read, in the order of the resolutions (READS.RECORD). Without it, the plan records no read,
+   * and each resolution costs one more test.
+   */
+  readonly reads?: Read[];
+}
+/** The options of `evaluate`. */
+interface EvaluateOptions {
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+  /** The verb that goes up the ladder at each document, for example `format`. The default is `eval` (VERB.PREPARE). */
+  readonly verb?: string;
+  /** The mock of the host (RUN.MOCK). Without it, an effect gives its payload (RUN.EVAL). */
+  readonly perform?: Perform;
+  /** A list that gets each read, in the order of the resolutions (READS.RECORD). */
+  readonly reads?: Read[];
 }
 /** The options of a compilation. */
 interface PrepareOptions {
@@ -1203,6 +2001,11 @@ interface PrepareOptions {
   readonly declaredType?: string;
   /** `true`: each evaluation records a trace. The default is `false`. */
   readonly trace?: boolean;
+  /**
+   * The verb that goes up the ladder at each document, for example `format`. Each part evaluates with the same verb.
+   * The default is `eval` (VERB.PREPARE).
+   */
+  readonly verb?: string;
 }
 /** A compiled document. It evaluates many times, and it does the work of the ladder one time. */
 interface Plan {
@@ -1212,10 +2015,11 @@ interface Plan {
   /** The compiled root document. */
   readonly root: CompiledPart;
   /**
-   * This function evaluates the document. It does not wait, and the host does no effect.
+   * This function evaluates the document. It does not wait, and the host does no effect. A mock can answer each
+   * effect at once (RUN.MOCK).
    *
    * @param context - The names and the capabilities at the root.
-   * @param options - A list that gets the effects.
+   * @param options - A list that gets the effects, the mock of the host and a list that gets the reads.
    * @returns The result.
    */
   evaluate(context?: Context, options?: EvalOptions): Result;
@@ -1223,7 +2027,7 @@ interface Plan {
    * This function runs the document: the host does each effect, and the run waits when the host waits.
    *
    * @param context - The names and the capabilities at the root.
-   * @param options - The host code that does the effects, and a signal to stop the run.
+   * @param options - The host code that does the effects, a signal to stop the run and a list that gets the reads.
    * @returns The result, when the run ends.
    */
   run(context?: Context, options?: RunOptions): Promise<Result>;
@@ -1232,9 +2036,13 @@ interface Plan {
  * This function compiles a document into a plan. The ladder, the kinds and the parts are known after it. A plan
  * evaluates many times. A document that does not compile gives a plan that fails with the reason, when it evaluates.
  *
+ * The verb of the options goes up the ladder at each document, and each part evaluates with the same verb. The
+ * default verb is `eval`. A plan of another verb, for example `format`, evaluates, runs and traces as a plan of
+ * `eval` does (VERB.PREPARE).
+ *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document, as JSON.
- * @param options - The type of a bare root value, and a trace.
+ * @param options - The type of a bare root value, a trace and the verb.
  * @returns The plan.
  */
 export declare function prepare(machine: Machine, doc: unknown, options?: PrepareOptions): Plan;
@@ -1250,17 +2058,20 @@ export declare function planner(machine: Machine, options?: PrepareOptions): (do
 /**
  * This function evaluates a document, and records each evaluation in a trace.
  *
- * The verb `eval` goes up the ladder for each document. The kind of the document tells where its parts are. The
- * evaluator gets each part sealed: it can evaluate the part, and it cannot read its value. A failure gives an error
- * value, and the function does not throw. An effect is recorded in its order, and nothing does it.
+ * The verb of the options goes up the ladder for each document. The default verb is `eval`. The kind of the document
+ * tells where its parts are. The evaluator gets each part sealed: it can evaluate the part, and it cannot read its
+ * value.
+ *
+ * A failure gives an error value, and the function does not throw. An effect is recorded in its order, and the host
+ * does not do it. A mock can answer each effect at once (RUN.MOCK).
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document, as JSON.
  * @param context - The names and the capabilities at the root.
- * @param declaredType - The type of a bare root value.
+ * @param options - The type of a bare root value, or the options: that type, the mock of the host, the verb and a list for the reads.
  * @returns The result, the trace and the effects in their order.
  */
-export declare function evaluate(machine: Machine, doc: unknown, context?: Context, declaredType?: string): Run;
+export declare function evaluate(machine: Machine, doc: unknown, context?: Context, options?: string | EvaluateOptions): Run;
 /**
  * This function runs a document: an evaluation in which the host does each effect. A runner waits for its
  * parts and for its effects, thus a step can read the result of the step before. The part of the run before the
@@ -1269,7 +2080,7 @@ export declare function evaluate(machine: Machine, doc: unknown, context?: Conte
  * @param machine - The world, the evaluators and the runners.
  * @param doc - The document, as JSON.
  * @param context - The names and the capabilities at the root.
- * @param options - The host code that does the effects, the type of a bare root value, and a signal.
+ * @param options - The host code that does the effects, the type of a bare root value, a signal, the verb and a list for the reads.
  * @returns The result, the trace and the effects in their order, when the run ends.
  */
 export declare function run(machine: Machine, doc: unknown, context?: Context, options?: RunOptions): Promise<Run>;
@@ -1337,6 +2148,28 @@ export declare class MergeError extends Error {
    */
   constructor(conflicts: readonly MergeConflict[]);
 }
+/** What `extendDomain` adds to a domain: more parents, and the types of more steps. */
+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>>;
+}
+/**
+ * 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`.
+ *
+ * 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.
+ *
+ * @param name - The name of the domain.
+ * @param more - The parents and the steps to add.
+ * @returns The part, as a function of the merge before it.
+ */
+export declare function extendDomain(name: string, more: DomainExtension): (prev: Machine) => MachinePart;
 /**
  * This function merges worlds into one world, in the order of the parts. It does not change a part.
  *
@@ -1359,9 +2192,11 @@ export declare function mergeWorlds(...parts: readonly (WorldPart | ((prev: Worl
  *
  * - The worlds merge with the rules of `mergeWorlds`. The paths of their conflicts start with `"world"`.
  * - The tables `evaluators`, `runners`, `derefs` and `walkers` merge name by name. A function is equal only to itself.
+ * - The table `domains` merges name by name. Two domains with the same test, parents and summary give one domain (D22).
  * - The evaluator and the runner of a name are its code. A replacement of the name replaces both.
  * - A runner hides the evaluator of its name. Thus one part must give both, or the merge gives a conflict.
  * - The hooks `known` compose in the order of the parts. A hook does not answer for a name that a later part replaces.
+ *   The hooks `facts` compose the same way, and the first answer that is not `undefined` wins.
  * - Each other field, for example `permits`, `adopt`, `roots`, `plain` or `maxDepth`, is one value. Two different
  *   values are a conflict. An absent field has no value.
  *
@@ -1393,7 +2228,7 @@ export declare function restrictWorld(world: World, paths: readonly MergePath[])
  *
  * - A path that starts with `"world"` removes an entry of the world, with the rules of `restrictWorld`.
  * - `["evaluators", name]` or `["runners", name]` removes the code of the name: its evaluator and its runner.
- * - `["derefs", name]` and `["walkers", name]` remove one entry of their tables.
+ * - `["derefs", name]`, `["walkers", name]` and `["domains", name]` remove one entry of their tables.
  *
  * A path that names no entry changes nothing. The function does not change the machine. An own entry names an
  * evaluator directly, thus only a machine without the code of a name refuses each document that names it.
@@ -1440,102 +2275,16 @@ export declare function classify(shapes: readonly Shape$1[], value: Json): Class
  */
 export declare function tag(value: Json, kind: string): Envelope;
 //#endregion
-//#region src/parts.d.ts
-/** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
-interface PartSlot {
-  /** The keys from the value of the document to the part. */
-  readonly path: readonly Key[];
-  /** The path as one text, with a dot between the keys, for example `bind.x`. A part of a list has its index. */
-  readonly key: string;
-  readonly item: Json;
-  readonly of?: string;
-  /** `true` when the position of the part declares an address: a reference there gives what its path reaches. */
-  readonly address?: true;
-}
-/** The value of a document, split into its parts, by the shape that its kind declares. */
-type Split = {
-  readonly ok: true;
-  /** The parts, in the order of the value. */
-  readonly parts: readonly PartSlot[];
-  /** The value without the parts: a field that holds a part is not in it, and a list of parts gives `null`. */
-  readonly data: Json;
-  /**
-   * This function gives the value with a handle in the place of each part.
-   *
-   * @param handles - One handle for each part, in the order of `parts`.
-   * @returns The value with the handles.
-   */
-  fill<P>(handles: readonly P[]): unknown;
-} | {
-  readonly ok: false;
-  readonly reason: string;
-  readonly at: readonly Key[];
-};
-/**
- * This function splits a value into its parts, by the shape that its kind declares. The evaluator, the view and
- * the static kit use the same split, thus each one sees the same parts.
- *
- * @param shape - The shape of the value. The default is data.
- * @param value - The value of the document.
- * @returns The parts and a way to fill their places, or the reason why the value does not have the shape.
- */
-export declare function splitParts(shape: Shape | undefined, value: Json): Split;
-/**
- * The kind and the parts of one document: what `partsOf` gives. `ok` is `false` only when the value is not a
- * document: it has no envelope, and its position declares no type. A value without the shape of its kind gives a
- * failed `split`.
- */
-type DocParts = {
-  readonly ok: true;
-  /** The document. A bare value gets the type that its position declares. */
-  readonly doc: Envelope;
-  /** `true` when the type came from the position and not from an envelope. */
-  readonly declared: boolean;
-  /** The kind, or `undefined` when the world has no kind for the type. Then the value is data. */
-  readonly kind: Kind | undefined;
-  /** The keys of the kind after each alias, or `undefined` without a kind. */
-  readonly typePath: readonly Key[] | undefined;
-  /**
-   * The split of the value by the shape of the kind. The reason of a failed split is the reason of the `#VALUE!`
-   * of an evaluation: it names the kind. Its `at` gives the keys from the value to the problem.
-   */
-  readonly split: Split;
-} | {
-  readonly ok: false;
-  readonly code: "#PART?";
-  readonly reason: string;
-};
-/**
- * This function reads one document by the contracts of the world. It finds the kind of the type. A bare value gets
- * the type that its position declares. Then the function splits the value by the shape of the kind. The plan, the
- * reference interpreter and the static kit read each document with this function. Thus they see the same parts.
- *
- * @param world - The world of the kinds.
- * @param value - The document, or a bare value.
- * @param declaredType - The type that the position of a bare value declares.
- * @returns The document, its kind and its parts, or the reason why the value is not a document.
- */
-export declare function partsOf(world: World, value: unknown, declaredType?: string): DocParts;
-/**
- * This function tells if the path of a part matches a pattern of a scope rule. The key `"*"` of a pattern matches
- * each key.
- *
- * @param path - The path of the part.
- * @param pattern - The pattern.
- * @returns `true` when the path matches.
- */
-export declare function pathMatches(path: readonly Key[], pattern: readonly Key[]): boolean;
-//#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 code of the evaluators of the standard world, by name. */
-export declare const STD_EVALUATORS: Readonly<Record<string, Evaluator>>;
-/** The options of a walker `nearest`. */
-interface NearestOptions {
+//#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 code of the evaluators of the standard world, by name. */
+export declare const STD_EVALUATORS: Readonly<Record<string, Evaluator>>;
+/** The options of a walker `nearest`. */
+interface NearestOptions {
   /**
    * This function tells if a node has the wanted type. The default compares the field `type` of a host thing.
    *
@@ -1563,7 +2312,7 @@ export declare const STD_WALKERS: Readonly<Record<string, Walker>>;
  * order. In a run, an effect ends before the next step starts.
  */
 export declare const STD_RUNNERS: Readonly<Record<string, Runner>>;
-/** The machine of the examples: the standard world, its evaluators, its runners and its walkers. */
+/** The machine of the examples: the standard world, its evaluators, its runners, its walkers and the domains of the kernel. */
 export declare const STD_MACHINE: Machine;
 /** The capabilities of the examples at the root: the two effects of the standard world. */
 export declare const STD_CAPS: readonly string[];
@@ -1669,155 +2418,144 @@ interface Construct {
 /** Six constructs that show the range of the context. */
 export declare const CONSTRUCTS: readonly Construct[];
 //#endregion
-//#region src/static.d.ts
-/** One document that a walk visits. */
-interface DocVisit {
-  /** The keys from the root document to this document, through the parts. It is the place of an error. */
-  readonly place: readonly Key[];
-  /** The keys from the root JSON value to this document. A change at this path changes this document. */
-  readonly at: readonly Key[];
-  /** The visit of the document that holds this document as a part. The root has none. */
-  readonly parent?: DocVisit | undefined;
-  /** The keys from the value of the parent to this document: the path of the part. The root has none. */
-  readonly slot: readonly Key[];
-  /** The document. A bare value has the type that its position declares. */
-  readonly doc: Envelope;
-  /** `true` when the type came from the position and not from an envelope. */
-  readonly declared: boolean;
-  /** The kind of the document, when the world has it. */
-  readonly kind?: Kind | undefined;
-  /** The keys of the kind after each alias. */
-  readonly typePath?: readonly Key[] | undefined;
-  /** The number of documents around this document. The root has 0. */
-  readonly depth: number;
-  /** The names that the kinds around this document bind for it. */
-  readonly names: ReadonlySet<string>;
-  /** The names that a sequence around this document binds only for the parts after it. */
-  readonly later: ReadonlySet<string>;
-  /** `true` when the position of the document declares an address: a reference there is not a read of a value. */
-  readonly address?: true | undefined;
+//#region src/facts.d.ts
+/**
+ * One read of a document: a free reference, with its marks (FACTS.READS). A plan resolves the path of the reference
+ * when it evaluates the reference. The static read covers each path that the plan resolves there (FACTS.SOUND).
+ */
+interface StaticRead {
+  /** The root of the path. */
+  readonly root: Root;
+  /** The keys after the root, up to the first step that is not a key. */
+  readonly keys: readonly Key[];
   /**
-   * The capabilities of the document: the capabilities of the walk, narrowed by the capability rules of the kinds
-   * around it (`Kind.caps`). A walk without capabilities gives none here.
+   * `true` when each step after the root is a key. Then the plan resolves this path and no other. A step document,
+   * for example `nearest`, makes it `false`: the plan resolves a path that starts with the keys.
    */
-  readonly caps?: readonly Cap[] | undefined;
-}
-/** A position that a walk cannot read as a document. */
-interface WalkProblem {
-  /** The keys from the root document to the document with the problem. */
+  readonly exact: boolean;
+  /** `true` when only a lazy part reaches the reference. An evaluation can then give a value without this read (FACTS.LAZY). */
+  readonly lazy: boolean;
+  /** `true` when the position of the reference declares an address. The read gives what the path reaches, not its value. */
+  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. */
   readonly place: readonly Key[];
-  /** The keys from the root JSON value to the value with the problem. */
+  /** The keys from the root JSON value to the reference document. */
   readonly at: readonly Key[];
-  readonly code: "#PART?" | "#VALUE!";
-  readonly reason: string;
 }
-/** The options of a walk. */
-interface WalkOptions {
+/** The static facts of one document (D24). They depend only on the document and the machine, not on a context. */
+interface DocFacts {
+  /** The free references, in the order of the document (FACTS.READS). A reference to a name that a kind binds is not here. */
+  readonly reads: readonly StaticRead[];
+  /** `"run"` when one kind of the document is on the run side (FACTS.SIDE). */
+  readonly side: Side;
+  /** The kinds of the effects that the contracts declare, as texts with dots, each one time (FACTS.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
+   * its result depends only on what its reads give (FACTS.PURE).
+   */
+  readonly pure: boolean;
+  /** `true` when the result can change while each read gives the same thing, for example with a clock (FACTS.VOLATILE). */
+  readonly volatile: boolean;
+  /** The number of documents in the document: a hint of the cost of an evaluation. */
+  readonly size: number;
+}
+/** The options of `factsOf`. */
+interface FactsOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
-  /** The names that the host binds at the root. */
-  readonly names?: readonly string[];
-  /** The capabilities at the root. With them, each visit gets the capabilities of its document. */
-  readonly caps?: readonly Cap[];
   /**
-   * This function gets each position that is not a document.
+   * 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).
+   */
+  readonly verb?: string;
+  /**
+   * This function tells if a read reaches a volatile value of the host, for example a function that reads a clock.
+   * A read that it marks makes the document volatile (FACTS.VOLATILE).
    *
-   * @param problem - The position and the reason.
+   * @param read - The read.
+   * @returns `true` when the read reaches a volatile value.
    */
-  readonly problem?: (problem: WalkProblem) => void;
+  readonly volatile?: (read: StaticRead) => boolean;
 }
 /**
- * This function visits each document of a document: the root and each part at each depth, by the contracts of the
- * kinds. A part of a kind that the world does not have is not visited. With capabilities in the options, the walk
- * narrows them for each part by the rules of its kind, as a run does. The walk uses no stack of the host for the
- * depth, thus a deep document cannot overflow it. The time and the memory of a walk are linear in the size of the
- * document. A visit makes the keys of its place and of its path only when a reader asks for them.
+ * 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:
  *
- * @param world - The world of the kinds.
- * @param doc - The document, as JSON.
- * @param visit - The function that gets each document. It gives `"skip"` to not visit the parts of a document.
- * @param options - The type of a bare root value, the names, the capabilities and a function for the problems.
- */
-export declare function walk(world: World, doc: unknown, visit: (visit: DocVisit) => void | "skip", options?: WalkOptions): void;
-/** One reference of a document. */
-interface RefUse {
-  /** The visit of the reference document: its parent, its depth and the names that it sees. */
-  readonly visit: DocVisit;
-  /** The place of the reference document, through the parts. */
-  readonly place: readonly Key[];
-  /** The keys from the root JSON value to the reference document. */
-  readonly at: readonly Key[];
-  /** The path of the reference: its root and its steps. */
-  readonly path: readonly Json[];
-  readonly root: string;
-  /** `false` when a kind around the reference binds its first name. A reference to another root is free. */
-  readonly free: boolean;
-  /** `true` when the reference is an address: its position declares it. An address does not read a value. */
-  readonly address: boolean;
-}
-/**
- * This function finds each reference of a document: each document of the type `ref` that a walk reaches. A
- * reference to a name that a kind around it binds is not free. The others are what the document reads from
- * outside: its dependencies. When the kind `ref` has parts, the walk also finds the references in its step documents.
+ * - `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`.
+ * - `side` and `effects`: from the contract of each kind.
+ * - `pure`: each kind declares `pure`, 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.
  *
- * @param world - The world of the kinds.
- * @param doc - The document, as JSON.
- * @param options - The type of a bare root value. The names of the host do not change the result.
- * @returns The references, in the order of the document.
- */
-export declare function refsOf(world: World, doc: unknown, options?: WalkOptions): readonly RefUse[];
-/**
- * This function changes the free references of a document. The document is not changed: the function gives a new
- * document that shares each part without a change.
+ * The hook `facts` of the machine answers for a name that a fallback kind covers, for example an operation. Its
+ * answer wins over the contract of the kind. The contract of a kind does not describe the evaluator of an own
+ * 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.
  *
- * @param world - The world of the kinds.
+ * 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.
+ *
+ * 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
+ * them again only after an edit of the document or of the machine.
+ *
+ * @param machine - The world, the code and the hook `facts`.
  * @param doc - The document, as JSON.
- * @param change - The function that gives the new document of a reference, or `undefined` to keep it.
- * @param options - The type of a bare root value, and the names that the host binds at the root.
- * @returns The new document.
+ * @param options - The type of a bare root value, the verb and the volatile reads of the host.
+ * @returns The facts.
  */
-export declare function mapRefs(world: World, doc: unknown, change: (use: RefUse) => unknown, options?: WalkOptions): unknown;
-/** A problem that a check finds before a document runs. */
-interface Issue {
-  readonly code: ErrorCode;
-  /** The keys from the root document to the document with the problem. */
-  readonly place: readonly Key[];
-  readonly reason: string;
-  /** The keys from the root JSON value to the value with the problem. */
-  readonly at?: readonly Key[];
-}
-/** The options of a check. */
-interface CheckOptions {
+export declare function factsOf(machine: Machine, doc: unknown, options?: FactsOptions): DocFacts;
+//#endregion
+//#region src/effects.d.ts
+/** The options of `effectsOf`. */
+interface EffectsOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
-  /** The names that the host binds at the root. `"any"` does not check the names. The default is no names. */
-  readonly names?: readonly string[] | "any";
   /**
-   * The capabilities at the root. Without them, the check does not check the effects. The check narrows them for
-   * each part by the capability rules of the kinds, as a run does.
+   * The capabilities at the root. With them, the result keeps only the effects that the rule of the machine permits at
+   * their documents, as a run does (CAP.PERMITS). Without them, the root has each capability, and only the capability
+   * rules of the kinds remove an effect.
    */
   readonly caps?: readonly Cap[];
 }
 /**
- * This function checks a document before an evaluation, by the contracts of its kinds. It finds the problems
- * that an evaluation finds when it reaches them:
+ * This function gives the effects of a document that can reach the host (CAP.EFFECTS-OF, R2 P3). The result is the
+ * effects that the contract of each kind declares, without the effects that the capability rules around them remove.
+ * A rule `mask` removes each effect of its parts, and a rule `only` removes each effect outside its list.
  *
- * - `#KIND?`: a kind that the world does not have.
- * - `#NOEVAL`: no evaluator.
- * - `#VALUE!`: a value without the shape of its kind.
- * - `#PART?`: a value without a type.
- * - `#DEPTH!`: too much nesting.
- * - `#REF!` and `#STEP?`: a bad path.
- * - `#NAME?`: a name that nothing binds. With the hook `known` of the machine, also a name that the language does not
- *   have, for example an operation.
- * - `#CAP!`: an effect that the capabilities of its document do not permit. A kind around the document can narrow them.
+ * Without capabilities in the options, the result is the least authority of the document. A host that grants these
+ * kinds as capabilities grants each effect that a run of the document can give it. With capabilities, the result keeps
+ * only the effects that the rule of the machine permits at their documents.
  *
- * @param machine - The world and the code of the evaluators.
+ * The result covers each effect that an evaluation or a run gives the host (CAP.EFFECTS-SOUND). A procedure value keeps
+ * the capabilities of the document that made it, thus the effects of its body count at the body (CAP.LATENT). The
+ * contract describes the code of its kind. The code of an own entry for another evaluator is outside the result.
+ *
+ * @param machine - The world and its contracts, and the hook `permits`.
  * @param doc - The document, as JSON.
- * @param options - The type of a bare root value, the names of the host and the capabilities.
- * @returns The problems, in the order of the document.
+ * @param options - The type of a bare root value and the capabilities at the root.
+ * @returns The kinds of the effects, as texts with dots, each one time, in the order of the document.
  */
-export declare function check(machine: Machine, doc: unknown, options?: CheckOptions): readonly Issue[];
+export declare function effectsOf(machine: Machine, doc: unknown, options?: EffectsOptions): readonly string[];
+/**
+ * This function compares the latent effects that a procedure declares with the body of the procedure (CAP.LATENT). A
+ * procedure entry is a kind whose code evaluates the document of a procedure. Its field `effects` declares the latent
+ * effects: the effects that a call of the procedure can cause. `check` tests each call against this declaration.
+ *
+ * The function gives a `#CAP!` for each effect of the body that can reach the host and that the declaration does not
+ * permit. An effect that a kind in the body masks fails in the body, thus it is not a latent effect.
+ *
+ * @param machine - The world and its contracts.
+ * @param declared - The latent effects that the procedure declares, for example the field `effects` of its kind.
+ * @param body - The document of the procedure, as JSON.
+ * @param options - The type of a bare root value.
+ * @returns The issues, in the order of the body.
+ */
+export declare function checkLatent(machine: Machine, declared: readonly Cap[], body: unknown, options?: Omit<EffectsOptions, "caps">): readonly Issue[];
 //#endregion
 //#region src/formula.d.ts
 /** An operation of a formula language: a function of the values of its arguments. */
@@ -1845,6 +2583,14 @@ type ExtFn = (data: Json, context: Context) => Result;
  * - `check`: a check of the value of an operation, for example "a number must be finite".
  * - `combine`: the error of two or more failed parts of an operation, a `record` or a `list`. With it, each part
  *   evaluates, and one failed part gives its own error. Without it, the first error stops the evaluation.
+ * - `pure`: the pure operations, for `factsOf` (D24). `true` names each operation that is not volatile. The default
+ *   names no operation.
+ * - `volatile`: the operations whose results can change while their arguments stay the same, for example a clock.
+ * - `sigs`: the signatures of the operations, by their name, for a check of types (TYPE.SIGNATURE). A list gives
+ *   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.
  */
 interface FormulaProfile {
   readonly ops?: Readonly<Record<string, OpFn>> | ((name: string) => OpFn | undefined);
@@ -1857,6 +2603,22 @@ interface FormulaProfile {
   readonly missing?: (value: unknown) => boolean;
   readonly check?: (value: unknown, op: string) => Result | undefined;
   readonly combine?: (errors: readonly EvalError[]) => EvalError;
+  readonly pure?: true | readonly string[];
+  readonly volatile?: readonly string[];
+  readonly sigs?: Readonly<Record<string, Signature | readonly Signature[]>> | ((name: string) => Signature | readonly Signature[] | undefined);
+}
+/**
+ * The signature of an operation: the value types of its parameters and of its result (TYPE.SIGNATURE). A parameter of
+ * the type `unknown` at the end of `params` is optional. A later version can add a key, for example the type that a
+ * true result proves.
+ */
+interface Signature {
+  /** The types of the parameters, in order. */
+  readonly params: readonly ValueType[];
+  /** The type of each argument after the parameters. Without it, the operation takes no more arguments. */
+  readonly rest?: ValueType;
+  /** The type of the result. */
+  readonly to: ValueType;
 }
 /** The value of a name whose binding failed. A reference to the name gives the error. */
 export declare class Held {
@@ -1890,7 +2652,7 @@ export declare function jsTruthy(value: unknown): boolean;
 export declare function formulaKinds(): Readonly<Record<string, WorldEntry>>;
 /**
  * This function makes the evaluators of the formula kit for one language. Each evaluator compiles its document
- * one time into code.
+ * one time into code. Each evaluator also holds its type rule, for a check of types (TYPE.SYNTH).
  *
  * @param profile - The operations and the rules of the language.
  * @returns The evaluators, by their name.
@@ -1907,16 +2669,31 @@ export declare function formulaEvaluators(profile?: FormulaProfile): Readonly<Re
  * @returns The hook: `true`, or the reason of the `#NAME?` that the evaluator gives in a run.
  */
 export declare function formulaKnown(profile?: FormulaProfile): (path: readonly Key[], evaluator: string) => true | string;
+/**
+ * This function makes the hook `facts` of the formula kit for one profile (FACTS.PROFILE, D24). It answers for the
+ * operations and the extensions, because one fallback kind covers each of them.
+ *
+ * - An operation of `lazy` has a lazy rule for each argument.
+ * - An operation is pure when the profile names it in `pure`, or when `pure` is `true`. A volatile operation is not pure.
+ * - A standard extension is pure. An extension of the profile gets the context, thus it is not pure.
+ *
+ * @param profile - The operations, the extensions and their facts.
+ * @returns The hook: the facts of a name, or `undefined` for the facts of the contract.
+ */
+export declare function formulaFacts(profile?: FormulaProfile): (path: readonly Key[], code: string) => KindFacts | undefined;
 /**
  * This function makes a machine for a formula language. It merges the kit and the parts that the language adds with
  * `mergeMachines`. Thus a kind `ops.*` or a namespace `ops` of the language extends the namespace of the kit, and
  * the fallback of the kit stays. The hook `known` of the kit comes from the profile (`formulaKnown`). A hook `known`
- * of the language answers after it.
+ * of the language answers after it. The hook `facts` of the kit comes from the profile too (`formulaFacts`).
  *
  * A kind or an evaluator of the language that differs from the entry of the kit with its name is a conflict. The
  * language names the path in `replaces` to replace the entry, for example `["world", "kinds", "ref"]` or
  * `["evaluators", "formula.op"]`. Then the hook of the kit does not answer for a replaced evaluator.
  *
+ * The kit gives the domains of the kernel (`STD_DOMAINS`). Thus a domain of the language with the name `number` is a
+ * conflict. The language names `["domains", "number"]` in `replaces` to replace it.
+ *
  * @param profile - The operations and the rules of the language.
  * @param more - The parts of a machine that the language adds, with the paths of the entries that it replaces.
  * @returns The machine.
@@ -1941,16 +2718,26 @@ interface ReferenceOptions {
   readonly definitions?: Definitions;
   /** A list that gets each effect, in its order. */
   readonly effects?: Effect[];
+  /** The mock of the host (RUN.MOCK). It answers each effect at once. Without it, an effect gives its payload. */
+  readonly perform?: Perform;
+  /**
+   * The verb that goes up the ladder at each document, as in `prepare`. The default is `eval`. The reference reads
+   * each verb by the same rules (VERB.AGREE).
+   */
+  readonly verb?: string;
 }
 /**
  * This function evaluates a document by the rules, without a compilation. It is the reference of the plans: a plan,
  * a traced plan and the second tier of a language must give its results. It covers evaluations, not runs: an effect
- * gives its payload, and a part that waits gives `#CALC!`.
+ * gives the answer of the mock or its payload, and a part that waits gives `#CALC!`.
+ *
+ * The verb of the options goes up the ladder at each document, as in `prepare`. Each verb has the same rules: the
+ * ladder, the contract of the kind and the sealed parts (VERB.AGREE).
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document.
  * @param context - The names and the capabilities at the root.
- * @param options - The type of a bare root value, the definitions of compiled code, and a list for the effects.
+ * @param options - The type of a bare root value, the definitions of compiled code, a list for the effects, a mock and the verb.
  * @returns The result.
  */
 export declare function reference(machine: Machine, doc: unknown, context?: Context, options?: ReferenceOptions): Result;
@@ -1984,10 +2771,23 @@ interface TierResult {
   readonly result: Result;
   readonly effects?: readonly Effect[];
 }
+/** What `agree` gives the second tier of a language beside the document and the context. */
+interface TierInput {
+  /** The mock of the host, when `agree` has one (AGREE.MOCK). The tier answers each effect with it. */
+  readonly perform?: Perform;
+  /** The verb of `agree`, when its options name one (VERB.AGREE). A tier that does not serve the verb fails. */
+  readonly verb?: string;
+}
 /** The options of `agree`. */
 interface AgreeOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
+  /**
+   * The verb of each tier, as in `prepare`. The default is `eval`. The plan, the reference, the traced evaluation and a
+   * second evaluation each ask the ladder for this verb (VERB.AGREE). The second tier of a language gets it in its
+   * input.
+   */
+  readonly verb?: string;
   /** 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 and a second evaluation. */
@@ -1997,9 +2797,15 @@ interface AgreeOptions {
    *
    * @param doc - The document.
    * @param context - The context.
+   * @param input - The mock of the host and the verb, when `agree` has them.
    * @returns The result, or the result with the effects.
    */
-  readonly other?: (doc: unknown, context: Context) => Result | TierResult;
+  readonly other?: (doc: unknown, context: Context, input: TierInput) => Result | TierResult;
+  /**
+   * The mock of the host (RUN.MOCK, AGREE.MOCK). Each tier gets it, thus the tiers agree on documents with effects. A
+   * mock must give the same answer to the same effect, because each tier asks it again.
+   */
+  readonly perform?: Perform;
   /**
    * This function compares two values that the rules of `sameValue` do not know, for example two dates.
    *
@@ -2043,8 +2849,9 @@ type Agreement = {
  * errors have the same code and place. Each other object is the same only as itself, unless the rule of the caller
  * tells otherwise.
  *
- * `docEquals` uses the same rules for lists, plain records and the other objects. It has no rules for closures, for
- * `Held` values and for a rule of the caller. Thus two closures are equal there only when they are the same function.
+ * `docEquals` and `sameResult` use the same walk (D20). `docEquals` has no rules for closures, for `Held` values and
+ * for a rule of the caller. `sameResult` is for an early cutoff, thus a closure is the same there only as itself, and
+ * two errors also need the same reason.
  *
  * @param a - The first value.
  * @param b - The second value.
@@ -2056,16 +2863,625 @@ export declare function sameValue(a: unknown, b: unknown, equal?: (a: unknown, b
  * This function evaluates a document with a plan and with other tiers, and compares the results (PLAN.AGREES). Two
  * results agree when they have the same value by `sameValue`, or errors with the same code, and the same place when
  * both have one. The effects must have the same kinds, places and payloads, in the same order. A language gives its
- * own tier with the option `other`.
+ * own tier with the option `other`. Each tier gets the mock of the option `perform` (AGREE.MOCK).
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document.
  * @param context - The names and the capabilities at the root.
- * @param options - The tiers, the definitions for the reference, the rules of the comparison and the second tier.
+ * @param options - The tiers, the definitions for the reference, the rules of the comparison, the second tier and the mock.
  * @returns The result of the plan, or the first tier that disagrees and the reason.
  */
 export declare function agree(machine: Machine, doc: unknown, context?: Context, options?: AgreeOptions): Agreement;
 //#endregion
+//#region src/conform.d.ts
+/**
+ * An obligation that `conforms` checks. `C1` to `C8` are the obligations of host code in `docs/SEMANTICS.md`. `local`
+ * and `agree` are two premises of the simulation of the plan (SIM-PLAN).
+ *
+ * - `C1`: each context that the code gives a part, or an effect, has only the capabilities of its document.
+ * - `C2`: the code causes only the effects that the contract of the kind declares.
+ * - `C3`: each eager part evaluates when the result is a value, and a lazy part evaluates only when its result counts.
+ * - `C4`: the code of a pure kind causes no effect, and it reads the context only through `resolve`.
+ * - `C5`: the code reads its parts only through their handles, not through the JSON of the document.
+ * - `C6`: only a runner waits, and a runner passes each wait of its parts and its effects through.
+ * - `C7`: the code binds for a part each name that the scope rules give the part, and no other name.
+ * - `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.
+ */
+type Obligation = "C1" | "C2" | "C3" | "C4" | "C5" | "C6" | "C7" | "C8" | "local" | "agree";
+/** 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. */
+  readonly type: string;
+  /** The document. A probe document takes the place of each part. */
+  readonly doc: Envelope;
+  /** The result of each probe part, by the key of the part. */
+  readonly results: Readonly<Record<string, Result>>;
+  /** The keys of the probe parts that wait for the host before they give their result. Only a run has them. */
+  readonly waits: readonly string[];
+  /** The capabilities of the context of the document. */
+  readonly caps: readonly Cap[];
+  /** `true` in a run, in which the host does each effect and a part can wait. */
+  readonly running: boolean;
+}
+/** One obligation that the code breaks, with the reason and the first probe that shows it. */
+interface Finding {
+  readonly obligation: Obligation;
+  /** One or two sentences that tell what the code did. */
+  readonly reason: string;
+  readonly probe: ConformProbe;
+}
+/** The options of `conforms`. */
+interface ConformOptions {
+  /**
+   * The verb that the evaluator serves. The default is `eval`. The facts of a contract (`effects`, `pure` and `lazy`)
+   * describe only `eval`, thus `conforms` checks C2, C3 and C4 only for `eval` (D23).
+   */
+  readonly verb?: string;
+  /**
+   * The types of the probe documents. The default is each kind of the world whose verb names the evaluator. A fallback
+   * kind gives the key `probe`, for example `["ops", "probe"]`. The contract of the kind of each type applies.
+   */
+  readonly types?: readonly TypeRef[];
+  /**
+   * More values of probe documents, by the text of their type. A probe document takes the place of each part of such a
+   * value. Use them for data that the code needs, for example the key of `write`.
+   */
+  readonly values?: Readonly<Record<string, readonly Json[]>>;
+  /**
+   * The results that a probe part can give. The default holds numbers, truth values, a text, `null`, a list, a
+   * record, a function and two errors.
+   */
+  readonly results?: readonly Result[];
+  /**
+   * The definitional code of the compiled evaluators and runners, as for `reference`. A standard evaluator gets its
+   * definition from `STD_DEFINITIONS`.
+   */
+  readonly definitions?: Definitions;
+  /** The capabilities of half of the probes. The other half has none. The default is the declared effects and `probe`. */
+  readonly caps?: readonly Cap[];
+  /** The names of the context of each probe. */
+  readonly names?: Readonly<Record<string, unknown>>;
+  /** The seed of the random results. The same seed gives the same probes. The default is 1. */
+  readonly seed?: number;
+  /** The count of probes with random results for each probe document. The default is 12. */
+  readonly runs?: number;
+  /** The mock of the host (RUN.MOCK). It answers each effect at once. Without it, an effect gives its payload. */
+  readonly perform?: Perform;
+  /**
+   * This function compares two values that the rules of `sameValue` do not know, as in `agree`.
+   *
+   * @param a - The first value.
+   * @param b - The second value.
+   * @returns `true` or `false`, or `undefined` for the rules of `sameValue`.
+   */
+  readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
+}
+/**
+ * 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
+ * the contract of each kind that names the code, and it gives the probe parts chosen and random results.
+ *
+ * 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.
+ *
+ * @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.
+ * @param options - The verb, the types and the values of the probe documents, and the results of the probe parts. Also
+ *   the definitions, the capabilities, the names, the seed, the mock and the rule of equality.
+ * @returns The first finding of each obligation that the code breaks, in the order of the obligations.
+ * @throws {Error} The machine has no code with the name, or no kind names it and the options give no types.
+ */
+export declare function conforms(machine: Machine, name: string, options?: ConformOptions): readonly Finding[];
+//#endregion
+//#region src/same.d.ts
+/**
+ * This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
+ * work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
+ * only costs work. Thus each rule gives `false` when it is not sure.
+ *
+ * - Two values compare by the rules of `docEquals`. Lists and plain records compare by their items and fields. Each
+ *   other value compares with `Object.is`.
+ * - Thus `-0` is not `0`, and `NaN` is `NaN`. A date, a map and a closure of `fn` are the same only as themselves.
+ * - Two errors are the same when they have the same code, reason and place (RESULT.SAME-ERROR). The cause is not
+ *   compared. A `Held` value compares its error by the same rule.
+ * - A value and an error are not the same.
+ *
+ * `sameValue` of `agree` uses the same walk, with rules for two tiers (D20). It compares two closures by their
+ * parameters, and two errors by their code and place.
+ *
+ * @param a - The earlier result.
+ * @param b - The new result.
+ * @param equal - The rule of the host for two values, for example two dates. It answers first, and `undefined` gives the rules above.
+ * @returns `true` when the results are the same.
+ */
+export declare function sameResult(a: Result<unknown>, b: Result<unknown>, equal?: (a: unknown, b: unknown) => boolean | undefined): boolean;
+//#endregion
+//#region src/reads.d.ts
+/** The answer of `verifyReads`: the old result stays valid, or the first read that reaches another thing. */
+type ReadsCheck = {
+  readonly same: true;
+} | {
+  readonly same: false;
+  /** The index of the first changed read in the list. */
+  readonly index: number;
+  /** The first changed read, as the evaluation recorded it. */
+  readonly read: Read;
+  /** What the path of that read reaches in the new context. */
+  readonly now: Result;
+};
+/** The options of `verifyReads`. */
+interface VerifyOptions {
+  /**
+   * The rule of the host for two things, as in `sameResult`. It answers first, and `undefined` gives the rules of
+   * `sameResult`. An example is a rule for a host thing that keeps a version.
+   *
+   * @param a - The thing of the recorded read.
+   * @param b - The thing in the new context.
+   * @returns `true` when the two things are the same, or `undefined` for the rules of `sameResult`.
+   */
+  readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
+}
+/**
+ * This function tells if an old result stays valid in a new context (READS.VERIFY, D26). It resolves the path of
+ * each free read again, in the order of the list, and it compares what the path reaches with `sameResult`. It stops at
+ * the first read that reaches another thing, and it gives that read (READS.CHANGED).
+ *
+ * - A read that is not free reads a binding that a kind made from earlier reads, for example a name of `let`. The
+ *   function does not resolve it again.
+ * - A thing compares as in `sameResult`. Thus a host thing or a date is the same only as itself. A host gives a new
+ *   object for a new state, or the option `equal`.
+ * - A longer path through a name that holds a `Held` in the new context is a changed read. A reference of the formula
+ *   kit gives the error of that binding, and the resolution of the path does not show it.
+ * - The answer is sound only for a pure document (FACTS.PURE). A document with an effect, a volatile operation or an
+ *   extension of a profile can read outside `resolve`. The schedule asks `factsOf` first.
+ *
+ * The values of the context must not change in place, as PLAN.CACHE says for the documents. A value that changed in
+ * place is the same object, thus the function cannot see the change.
+ *
+ * @param target - The machine of the evaluation, or its plan.
+ * @param reads - The reads of the evaluation, from the option `reads`.
+ * @param context - The new context.
+ * @param options - The rule of the host for two things.
+ * @returns `{ same: true }` when each free read reaches the same thing, or else the first changed read.
+ */
+export declare function verifyReads(target: Machine | Plan, reads: readonly Read[], context: Context, options?: VerifyOptions): ReadsCheck;
+//#endregion
+//#region src/durable.d.ts
+/** The two epochs of a host (DURABLE.EPOCHS). Each epoch counts the changes of its level. */
+interface Epochs {
+  /** The count of the changes of the structure: a new machine, or an edit of a document. */
+  readonly structure: number;
+  /** The count of the changes of the data. A change of the structure is also a change of the data. */
+  readonly data: number;
+}
+/** The work of a durable cache since its start. A schedule reads it as a measure, not as a rule (R4). */
+interface DurableCounts {
+  /** The compilations: the calls of `prepare`. */
+  readonly compiles: number;
+  /** The calls of `factsOf`. */
+  readonly facts: number;
+  /** The evaluations of a plan. */
+  readonly evaluations: number;
+  /** The calls of `verifyReads`. */
+  readonly verifications: number;
+  /** The results that stayed without an evaluation. */
+  readonly reuses: number;
+}
+/** The options of `durable`. */
+interface DurableOptions {
+  /** The type of a bare root value, for each plan and each fact. */
+  readonly declaredType?: string;
+  /** The verb of each plan and each fact. The default is `eval` (VERB.PREPARE). */
+  readonly verb?: string;
+  /** The volatile reads of the host, as in `factsOf`. A document with such a read is not pure, thus it evaluates again after each change of data. */
+  readonly volatile?: FactsOptions["volatile"];
+  /** The rule of the host for two things, as in `verifyReads`. */
+  readonly equal?: VerifyOptions["equal"];
+}
+/**
+ * A cache of plans, facts and results with two levels of durability (D30). A host or a schedule tells the cache each
+ * change of the structure and each change of the data.
+ */
+interface Durable {
+  /** The machine of the current structure epoch. */
+  readonly machine: Machine;
+  /** The current epochs. A schedule builds again what depends on the whole structure when `structure` changes, for example a graph of the nodes. */
+  readonly epochs: Epochs;
+  /** The work since the start. */
+  readonly counts: DurableCounts;
+  /**
+   * This function gives the plan of a document. A document object compiles one time for a machine (DURABLE.STRUCTURE).
+   * A change of data compiles nothing (DURABLE.DATA).
+   *
+   * @param doc - The document, as JSON.
+   * @returns The plan.
+   */
+  plan(doc: unknown): Plan;
+  /**
+   * This function gives the static facts of a document. A document object computes its facts one time for a machine.
+   *
+   * @param doc - The document, as JSON.
+   * @returns The facts.
+   */
+  facts(doc: unknown): DocFacts;
+  /**
+   * This function gives the result of the document of a node (DURABLE.REUSE). The key names the node, and in one data
+   * epoch the context of a key gives the same data.
+   *
+   * - In the data epoch of its result, a key with the same plan gives that result again.
+   * - After a change of data, a pure document verifies its reads, and it keeps its result when each read is the same.
+   * - Each other document evaluates again.
+   *
+   * @param key - The name of the node in the host, for example the name of a cell.
+   * @param doc - The document of the node.
+   * @param context - The context of the node.
+   * @returns The result.
+   */
+  evaluate(key: unknown, doc: unknown, context: Context): Result;
+  /** This function tells the cache that the data changed: a context gives a new value (DURABLE.EPOCHS). */
+  changeData(): void;
+  /**
+   * This function tells the cache that the structure changed (DURABLE.EPOCHS). An edit of a document gives a new
+   * document object, and only that object compiles. A new machine drops each plan, each fact and each result.
+   *
+   * @param machine - The new machine, or `undefined` for an edit of a document.
+   */
+  changeStructure(machine?: Machine): void;
+  /**
+   * This function drops the result of a node, for example a node that the host removed.
+   *
+   * @param key - The name of the node.
+   */
+  forget(key: unknown): void;
+}
+/**
+ * This function makes a cache with two levels of durability for a host or a schedule (R4 P7, D30). The structure is
+ * the machine and the documents. The data is each value that a context gives: the names, `self`, `event`, the
+ * capabilities and the world of the host.
+ *
+ * - A plan and the facts depend only on the structure. A document object compiles one time for a machine, thus a
+ *   change of data compiles nothing (DURABLE.DATA).
+ * - A result depends on the data too. It stays in its data epoch. After a change of data, a pure document verifies
+ *   its reads with `verifyReads`, and each other document evaluates again.
+ * - An edit gives a new document object, thus only that document compiles. A new machine drops each plan, each fact
+ *   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.
+ *
+ * @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.
+ * @returns The cache.
+ */
+export declare function durable(machine: Machine, options?: DurableOptions): Durable;
+//#endregion
+//#region src/schedule.d.ts
+/** One edge of a graph of nodes: a static read of a node from the document of another node (SCHED.EDGES). */
+interface NodeEdge {
+  /**
+   * The node that the read reaches: the first key after the root `world`. It is `undefined` when the read can reach
+   * each node, for example the path `["world"]`, or a step document right after the root.
+   */
+  readonly to: string | undefined;
+  /** The keys after the node, up to the first step document: the field of the node that the read reaches (SCHED.GRAIN). */
+  readonly field: readonly Key[];
+  /** `true` when only a lazy part reaches the read. An evaluation can then give a value without it (FACTS.LAZY). */
+  readonly lazy: boolean;
+  /** The static read of `factsOf`, with its path, its place and its mark `exact`. */
+  readonly read: StaticRead;
+}
+/** One node of a schedule, with what the static facts tell about it (SCHED.GRAPH). */
+interface NodeInfo {
+  /** The name of the node: its key under the root `world`. */
+  readonly id: string;
+  /** The document of the node. */
+  readonly doc: unknown;
+  /** The static facts of the document. */
+  readonly facts: DocFacts;
+  /** The side of the node, from the facts. A node on the run side is a sink: no node reads it (SCHED.SIDE). */
+  readonly side: Side;
+  /** The edges to the nodes that the document can read, in the order of its reads. */
+  readonly edges: readonly NodeEdge[];
+}
+/** The options of `schedule`: the options of `durable`, and the context of the host. */
+interface ScheduleOptions extends DurableOptions {
+  /** The context of the host: the names, `self`, `event` and the capabilities. The schedule sets the root `world` to the nodes. */
+  readonly context?: Context;
+}
+/** The work of a schedule since its start: the work of its `durable` cache, and the demands ahead of a node. */
+interface ScheduleCounts extends DurableCounts {
+  /**
+   * The demands that a demand of the host made before its own node (SCHED.LONG-CHAIN). Each node that the eager edges
+   * reach, and that has no value in the data epoch, adds one.
+   */
+  readonly ahead: number;
+}
+/** The options of a run of a node. */
+interface NodeRunOptions {
+  /** The event that starts the run, at the root `event`. The default is the event of the context of the host. */
+  readonly event?: Thing;
+  /** The host code that does each effect, as in `run`. */
+  readonly perform?: Perform;
+  /** A signal that stops the run. */
+  readonly signal?: StopSignal;
+}
+/**
+ * The demand schedule of a graph of named nodes (D31). The host tells it each change of a node, of the machine and of
+ * its data. The schedule evaluates a node only when a host or another node reads it.
+ */
+interface Schedule {
+  /** The epochs of the schedule (DURABLE.EPOCHS). A schedule builds again what depends on the structure when `structure` changes. */
+  readonly epochs: Epochs;
+  /** The work of the schedule since its start: the compilations, the evaluations, the verifications, the reuses and the demands ahead. */
+  readonly counts: ScheduleCounts;
+  /** The context of each node in the current data epoch: the context of the host, with the nodes at the root `world`. */
+  readonly context: Context;
+  /**
+   * This function gives each node with its facts, its side and its edges (SCHED.GRAPH). The map stays the same object
+   * in one structure epoch, thus a schedule can keep what it computes from it, for example an order.
+   *
+   * @returns The nodes, by name.
+   */
+  graph(): ReadonlyMap<string, NodeInfo>;
+  /**
+   * This function gives the value of a node on demand (SCHED.DEMAND). A read of `world` in the document demands that
+   * node first. Each node evaluates at most one time in a data epoch.
+   *
+   * - First, the schedule demands each node that the eager edges reach, deepest first (SCHED.LONG-CHAIN).
+   * - After a change, a pure node verifies its reads, and it keeps its result when each read is the same (SCHED.STALE).
+   * - Each node of a cycle gives `#CYCLE!`, in each order of demands (SCHED.CYCLE).
+   * - A node on the run side gives `#REF!`, because the schedule does not evaluate it (SCHED.SIDE).
+   *
+   * @param id - The name of the node.
+   * @returns The result, or `#N/A` for a node that the schedule does not have.
+   */
+  read(id: string): Result;
+  /**
+   * This function adds a node, or gives a node a new document. It is a change of the structure. Only a new document
+   * object compiles (DURABLE.STRUCTURE).
+   *
+   * @param id - The name of the node.
+   * @param doc - The document of the node. It must not change in place after this call.
+   */
+  set(id: string, doc: unknown): void;
+  /**
+   * This function removes a node. It is a change of the structure, and a read of the node then gives `#N/A`.
+   *
+   * @param id - The name of the node.
+   * @returns `true` when the schedule had the node.
+   */
+  remove(id: string): boolean;
+  /**
+   * This function tells the schedule that the data of the host changed (DURABLE.EPOCHS). The values of a context do
+   * not change in place, thus new data comes in a new context, or through a host thing.
+   *
+   * @param context - The new context of the host, or `undefined` to keep the context.
+   */
+  changeData(context?: Context): void;
+  /**
+   * This function gives the schedule a new machine. It drops each plan, each fact and each result.
+   *
+   * @param machine - The new machine.
+   */
+  changeMachine(machine: Machine): void;
+  /**
+   * This function starts a run of the document of a node, and the host does each effect (SCHED.RUN). Only the host
+   * starts a run, for example at an event. A change of data does not start or repeat a run (L3).
+   *
+   * @param id - The name of the node.
+   * @param options - The event, the host code that does the effects, and a signal to stop the run.
+   * @returns The result, when the run ends.
+   */
+  run(id: string, options?: NodeRunOptions): Promise<Result>;
+}
+/**
+ * This function gives the edges of a node from the static facts of its document (SCHED.EDGES). Each read of the root
+ * `world` is an edge to the node of its first key. The keys after that key are the field of the edge (SCHED.GRAIN).
+ * A read of another root reads the data of the host, thus it is not an edge.
+ *
+ * A reference in the value of a node can lead a read to a third node (DEREF.COLLAPSE). The edges do not show such a
+ * read, but the reads of an evaluation do (S1d).
+ *
+ * @param facts - The static facts of the document of the node.
+ * @returns The edges, in the order of the reads.
+ */
+export declare function edgesOf(facts: DocFacts): readonly NodeEdge[];
+/**
+ * This function makes the demand schedule of a graph of named nodes (S1, R4, D31). A host gives each node a name and
+ * a document. The root `world` of each node reaches the other nodes by name. The context of the host gives the other
+ * roots.
+ *
+ * - `graph()` gives the facts, the side and the edges of each node, from `factsOf` and `edgesOf`.
+ * - `read(id)` evaluates a node on demand, through `durable`. A pure node verifies its reads after a change, and a
+ *   read of a node demands that node again. Thus only a node with a changed read evaluates again: the red-green
+ *   algorithm of rustc.
+ * - A node is on a cycle when its demand reaches itself through the reads of the evaluations. Each node of such a
+ *   strongly connected component gives `#CYCLE!`, whatever its document does with the error. The schedule finds the
+ *   components with the algorithm of Tarjan over the demands. Thus each order of demands gives the same values.
+ * - A demand of the host, or of a run, first demands each node that the eager edges reach, deepest first. Thus each
+ *   read of such a node finds a value, and a chain of 100000 nodes does not overflow the stack (SCHED.LONG-CHAIN).
+ *   Each such demand starts with no node in evaluation, thus the order of demands keeps the values of D31.
+ * - A node on the run side is a sink. Only `run` evaluates it, and only the host uses `run`.
+ *
+ * The host keeps the promises of `durable`. The documents and the values of a context do not change in place.
+ *
+ * @param machine - The machine of the first structure epoch.
+ * @param options - The options of `durable`, and the context of the host.
+ * @returns The schedule.
+ */
+export declare function schedule(machine: Machine, options?: ScheduleOptions): Schedule;
+//#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> {
+  /** The node that the read reaches. It is `undefined` when the read can reach each node (GRAPH.UNKNOWN). */
+  readonly to: Id | undefined;
+  /** `true` when only a lazy part reaches the read. An evaluation can then give a value without it (FACTS.LAZY). */
+  readonly lazy: boolean;
+}
+/** One node of a graph, with its edges. `NodeInfo` of a schedule is such a node. */
+interface GraphNode<Id> {
+  /** The edges to the nodes that the node reads. */
+  readonly edges: readonly GraphEdge<Id>[];
+  /** The side of the node. A node on the run side is a sink: no edge reaches it (SCHED.SIDE). The default is `derive`. */
+  readonly side?: Side;
+}
+/**
+ * A graph of nodes, by name. The order of the map is the order of the nodes in each answer. The function `graph` of
+ * a schedule gives such a graph. An edge to a name that is not in the map, or to a sink, is not an edge of the
+ * analysis.
+ */
+type NodeGraph<Id> = ReadonlyMap<Id, GraphNode<Id>>;
+/** The options of an analysis. */
+interface GraphOptions {
+  /**
+   * `true`: the analysis keeps only the eager edges with a target node. Such a read occurs in each evaluation in
+   * which each document around it gives a value (FACTS.LAZY). The default keeps each edge.
+   */
+  readonly eager?: boolean;
+}
+/** One static cycle of a graph (GRAPH.CYCLE). */
+interface GraphCycle<Id> {
+  /** The nodes of the cycle, in the order of the graph. */
+  readonly nodes: readonly Id[];
+  /**
+   * `true` when the eager edges with a target close the cycle. `false` when the cycle needs a lazy edge or an edge
+   * without a target. The value of each node still comes from the demand (D31).
+   */
+  readonly certain: boolean;
+}
+/**
+ * This function gives the strongly connected components of a graph of nodes (GRAPH.SCC), with the algorithm of
+ * Tarjan. It keeps its own stack, thus a chain of 100000 nodes does not overflow the stack of the host.
+ *
+ * - Each component comes after each component that it reads: the deepest component comes first.
+ * - A node that is on no cycle is a component of one node.
+ * - The nodes of a component are in the order of the graph.
+ *
+ * @param graph - The nodes, each with its edges.
+ * @param options - The option `eager` keeps only the eager edges with a target node.
+ * @returns The components, deepest first.
+ */
+export declare function components<Id>(graph: NodeGraph<Id>, options?: GraphOptions): readonly (readonly Id[])[];
+/**
+ * This function gives the height of each node: the order of a push schedule (GRAPH.ORDER). A schedule that evaluates
+ * the nodes from the lowest height up evaluates each node after each node that it reads, except on a cycle.
+ *
+ * - A node that reads no node outside its component has the height 0.
+ * - Each other node is one higher than the highest node that it reads outside its component.
+ * - The nodes of one component have one height.
+ * - An edge without a target reads each node that is not a sink (GRAPH.UNKNOWN).
+ *
+ * @param graph - The nodes, each with its edges.
+ * @param options - The option `eager` keeps only the eager edges with a target node.
+ * @returns The height of each node, in the order of the graph.
+ */
+export declare function heights<Id>(graph: NodeGraph<Id>, options?: GraphOptions): ReadonlyMap<Id, number>;
+/**
+ * This function puts the nodes in layers by their heights, in linear time (GRAPH.LAYERS). The first layer has the
+ * height 0. Two nodes of one layer read each other only inside one component. Thus a push schedule can evaluate the
+ * components of one layer at the same time.
+ *
+ * @param graph - The nodes, each with its edges.
+ * @param options - The option `eager` keeps only the eager edges with a target node.
+ * @returns The layers, from the height 0 up. Each layer keeps the order of the graph.
+ */
+export declare function nodeLayers<Id>(graph: NodeGraph<Id>, options?: GraphOptions): readonly (readonly Id[])[];
+/**
+ * This function gives the nodes that a set of observed nodes needs (GRAPH.NECESSARY). These are the observed nodes,
+ * and each node with a path of edges from them. A push schedule evaluates only these nodes. An observed name that is
+ * not a node of the graph adds nothing.
+ *
+ * @param graph - The nodes, each with its edges.
+ * @param observed - The nodes that the host shows or reads.
+ * @param options - The option `eager` keeps only the eager edges with a target node.
+ * @returns The necessary nodes, in the order of the graph.
+ */
+export declare function necessary<Id>(graph: NodeGraph<Id>, observed: Iterable<Id>, options?: GraphOptions): ReadonlySet<Id>;
+/**
+ * This function gives the static cycles of a graph (GRAPH.CYCLE): each component with two or more nodes, and each
+ * node with an edge to itself. A cycle of the eager edges with a target is certain, and `check` or a host can report
+ * it before a run. Another cycle is possible: an evaluation can skip a lazy read.
+ *
+ * - A component of all the edges that is also a component of the eager edges is one certain cycle.
+ * - Each other component of all the edges is one possible cycle, and each certain cycle in it comes after it.
+ * - A read can still fail before it occurs. Thus the demand of D31, not a static cycle, gives the value of each node.
+ *
+ * @param graph - The nodes, each with its edges.
+ * @returns The cycles, deepest first.
+ */
+export declare function cycles<Id>(graph: NodeGraph<Id>): readonly GraphCycle<Id>[];
+//#endregion
+//#region src/replay.d.ts
+/** One effect of a log: its address, its request and its outcome. */
+interface ReplayEntry {
+  /** The address of the effect (RUN.ADDRESS), for example `1#0` or `all0.1/1#0`. */
+  readonly address: string;
+  /** The kind of the effect, as a text with dots. */
+  readonly kind: string;
+  readonly payload: unknown;
+  /** The outcome of the effect (RUN.OUTCOME). It is absent when the recorded run stopped before the answer came. */
+  readonly outcome?: Result;
+  /** `true` when the host made the run wait for the outcome. */
+  readonly waited: boolean;
+}
+/** An item of an `all` whose wait settled in the recorded run. */
+interface ReplaySettle {
+  /** The address of the `all`, for example `all0` or `all0.1/all0`. */
+  readonly all: string;
+  /** The index of the item. */
+  readonly item: number;
+}
+/** The log of a run: each effect in the order of the requests, and the order in which the waits of each `all` settled. */
+interface ReplayLog {
+  readonly effects: readonly ReplayEntry[];
+  readonly settles: readonly ReplaySettle[];
+}
+/** A recorder: the function `perform` for a run, and the log of that run (RUN.RECORD). */
+interface Recorder {
+  /** The function to give the run. It gives each effect to the function `perform` of the host, and it records the effect. */
+  readonly perform: Perform;
+  /**
+   * This function gives the log of the run until this time. An effect gets its outcome when the answer comes.
+   *
+   * @returns The log.
+   */
+  log(): ReplayLog;
+}
+/** The options of a replayer. */
+interface ReplayOptions {
+  /**
+   * `false`: each answer comes at once, also for an effect that waited in the recorded run. An evaluation needs this
+   * value, because it does not wait. The default is `true`: an effect waits when it waited in the recorded run.
+   */
+  readonly wait?: boolean;
+}
+/**
+ * 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.
+ *
+ * @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.
+ */
+export declare function recorder(perform?: Perform): Recorder;
+/**
+ * This function makes a replayer: a function `perform` that answers each effect from a log, by its address (RUN.REPLAY). A
+ * 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.
+ *
+ * @param log - The log of a recorder.
+ * @param options - `wait: false` for an evaluation.
+ * @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 {
@@ -2147,5 +3563,53 @@ export declare function typesOf(world: World): readonly (readonly Key[])[];
  */
 export declare function generate(world: World, options: GenerateOptions): unknown;
 //#endregion
-export type { AgreeOptions, Agreement, Alias, AllOptions, Answer, AskOptions, Cap, CapsRule, CheckOptions, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, Construct, Context, Part as ContextPart, Definitions, DerefCode, DocParts, DocVisit, Edge, Effect, Envelope, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, Evaluator, ExtFn, Failed, FormulaProfile, GenerateOptions, Give, Header, Hop, HopBy, HostThing, Issue, Json, JsonRecord, KernelCode, Key, Kind, KindSource, LazyOp, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, OpFn, OrderProblem, Outcome, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartsSpec, Perform, Plan, PrepareOptions, Random, RefUse, ReferenceOptions, Resolution, ResolveCode, ResolveOptions, Result, Root, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, ScopeRule, Shape$1 as Shape, Side, Split, Step, StepSpec, Steps, StopSignal, Stored, Thing, Tier, TierResult, TraceNode, TypeRef, Use, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldPart };
+//#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. */
+interface TypeReading {
+  readonly type: ValueType;
+  readonly issues: readonly TypeIssue[];
+}
+/**
+ * This function makes a value type from a JSON Schema (TYPE.SCHEMA). A host uses it for the type of a root, for
+ * example the schema of a store for `world`. It reads this subset:
+ *
+ * - `type`: `null`, `boolean`, `number`, `integer` (as `number`), `string`, `object` and `array`, or a list of them.
+ * - `properties`, `required` and `additionalProperties` give a record. `false` closes it, and a property that is not
+ *   in `required` is optional.
+ * - `items` gives a list. `enum` and `const` give `one`. `anyOf` and `oneOf` give a union.
+ *
+ * The type holds each value that the schema accepts. Each keyword that the function does not read tests nothing, as
+ * `unknown`, and the issues name it. Examples are `minimum`, `pattern` and `allOf`. A schema with `$ref` or `nullable`
+ * reads as `unknown`, because these keywords can permit more values. A schema with more than one of `type`, `anyOf`
+ * and `oneOf` gives the type of the first, and an issue for each other. The function does not throw.
+ *
+ * @param schema - The schema, as JSON.
+ * @returns The type, and the problems of the reading with their keys in the schema.
+ */
+export declare function typeFromSchema(schema: unknown): TypeReading;
+/** The options of `typeFromSamples`. */
+interface SampleOptions {
+  /** `true`: the samples show each field, thus each record type is closed. The default is `false`. */
+  readonly closed?: boolean;
+}
+/**
+ * This function infers a value type from sample values (TYPE.SAMPLES), as a type provider of F# does. A host uses it
+ * for the type of a root, for example from some events.
+ *
+ * - `null`, a truth value, a number and a text give their base types, not their values.
+ * - The items of each list join into one type of items.
+ * - All records join into one record with each key of the samples. A key that a record does not have is optional.
+ * - Values of different forms give a union, as `join` gives. No samples give `never`.
+ * - A value without a type of the kernel, for example a function, gives `unknown`.
+ *
+ * Each sample is a member of the type. A record is open, because samples do not show that a field cannot exist. With
+ * `closed: true`, each record is closed, and a reference to a field that no sample has gives `#TYPE!`.
+ *
+ * @param values - The sample values.
+ * @param options - `closed: true` closes each record type.
+ * @returns The type.
+ */
+export declare function typeFromSamples(values: readonly unknown[], options?: SampleOptions): ValueType;
+//#endregion
+export type { AgreeOptions, Agreement, Alias, AllOptions, Answer, AskOptions, Cap, CapsRule, CheckOptions, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, 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, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PrepareOptions, Random, Read, ReadsCheck, Recorder, RefUse, ReferenceOptions, 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, Thing, Tier, TierInput, TierResult, TraceNode, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldPart };
 //# sourceMappingURL=index.d.ts.map