@mark1russell7/coeval 0.20.1 → 0.22.0

package/build/index.d.ts

@@ -251,6 +251,235 @@ export declare function thrown(error: unknown, who: string): Failed;
  * @returns The text.
  */
 export declare function describe(value: unknown): string;
+/**
+ * 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`, `undefined`, `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>>;
+  /**
+   * The codec of the members: it writes a member as JSON and reads it again (D40). A document holds a member as the
+   * standard extension `ext.domain`. A domain without a codec has no such document.
+   */
+  readonly codec?: DomainCodec;
+  /**
+   * The full list of the members of the domain, when the domain holds few values, for example `true` and `false` of
+   * `bool` (TYPE.FITS-FINITE). `fits` reads it: a base type with a list fits a type that holds each member of the list.
+   * The language keeps the list complete: each member of the domain is in the list. A value that fails a test of the
+   * domain does not count. The check reads a list of at most 64 values.
+   */
+  readonly values?: readonly unknown[];
+  /**
+   * Some members of the domain for the tests of `conforms`, for example `0` and `-1` of `number` (D99). The checks
+   * `truth` and `cover` add the samples of each domain to the palette. A sample that fails a test of a type does not
+   * count. The list is not a full list of the members, thus `fits` does not read it.
+   */
+  readonly samples?: readonly unknown[];
+  /**
+   * The covers of the domain (TYPE.FITS-COVER, D85). A cover is a list of domains under this domain, and its domains
+   * together hold each member of this domain. An example is a domain of negative numbers and a domain of the other
+   * numbers as a cover of `number`. `fits` reads it: a base type fits a union when each domain of a cover fits it.
+   *
+   * A split of a record also narrows a field of the domain to each domain of a cover (D90).
+   * The language keeps each cover true, and `fits` trusts it, as it trusts `values`. A cover that is empty, or that
+   * names this domain or a name that is not under it, does not count. `conforms` tests each cover from samples (D94).
+   */
+  readonly covers?: readonly (readonly string[])[];
+}
+/**
+ * The codec of a domain: it writes a member of the domain as JSON, and it reads the JSON again (D40). Both functions
+ * must be pure. `decode(encode(v))` must equal `v` by `sameValue` (EXT.ROUNDTRIP). The codec must give one JSON
+ * value for each member, thus the same value has the same document in each language (D12).
+ */
+interface DomainCodec {
+  /**
+   * This function writes a member of the domain as JSON.
+   *
+   * @param value - A member of the domain.
+   * @returns The JSON of the member.
+   */
+  readonly encode: (value: unknown) => Json;
+  /**
+   * This function reads the JSON of a member again. It throws for JSON that does not write a member.
+   *
+   * @param data - The JSON that `encode` gave.
+   * @returns The member.
+   */
+  readonly decode: (data: Json) => unknown;
+}
+/** 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 finite rule comes after these rules (TYPE.FITS-FINITE). A type with at most 64 members fits when each member
+ *   is a member of `expected`. Thus `bool` fits `{ "one": [true, false] }`.
+ * - A base type has few members when its domain or a parent declares `values`, as `null`, `undefined` and `bool` do.
+ *   A union, a `one`, a closed record of such types and a list of `never` also have few members.
+ * - The cover rule comes next (TYPE.FITS-COVER, D85). A base type fits a union or a `one` when each domain of a cover
+ *   fits. The cover is in `covers` of a domain of its line. Each domain of a cover is under the covered
+ *   domain. Thus a cover of `number` by `neg` and `nonneg` gives `number` a fit against `neg | nonneg`.
+ * - The split rule comes last (D84). An open record, or a closed record with more than 64 members, splits a field with
+ *   few members over a union. A closed record also splits over a `one`. Each record of the split narrows the field to
+ *   one member, and each record must fit.
+ *   Thus `{ "record": { "a": "bool" } }` fits a union of a record for each value of `a`.
+ * - A split also narrows a field of a record in a field, by its path (TYPE.FITS-PATH, D89). The fields of the record
+ *   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
+ *   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
+ * - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
+ *   its line splits into the domains of a cover. A field of a union without a finite list splits into its
+ *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only the
+ *   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ * - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
+ *   is the order of the line, then the order of the covers of each domain.
+ *
+ * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
+ * (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
+ * or a false cover makes the relation unsound for that domain.
+ *
+ * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. The
+ * failed tries of covers take from these 64 records too. A domain without `values` gets no finite rule, and
+ * neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
+ * covers. The function does not throw.
+ *
+ * @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[];
 /**
  * The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
  * global symbol, thus two copies of the kernel in one program know the things of each other.
@@ -415,8 +644,36 @@ interface WalkInput {
    */
   readonly visit?: (key: Key, thing: Thing) => void;
 }
-/** A walker: the code of the verb `step` of a kind of step documents. */
-type Walker = (input: WalkInput) => WalkResult;
+/** The input of the type rule of a walker: the data of the step document, and the type of the thing before the step. */
+interface WalkTypeInput {
+  /** The value of the step document. A step document with parts has no type rule, thus this value holds no part. */
+  readonly data: Json;
+  /** The type of the thing that the path reached before this step. */
+  readonly here: ValueType;
+}
+/**
+ * A walker: the code of the verb `step` of a kind of step documents. A plain function is a walker.
+ *
+ * A walker can hold a type rule in its field `type` (TYPE.WALKER, D121). The rule gives the type of each thing that
+ * the walker reaches from a thing of the type `here`. It must be sound, as the rule of an evaluator. A walker
+ * without a rule reaches the type `unknown`. A host gives the rule with `Object.assign(walker, { type })`.
+ */
+interface Walker {
+  /**
+   * This function answers the step document on the thing that the path reached.
+   *
+   * @param input - The data of the step document, the thing before the step and the ladder.
+   * @returns What the step reached, or the reason of a failure.
+   */
+  (input: WalkInput): WalkResult;
+  /**
+   * This optional function gives the type of what the walker reaches.
+   *
+   * @param input - The data of the step document and the type before the step.
+   * @returns The type of each thing that the walker reaches.
+   */
+  readonly type?: (input: WalkTypeInput) => ValueType;
+}
 /**
  * What a resolution needs: the world, and the code of the `deref` evaluators and of the walkers.
  *
@@ -532,235 +789,6 @@ export declare function resolve(nav: Navigator, ctx: Context, path: readonly unk
  * @returns The value.
  */
 export declare function valueOfThing(thing: Thing): unknown;
-/**
- * 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`, `undefined`, `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>>;
-  /**
-   * The codec of the members: it writes a member as JSON and reads it again (D40). A document holds a member as the
-   * standard extension `ext.domain`. A domain without a codec has no such document.
-   */
-  readonly codec?: DomainCodec;
-  /**
-   * The full list of the members of the domain, when the domain holds few values, for example `true` and `false` of
-   * `bool` (TYPE.FITS-FINITE). `fits` reads it: a base type with a list fits a type that holds each member of the list.
-   * The language keeps the list complete: each member of the domain is in the list. A value that fails a test of the
-   * domain does not count. The check reads a list of at most 64 values.
-   */
-  readonly values?: readonly unknown[];
-  /**
-   * Some members of the domain for the tests of `conforms`, for example `0` and `-1` of `number` (D99). The checks
-   * `truth` and `cover` add the samples of each domain to the palette. A sample that fails a test of a type does not
-   * count. The list is not a full list of the members, thus `fits` does not read it.
-   */
-  readonly samples?: readonly unknown[];
-  /**
-   * The covers of the domain (TYPE.FITS-COVER, D85). A cover is a list of domains under this domain, and its domains
-   * together hold each member of this domain. An example is a domain of negative numbers and a domain of the other
-   * numbers as a cover of `number`. `fits` reads it: a base type fits a union when each domain of a cover fits it.
-   *
-   * A split of a record also narrows a field of the domain to each domain of a cover (D90).
-   * The language keeps each cover true, and `fits` trusts it, as it trusts `values`. A cover that is empty, or that
-   * names this domain or a name that is not under it, does not count. `conforms` tests each cover from samples (D94).
-   */
-  readonly covers?: readonly (readonly string[])[];
-}
-/**
- * The codec of a domain: it writes a member of the domain as JSON, and it reads the JSON again (D40). Both functions
- * must be pure. `decode(encode(v))` must equal `v` by `sameValue` (EXT.ROUNDTRIP). The codec must give one JSON
- * value for each member, thus the same value has the same document in each language (D12).
- */
-interface DomainCodec {
-  /**
-   * This function writes a member of the domain as JSON.
-   *
-   * @param value - A member of the domain.
-   * @returns The JSON of the member.
-   */
-  readonly encode: (value: unknown) => Json;
-  /**
-   * This function reads the JSON of a member again. It throws for JSON that does not write a member.
-   *
-   * @param data - The JSON that `encode` gave.
-   * @returns The member.
-   */
-  readonly decode: (data: Json) => unknown;
-}
-/** 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 finite rule comes after these rules (TYPE.FITS-FINITE). A type with at most 64 members fits when each member
- *   is a member of `expected`. Thus `bool` fits `{ "one": [true, false] }`.
- * - A base type has few members when its domain or a parent declares `values`, as `null`, `undefined` and `bool` do.
- *   A union, a `one`, a closed record of such types and a list of `never` also have few members.
- * - The cover rule comes next (TYPE.FITS-COVER, D85). A base type fits a union or a `one` when each domain of a cover
- *   fits. The cover is in `covers` of a domain of its line. Each domain of a cover is under the covered
- *   domain. Thus a cover of `number` by `neg` and `nonneg` gives `number` a fit against `neg | nonneg`.
- * - The split rule comes last (D84). An open record, or a closed record with more than 64 members, splits a field with
- *   few members over a union. A closed record also splits over a `one`. Each record of the split narrows the field to
- *   one member, and each record must fit.
- *   Thus `{ "record": { "a": "bool" } }` fits a union of a record for each value of `a`.
- * - A split also narrows a field of a record in a field, by its path (TYPE.FITS-PATH, D89). The fields of the record
- *   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
- *   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
- * - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
- *   its line splits into the domains of a cover. A field of a union without a finite list splits into its
- *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only the
- *   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
- * - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
- *   is the order of the line, then the order of the covers of each domain.
- *
- * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
- * (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
- * or a false cover makes the relation unsound for that domain.
- *
- * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. The
- * failed tries of covers take from these 64 records too. A domain without `values` gets no finite rule, and
- * neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
- * covers. The function does not throw.
- *
- * @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[];
 /** The two sides of evaluation. `derive` is pure. `run` causes effects in order. */
 type Side = "derive" | "run";
 /**
@@ -905,12 +933,20 @@ interface LazyRule {
  * - `lazy`: the parts that an evaluation can skip and still give a value.
  * - `reads`: the roots that the code of the kind resolves as a whole, with the path of one root. The static facts
  *   give a read of each root at each document of the kind (D44). The tree node reads `self` this way.
+ * - `effects`: the effects that the code of `eval` can cause, in the form of the field `effects` of a kind (D27). In
+ *   the answer of the hook `facts`, it gives the effects of the code of a name. The contract of a kind does not
+ *   describe an own entry for another evaluator, thus only the hook can give its effects (CAP.OWN-EFFECTS, D118).
+ * - `drives`: the parts that the code of a runner evaluates itself, without a wait, in the form of the lazy rules. A
+ *   step under such a part cannot wait for the host. The check of a run then refuses a part that can wait there
+ *   (RUN.DRIVES, D119). Without `drives`, the check assumes that the runner passes each wait of its parts through.
  */
 interface KindFacts {
   readonly pure?: boolean;
   readonly volatile?: boolean;
   readonly lazy?: readonly LazyRule[];
   readonly reads?: readonly Root[];
+  readonly effects?: "type" | readonly string[];
+  readonly drives?: readonly LazyRule[];
 }
 /**
  * The declaration of one attribute of the nodes of a kind (D42). The last two rungs of the ladder of an attribute
@@ -924,6 +960,8 @@ interface KindFacts {
  * - `default`: the term that gives the value when no rung before it answers and the declaration has no fold.
  * - `circular`: a cycle of this attribute gives its fixed point, not `#CYCLE!` (TREE.CIRCULAR, D113). Only a cycle
  *   whose attributes each declare `circular` gives a fixed point.
+ * - `collect`: the value of a node without an answer of the first four rungs and without a fold. The node combines
+ *   the contributions of each node of its subtree (TREE.COLLECT, D122).
  */
 interface AttributeDeclaration {
   readonly copy?: boolean;
@@ -933,7 +971,35 @@ interface AttributeDeclaration {
   };
   readonly default?: Json;
   readonly circular?: CircularDeclaration;
+  readonly collect?: CollectDeclaration;
 }
+/**
+ * The declaration `collect` of an attribute (TREE.COLLECT, D122). The node of the attribute visits each node of its
+ * subtree. It visits the node itself first. Then it visits the nodes in its list `children`, in the order of the list.
+ *
+ * - `{ unit, combine }`: the collection starts with the term `unit`. The term `combine` then adds the contribution
+ *   of each node, with the names `acc` and `item`. A node contributes when its kind has an equation for the
+ *   attribute in `tree.contributes`.
+ * - `"names"`: the registry of binding names. Its value is a record from the header name of each node to its node
+ *   (TREE.NAMED). Two nodes with one name give `#VALUE!` at the read of the registry.
+ */
+type CollectDeclaration = {
+  readonly unit: Json;
+  readonly combine: Json;
+} | "names";
+/** A declaration `collect` that the kit can use, or the reason of a bad declaration (D122). */
+type CollectRule = {
+  readonly ok: true;
+  readonly names: true;
+} | {
+  readonly ok: true;
+  readonly names: false;
+  readonly unit: Json;
+  readonly combine: Json;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
 /**
  * The declaration `circular` of an attribute (TREE.CIRCULAR, D113). The attribute that a cycle reaches first leads it.
  * The leader evaluates again until no value of the cycle changes.
@@ -965,6 +1031,14 @@ type CircularRule = {
  * @returns The start value and the limit, or the reason when the declaration has no correct form.
  */
 export declare function circularOf(declared: unknown): CircularRule;
+/**
+ * This function reads the declaration `collect` of an attribute (D122). The tree kit, the reference, `check` and the
+ * graph of attribute instances read it with this one function.
+ *
+ * @param declared - The value of the field `collect`.
+ * @returns The rule of the collection, or the reason when the declaration has no correct form.
+ */
+export declare function collectOf(declared: unknown): CollectRule;
 /**
  * The tree contract of a kind (D42): the equations of the attributes of its nodes. Each equation is a document that
  * evaluates with the node as `self` and without capabilities. A bare equation gets the type `of` of the parts of the
@@ -974,12 +1048,70 @@ export declare function circularOf(declared: unknown): CircularRule;
  * - `down`: the attributes of each child of the node. `self` is this node. An equation sees the names `child`,
  *   `index` and `prev` (TREE.DOWN).
  * - `attributes`: the declarations of the attributes of the node, for the rungs `copy` and `default`.
+ * - `contributes`: the contribution of the node to each collection of an attribute (TREE.COLLECT, D122). An
+ *   equation sees no names.
+ * - `at`: the attributes with parameters of the node (TREE.AT, D124). Only the step `tree.at` reads them, and the
+ *   equation sees each parameter as a name.
  */
 interface TreeContract {
   readonly equations?: Readonly<Record<string, Json>>;
   readonly down?: Readonly<Record<string, Json>>;
   readonly attributes?: Readonly<Record<string, AttributeDeclaration>>;
+  readonly contributes?: Readonly<Record<string, Json>>;
+  readonly at?: Readonly<Record<string, AtEquation>>;
+}
+/**
+ * An attribute with parameters (TREE.AT, D124), as `paramAttr` in Kiama. The step `tree.at` gives the arguments. The
+ * equation evaluates with the node as `self`, and it sees each parameter as a name, for example `names.width`.
+ */
+interface AtEquation {
+  /** The names of the parameters. The step gives an argument for each of them, and no other argument. */
+  readonly params: readonly string[];
+  readonly equation: Json;
 }
+/** An entry of `tree.at` that the kit can use, or the reason of a bad entry (D124). */
+type AtRule = {
+  readonly ok: true;
+  readonly params: readonly string[];
+  readonly equation: Json;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
+/**
+ * This function reads an entry of the table `tree.at` (D124). The tree kit, the reference, `check` and the graph of
+ * attribute instances read it with this one function.
+ *
+ * @param declared - The entry.
+ * @returns The rule, or the reason when the entry has no correct form.
+ */
+export declare function atRuleOf(declared: unknown): AtRule;
+/** The arguments of a step `tree.at` (D124): the names of the equation and their key, or the reason of bad arguments. */
+type AtArgs = {
+  readonly ok: true;
+  readonly names: Readonly<Record<string, Json>>;
+  readonly key: string;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
+/**
+ * This function examines the arguments of a step `tree.at` (D124). The step gives an argument for each parameter, and
+ * no other argument. Each argument is JSON data. The key is the text of `argsKey`, thus two equal arguments give one key.
+ *
+ * @param params - The parameters of the attribute.
+ * @param args - The field `args` of the step.
+ * @returns The names of the equation and the key, or the reason.
+ */
+export declare function atArgsOf(params: readonly string[], args: unknown): AtArgs;
+/**
+ * This function gives the key of a JSON value (D124). The fields of a record are in the order of their names. Two
+ * values have the same key only when they are equal by DOC.EQUALS, thus `-0` and `0` have different keys.
+ *
+ * @param value - The value.
+ * @returns The JSON text, or `undefined` for a value that is not JSON data: a number that is not finite, a host value or a cycle.
+ */
+export declare function argsKey(value: unknown): string | undefined;
 /**
  * This function gives the type of a bare equation of a kind (D42). It is the type `of` of the shape of its parts, or
  * else the type `of` of the shape `rest` of a record. The plan, the reference and `check` read it with this one function.
@@ -3082,6 +3214,10 @@ interface AttributeAnswer {
  * A new plan gives new arrays. Thus a host keeps its cells by the identity of `place` and by `attribute`.
  * A host that keeps its cells by the keys of `place` can give the answer of another node or a stale answer.
  *
+ * An attribute with parameters gets one cell for each key of its arguments (TREE.AT-CELL, D124). Its `place` is a
+ * second array with the same keys, one for each key of a node. Its `attribute` is the JSON text of the name and the
+ * arguments, for example `["height",{"width":200}]`.
+ *
  * The function gives the answer of `compute`, or a kept answer. A host with signals gives a computed signal: a change
  * of its store then makes only the attributes that read the store compute again. Each demand gives a new `compute`, and
  * a cell that computes again uses the last one.
@@ -3286,7 +3422,9 @@ interface EffectsOptions {
  *
  * 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.
+ * contract describes the code of its kind. The contract does not describe the code of an own entry for another
+ * evaluator. The answer of the hook `facts` for that code gives its effects (CAP.OWN-EFFECTS, D118). Without an
+ * answer, its effects are outside the result.
  *
  * @param machine - The world and its contracts, and the hook `permits`.
  * @param doc - The document, as JSON.
@@ -4632,6 +4770,8 @@ interface AttributeVertex {
   readonly type: string;
   /** `true` when the kind of the node declares the attribute `circular` (TREE.CIRCULAR-CHECK). Else the field is absent. */
   readonly circular?: true;
+  /** The arguments of an instance of an attribute with parameters (TREE.AT-CHECK). Else the field is absent. */
+  readonly args?: Readonly<Record<string, Json>>;
 }
 /** One read of an attribute by the code of another attribute (D107). */
 interface AttributeEdge {
@@ -4957,11 +5097,14 @@ interface TypeReading {
  * - `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.
+ * - `$ref` reads a definition in `$defs` or `definitions` of the same schema (TYPE.SCHEMA-REF). Another reference, a
+ *   missing definition and a reference in a cycle read as `unknown`.
+ * - `allOf` and the other keywords of a schema give the meet of their types (TYPE.SCHEMA-ALLOF). Records merge their
+ *   fields, and a closed part keeps the merge closed.
  *
  * 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.
+ * `unknown`, and the issues name it. Examples are `minimum` and `pattern`. A schema with `nullable` or `$dynamicRef`
+ * reads as `unknown`, because these keywords can permit more values. 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.
@@ -4990,5 +5133,5 @@ interface SampleOptions {
  * @returns The type.
  */
 export declare function typeFromSamples(values: readonly unknown[], options?: SampleOptions): ValueType;
-export type { AgreeOptions, AgreeRunOptions, AgreeScheduleOptions, Agreement, Alias, AllOptions, Answer, AskOptions, AttributeAnswer, AttributeCell, AttributeCycle, AttributeDeclaration, AttributeEdge, AttributeGraph, AttributeGraphOptions, AttributeRung, AttributeTrace, AttributeVertex, Cap, CapsRule, CheckOptions, CircularDeclaration, CircularRule, Classification, Closure, Code, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Declared, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, DomainCodec, DomainExtension, Durable, DurableCounts, DurableOptions, Edge, Effect, EffectsOptions, Envelope, Epochs, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, EvaluateOptions, Evaluator, ExtFn, FactsOptions, Failed, Finding, FormulaProfile, GenerateOptions, Give, GraphCycle, GraphEdge, GraphNode, GraphOptions, Header, Hop, HopBy, HostThing, Issue, Journal, Json, JsonRecord, KernelCode, Key, Kind, KindFacts, KindSource, LazyOp, LazyRule, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, NodeEdge, NodeGraph, NodeInfo, NodeRunOptions, Obligation, OpFn, OrderProblem, Outcome, ParseResult, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PlanRunOptions, PrepareOptions, PrintOptions, Random, Read, ReadPrints, ReadsCheck, Recorder, RefUse, ReferenceOptions, ReferenceRunOptions, ReplayCausePartsJson, ReplayEntry, ReplayEntryJson, ReplayErrorJson, ReplayExceptionJson, ReplayLog, ReplayLogJson, ReplayOptions, ReplayPartJson, ReplayPartsJson, ReplayResultJson, ReplaySettle, Resolution, ResolveCode, ResolveOptions, Result, Root, RootTypes, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, SampleOptions, Schedule, ScheduleAgreement, ScheduleAgreementCounts, ScheduleCounts, ScheduleEngine, ScheduleEngineFactory, ScheduleEngineStart, ScheduleOptions, ScopeRule, Shape$1 as Shape, Side, Signature, Split, StaticRead, Step, StepKey, StepLadder, StepNeed, StepReason, StepRefusal, StepSpec, StepWalk, Steps, StopSignal, Stored, SyntaxAssoc, SyntaxCalls, SyntaxEnvelopes, SyntaxFixity, SyntaxForm, SyntaxFormArgs, SyntaxHeader, SyntaxIssue, SyntaxLiterals, SyntaxOperator, SyntaxProfile, SyntaxRefPattern, SyntaxRefs, Thing, Tier, TierInput, TierResult, TraceNode, TreeContract, TreeOptions, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerbEffects, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, Walker, World, WorldEntry, WorldIssue, WorldOptions, WorldPart };
+export type { AgreeOptions, AgreeRunOptions, AgreeScheduleOptions, Agreement, Alias, AllOptions, Answer, AskOptions, AtArgs, AtEquation, AtRule, AttributeAnswer, AttributeCell, AttributeCycle, AttributeDeclaration, AttributeEdge, AttributeGraph, AttributeGraphOptions, AttributeRung, AttributeTrace, AttributeVertex, Cap, CapsRule, CheckOptions, CircularDeclaration, CircularRule, Classification, Closure, Code, CollectDeclaration, CollectRule, CompileInput, CompiledEvaluator, CompiledPart, CompiledRunner, ConformOptions, ConformProbe, Construct, Context, Part as ContextPart, Declared, Definitions, DerefCode, DocFacts, DocParts, DocVisit, Domain, DomainCodec, DomainExtension, Durable, DurableCounts, DurableOptions, Edge, Effect, EffectsOptions, Envelope, Epochs, ErrorCode, EvalError, EvalFn, EvalInput, EvalOptions, EvaluateOptions, Evaluator, ExtFn, FactsOptions, Failed, Finding, FormulaProfile, GenerateOptions, Give, GraphCycle, GraphEdge, GraphNode, GraphOptions, Header, Hop, HopBy, HostThing, Issue, Journal, Json, JsonRecord, KernelCode, Key, Kind, KindFacts, KindSource, LazyOp, LazyRule, Lookup, Machine, MachinePart, MergeConflict, MergePath, NamesSource, Namespace, Navigator, NearestOptions, NodeEdge, NodeGraph, NodeInfo, NodeRunOptions, Obligation, OpFn, OrderProblem, Outcome, ParseResult, Part$1 as Part, PartInfo, Shape as PartShape, PartSlot, PartType, PartsSpec, Perform, Plan, PlanRunOptions, PrepareOptions, PrintOptions, Random, Read, ReadPrints, ReadsCheck, Recorder, RefUse, ReferenceOptions, ReferenceRunOptions, ReplayCausePartsJson, ReplayEntry, ReplayEntryJson, ReplayErrorJson, ReplayExceptionJson, ReplayLog, ReplayLogJson, ReplayOptions, ReplayPartJson, ReplayPartsJson, ReplayResultJson, ReplaySettle, Resolution, ResolveCode, ResolveOptions, Result, Root, RootTypes, Run, RunCode, RunFn, RunInput, RunOptions, RunPart, Rung, Runner, Runtime, SampleOptions, Schedule, ScheduleAgreement, ScheduleAgreementCounts, ScheduleCounts, ScheduleEngine, ScheduleEngineFactory, ScheduleEngineStart, ScheduleOptions, ScopeRule, Shape$1 as Shape, Side, Signature, Split, StaticRead, Step, StepKey, StepLadder, StepNeed, StepReason, StepRefusal, StepSpec, StepWalk, Steps, StopSignal, Stored, SyntaxAssoc, SyntaxCalls, SyntaxEnvelopes, SyntaxFixity, SyntaxForm, SyntaxFormArgs, SyntaxHeader, SyntaxIssue, SyntaxLiterals, SyntaxOperator, SyntaxProfile, SyntaxRefPattern, SyntaxRefs, Thing, Tier, TierInput, TierResult, TraceNode, TreeContract, TreeOptions, TypeInput, TypeIssue, TypeProblem, TypeReading, TypeRef, TypeRule, Typed, Typing, Use, ValueType, VerbEffects, VerifyOptions, WalkInput, WalkOptions, WalkProblem, WalkResult, WalkTypeInput, Walker, World, WorldEntry, WorldIssue, WorldOptions, WorldPart };
 //# sourceMappingURL=index.d.ts.map